/*

 * Copyright (c) 2000, 2014, 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.jpeg;

import javax.imageio.IIOException;

import javax.imageio.ImageWriter;

import javax.imageio.ImageWriteParam;

import javax.imageio.IIOImage;

import javax.imageio.ImageTypeSpecifier;

import javax.imageio.metadata.IIOMetadata;

import javax.imageio.metadata.IIOMetadataFormatImpl;

import javax.imageio.metadata.IIOInvalidTreeException;

import javax.imageio.spi.ImageWriterSpi;

import javax.imageio.stream.ImageOutputStream;

import javax.imageio.plugins.jpeg.JPEGImageWriteParam;

import javax.imageio.plugins.jpeg.JPEGQTable;

import javax.imageio.plugins.jpeg.JPEGHuffmanTable;

import org.w3c.dom.Node;

import java.awt.image.Raster;

import java.awt.image.WritableRaster;

import java.awt.image.SampleModel;

import java.awt.image.DataBuffer;

import java.awt.image.DataBufferByte;

import java.awt.image.ColorModel;

import java.awt.image.IndexColorModel;

import java.awt.image.ColorConvertOp;

import java.awt.image.RenderedImage;

import java.awt.image.BufferedImage;

import java.awt.color.ColorSpace;

import java.awt.color.ICC_ColorSpace;

import java.awt.color.ICC_Profile;

import java.awt.Dimension;

import java.awt.Rectangle;

import java.awt.Transparency;

import java.io.IOException;

import java.util.List;

import java.util.ArrayList;

import java.util.Iterator;

import sun.java2d.Disposer;

import sun.java2d.DisposerRecord;

public class JPEGImageWriter extends ImageWriter {

    ///////// Private variables

    private boolean debug = false;

    /**

     * The following variable contains a pointer to the IJG library

     * structure for this reader.  It is assigned in the constructor

     * and then is passed in to every native call.  It is set to 0

     * by dispose to avoid disposing twice.

     */

    private long structPointer = 0;

    /** The output stream we write to */

    private ImageOutputStream ios = null;

    /** The Raster we will write from */

    private Raster srcRas = null;

    /** An intermediate Raster holding compressor-friendly data */

    private WritableRaster raster = null;

    /**

     * Set to true if we are writing an image with an

     * indexed ColorModel

     */

    private boolean indexed = false;

    private IndexColorModel indexCM = null;

    private boolean convertTosRGB = false;  // Used by PhotoYCC only

    private WritableRaster converted = null;

    private boolean isAlphaPremultiplied = false;

    private ColorModel srcCM = null;

    /**

     * If there are thumbnails to be written, this is the list.

     */

    private List<? extends BufferedImage> thumbnails = null;

    /**

     * If metadata should include an icc profile, store it here.

     */

    private ICC_Profile iccProfile = null;

    private int sourceXOffset = 0;

    private int sourceYOffset = 0;

    private int sourceWidth = 0;

    private int [] srcBands = null;

    private int sourceHeight = 0;

    /** Used when calling listeners */

    private int currentImage = 0;

    private ColorConvertOp convertOp = null;

    private JPEGQTable [] streamQTables = null;

    private JPEGHuffmanTable[] streamDCHuffmanTables = null;

    private JPEGHuffmanTable[] streamACHuffmanTables = null;

    // Parameters for writing metadata

    private boolean ignoreJFIF = false;  // If it's there, use it

    private boolean forceJFIF = false;  // Add one for the thumbnails

    private boolean ignoreAdobe = false;  // If it's there, use it

    private int newAdobeTransform = JPEG.ADOBE_IMPOSSIBLE;  // Change if needed

    private boolean writeDefaultJFIF = false;

    private boolean writeAdobe = false;

    private JPEGMetadata metadata = null;

    private boolean sequencePrepared = false;

    private int numScans = 0;

    /** The referent to be registered with the Disposer. */

    private Object disposerReferent = new Object();

    /** The DisposerRecord that handles the actual disposal of this writer. */

    private DisposerRecord disposerRecord;

    ///////// End of Private variables

    ///////// Protected variables

    protected static final int WARNING_DEST_IGNORED = 0;

    protected static final int WARNING_STREAM_METADATA_IGNORED = 1;

    protected static final int WARNING_DEST_METADATA_COMP_MISMATCH = 2;

    protected static final int WARNING_DEST_METADATA_JFIF_MISMATCH = 3;

    protected static final int WARNING_DEST_METADATA_ADOBE_MISMATCH = 4;

    protected static final int WARNING_IMAGE_METADATA_JFIF_MISMATCH = 5;

    protected static final int WARNING_IMAGE_METADATA_ADOBE_MISMATCH = 6;

    protected static final int WARNING_METADATA_NOT_JPEG_FOR_RASTER = 7;

    protected static final int WARNING_NO_BANDS_ON_INDEXED = 8;

    protected static final int WARNING_ILLEGAL_THUMBNAIL = 9;

    protected static final int WARNING_IGNORING_THUMBS = 10;

    protected static final int WARNING_FORCING_JFIF = 11;

    protected static final int WARNING_THUMB_CLIPPED = 12;

    protected static final int WARNING_METADATA_ADJUSTED_FOR_THUMB = 13;

    protected static final int WARNING_NO_RGB_THUMB_AS_INDEXED = 14;

    protected static final int WARNING_NO_GRAY_THUMB_AS_INDEXED = 15;

    private static final int MAX_WARNING = WARNING_NO_GRAY_THUMB_AS_INDEXED;

    ///////// End of Protected variables

    ///////// static initializer

    static {

        java.security.AccessController.doPrivileged(

            new java.security.PrivilegedAction<Void>() {

                public Void run() {

                    return null;

                }

            });

        initWriterIDs(JPEGQTable.class,

                      JPEGHuffmanTable.class);

    }

    //////// Public API

    public JPEGImageWriter(ImageWriterSpi originator) {

        super(originator);

        structPointer = initJPEGImageWriter();

        disposerRecord = new JPEGWriterDisposerRecord(structPointer);

        Disposer.addRecord(disposerReferent, disposerRecord);

    }

    public void setOutput(Object output) {

        setThreadLock();

        try {

            cbLock.check();

            super.setOutput(output); // validates output

            resetInternalState();

            ios = (ImageOutputStream) output; // so this will always work

            // Set the native destination

            setDest(structPointer);

        } finally {

            clearThreadLock();

        }

    }

    public ImageWriteParam getDefaultWriteParam() {

        return new JPEGImageWriteParam(null);

    }

    public IIOMetadata getDefaultStreamMetadata(ImageWriteParam param) {

        setThreadLock();

        try {

            return new JPEGMetadata(param, this);

        } finally {

            clearThreadLock();

        }

    }

    public IIOMetadata

        getDefaultImageMetadata(ImageTypeSpecifier imageType,

                                ImageWriteParam param) {

        setThreadLock();

        try {

            return new JPEGMetadata(imageType, param, this);

        } finally {

            clearThreadLock();

        }

    }

    public IIOMetadata convertStreamMetadata(IIOMetadata inData,

                                             ImageWriteParam param) {

        // There isn't much we can do.  If it's one of ours, then

        // return it.  Otherwise just return null.  We use it only

        // for tables, so we can't get a default and modify it,

        // as this will usually not be what is intended.

        if (inData instanceof JPEGMetadata) {

            JPEGMetadata jpegData = (JPEGMetadata) inData;

            if (jpegData.isStream) {

                return inData;

            }

        }

        return null;

    }

    public IIOMetadata

        convertImageMetadata(IIOMetadata inData,

                             ImageTypeSpecifier imageType,

                             ImageWriteParam param) {

        setThreadLock();

        try {

            return convertImageMetadataOnThread(inData, imageType, param);

        } finally {

            clearThreadLock();

        }

    }

    private IIOMetadata

        convertImageMetadataOnThread(IIOMetadata inData,

                                     ImageTypeSpecifier imageType,

                                     ImageWriteParam param) {

        // If it's one of ours, just return it

        if (inData instanceof JPEGMetadata) {

            JPEGMetadata jpegData = (JPEGMetadata) inData;

            if (!jpegData.isStream) {

                return inData;

            } else {

                // Can't convert stream metadata to image metadata

                // XXX Maybe this should put out a warning?

                return null;

            }

        }

        // If it's not one of ours, create a default and set it from

        // the standard tree from the input, if it exists.

        if (inData.isStandardMetadataFormatSupported()) {

            String formatName =

                IIOMetadataFormatImpl.standardMetadataFormatName;

            Node tree = inData.getAsTree(formatName);

            if (tree != null) {

                JPEGMetadata jpegData = new JPEGMetadata(imageType,

                                                         param,

                                                         this);

                try {

                    jpegData.setFromTree(formatName, tree);

                } catch (IIOInvalidTreeException e) {

                    // Other plug-in generates bogus standard tree

                    // XXX Maybe this should put out a warning?

                    return null;

                }

                return jpegData;

            }

        }

        return null;

    }

    public int getNumThumbnailsSupported(ImageTypeSpecifier imageType,

                                         ImageWriteParam param,

                                         IIOMetadata streamMetadata,

                                         IIOMetadata imageMetadata) {

        if (jfifOK(imageType, param, streamMetadata, imageMetadata)) {

            return Integer.MAX_VALUE;

        }

        return 0;

    }

    static final Dimension [] preferredThumbSizes = {new Dimension(1, 1),

                                                     new Dimension(255, 255)};

    public Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType,

                                                  ImageWriteParam param,

                                                  IIOMetadata streamMetadata,

                                                  IIOMetadata imageMetadata) {

        if (jfifOK(imageType, param, streamMetadata, imageMetadata)) {

            return preferredThumbSizes.clone();

        }

        return null;

    }

    private boolean jfifOK(ImageTypeSpecifier imageType,

                           ImageWriteParam param,

                           IIOMetadata streamMetadata,

                           IIOMetadata imageMetadata) {

        // If the image type and metadata are JFIF compatible, return true

        if ((imageType != null) &&

            (!JPEG.isJFIFcompliant(imageType, true))) {

            return false;

        }

        if (imageMetadata != null) {

            JPEGMetadata metadata = null;

            if (imageMetadata instanceof JPEGMetadata) {

                metadata = (JPEGMetadata) imageMetadata;

            } else {

                metadata = (JPEGMetadata)convertImageMetadata(imageMetadata,

                                                              imageType,

                                                              param);

            }

            // metadata must have a jfif node

            if (metadata.findMarkerSegment

                (JFIFMarkerSegment.class, true) == null){

                return false;

            }

        }

        return true;

    }

    public boolean canWriteRasters() {

        return true;

    }

    public void write(IIOMetadata streamMetadata,

                      IIOImage image,

                      ImageWriteParam param) throws IOException {

        setThreadLock();

        try {

            cbLock.check();

            writeOnThread(streamMetadata, image, param);

        } finally {

            clearThreadLock();

        }

    }

    private void writeOnThread(IIOMetadata streamMetadata,

                      IIOImage image,

                      ImageWriteParam param) throws IOException {

        if (ios == null) {

            throw new IllegalStateException("Output has not been set!");

        }

        if (image == null) {

            throw new IllegalArgumentException("image is null!");

        }

        // if streamMetadata is not null, issue a warning

        if (streamMetadata != null) {

            warningOccurred(WARNING_STREAM_METADATA_IGNORED);

        }

        // Obtain the raster and image, if there is one

        boolean rasterOnly = image.hasRaster();

        RenderedImage rimage = null;

        if (rasterOnly) {

            srcRas = image.getRaster();

        } else {

            rimage = image.getRenderedImage();

            if (rimage instanceof BufferedImage) {

                // Use the Raster directly.

                srcRas = ((BufferedImage)rimage).getRaster();

            } else if (rimage.getNumXTiles() == 1 &&

                       rimage.getNumYTiles() == 1)

            {

                // Get the unique tile.

                srcRas = rimage.getTile(rimage.getMinTileX(),

                                        rimage.getMinTileY());

                // Ensure the Raster has dimensions of the image,

                // as the tile dimensions might differ.

                if (srcRas.getWidth() != rimage.getWidth() ||

                    srcRas.getHeight() != rimage.getHeight())

                {

                    srcRas = srcRas.createChild(srcRas.getMinX(),

                                                srcRas.getMinY(),

                                                rimage.getWidth(),

                                                rimage.getHeight(),

                                                srcRas.getMinX(),

                                                srcRas.getMinY(),

                                                null);

                }

            } else {

                // Image is tiled so get a contiguous raster by copying.

                srcRas = rimage.getData();

            }

        }

        // Now determine if we are using a band subset

        // By default, we are using all source bands

        int numSrcBands = srcRas.getNumBands();

        indexed = false;

        indexCM = null;

        ColorModel cm = null;

        ColorSpace cs = null;

        isAlphaPremultiplied = false;

        srcCM = null;

        if (!rasterOnly) {

            cm = rimage.getColorModel();

            if (cm != null) {

                cs = cm.getColorSpace();

                if (cm instanceof IndexColorModel) {

                    indexed = true;

                    indexCM = (IndexColorModel) cm;

                    numSrcBands = cm.getNumComponents();

                }

                if (cm.isAlphaPremultiplied()) {

                    isAlphaPremultiplied = true;

                    srcCM = cm;

                }

            }

        }

        srcBands = JPEG.bandOffsets[numSrcBands-1];

        int numBandsUsed = numSrcBands;

        // Consult the param to determine if we're writing a subset

        if (param != null) {

            int[] sBands = param.getSourceBands();

            if (sBands != null) {

                if (indexed) {

                    warningOccurred(WARNING_NO_BANDS_ON_INDEXED);

                } else {

                    srcBands = sBands;

                    numBandsUsed = srcBands.length;

                    if (numBandsUsed > numSrcBands) {

                        throw new IIOException

                        ("ImageWriteParam specifies too many source bands");

                    }

                }

            }

        }

        boolean usingBandSubset = (numBandsUsed != numSrcBands);

        boolean fullImage = ((!rasterOnly) && (!usingBandSubset));

        int [] bandSizes = null;

        if (!indexed) {

            bandSizes = srcRas.getSampleModel().getSampleSize();

            // If this is a subset, we must adjust bandSizes

            if (usingBandSubset) {

                int [] temp = new int [numBandsUsed];

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

                    temp[i] = bandSizes[srcBands[i]];

                }

                bandSizes = temp;

            }

        } else {

            int [] tempSize = srcRas.getSampleModel().getSampleSize();

            bandSizes = new int [numSrcBands];

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

                bandSizes[i] = tempSize[0];  // All the same

            }

        }

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

            // 4450894 part 1: The IJG libraries are compiled so they only

            // handle <= 8-bit samples.  We now check the band sizes and throw

            // an exception for images, such as USHORT_GRAY, with > 8 bits

            // per sample.

            if (bandSizes[i] <= 0 || bandSizes[i] > 8) {

                throw new IIOException("Illegal band size: should be 0 < size <= 8");

            }

            // 4450894 part 2: We expand IndexColorModel images to full 24-

            // or 32-bit in grabPixels() for each scanline.  For indexed

            // images such as BYTE_BINARY, we need to ensure that we update

            // bandSizes to account for the scaling from 1-bit band sizes

            // to 8-bit.

            if (indexed) {

                bandSizes[i] = 8;

            }

        }

        if (debug) {

            System.out.println("numSrcBands is " + numSrcBands);

            System.out.println("numBandsUsed is " + numBandsUsed);

            System.out.println("usingBandSubset is " + usingBandSubset);

            System.out.println("fullImage is " + fullImage);

            System.out.print("Band sizes:");

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

                System.out.print(" " + bandSizes[i]);

            }

            System.out.println();

        }

        // Destination type, if there is one

        ImageTypeSpecifier destType = null;

        if (param != null) {

            destType = param.getDestinationType();