/*

 * Copyright 2007 Sun Microsystems, Inc.  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.  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 sun.java2d.pipe;

import java.awt.color.ColorSpace;

import java.awt.image.AffineTransformOp;

import java.awt.image.BufferedImage;

import java.awt.image.BufferedImageOp;

import java.awt.image.BufferedImageOp;

import java.awt.image.ByteLookupTable;

import java.awt.image.ColorModel;

import java.awt.image.ConvolveOp;

import java.awt.image.IndexColorModel;

import java.awt.image.Kernel;

import java.awt.image.LookupOp;

import java.awt.image.LookupTable;

import java.awt.image.RescaleOp;

import java.awt.image.ShortLookupTable;

import sun.java2d.SurfaceData;

import sun.java2d.loops.CompositeType;

import static sun.java2d.pipe.BufferedOpCodes.*;

public class BufferedBufImgOps {

    public static void enableBufImgOp(RenderQueue rq, SurfaceData srcData,

                                      BufferedImage srcImg,

                                      BufferedImageOp biop)

    {

        if (biop instanceof ConvolveOp) {

            enableConvolveOp(rq, srcData, (ConvolveOp)biop);

        } else if (biop instanceof RescaleOp) {

            enableRescaleOp(rq, srcData, srcImg, (RescaleOp)biop);

        } else if (biop instanceof LookupOp) {

            enableLookupOp(rq, srcData, srcImg, (LookupOp)biop);

        } else {

            throw new InternalError("Unknown BufferedImageOp");

        }

    }

    public static void disableBufImgOp(RenderQueue rq, BufferedImageOp biop) {

        if (biop instanceof ConvolveOp) {

            disableConvolveOp(rq);

        } else if (biop instanceof RescaleOp) {

            disableRescaleOp(rq);

        } else if (biop instanceof LookupOp) {

            disableLookupOp(rq);

        } else {

            throw new InternalError("Unknown BufferedImageOp");

        }

    }

/**************************** ConvolveOp support ****************************/

    public static boolean isConvolveOpValid(ConvolveOp cop) {

        Kernel kernel = cop.getKernel();

        int kw = kernel.getWidth();

        int kh = kernel.getHeight();

        // REMIND: we currently can only handle 3x3 and 5x5 kernels,

        //         but hopefully this is just a temporary restriction;

        //         see native shader comments for more details

        if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {

            return false;

        }

        return true;

    }

    private static void enableConvolveOp(RenderQueue rq,

                                         SurfaceData srcData,

                                         ConvolveOp cop)

    {

        // assert rq.lock.isHeldByCurrentThread();

        boolean edgeZero =

            cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;

        Kernel kernel = cop.getKernel();

        int kernelWidth = kernel.getWidth();

        int kernelHeight = kernel.getHeight();

        int kernelSize = kernelWidth * kernelHeight;

        int sizeofFloat = 4;

        int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

        RenderBuffer buf = rq.getBuffer();

        rq.ensureCapacityAndAlignment(totalBytesRequired, 4);

        buf.putInt(ENABLE_CONVOLVE_OP);

        buf.putLong(srcData.getNativeOps());

        buf.putInt(edgeZero ? 1 : 0);

        buf.putInt(kernelWidth);

        buf.putInt(kernelHeight);

        buf.put(kernel.getKernelData(null));

    }

    private static void disableConvolveOp(RenderQueue rq) {

        // assert rq.lock.isHeldByCurrentThread();

        RenderBuffer buf = rq.getBuffer();

        rq.ensureCapacity(4);

        buf.putInt(DISABLE_CONVOLVE_OP);

    }

/**************************** RescaleOp support *****************************/

    public static boolean isRescaleOpValid(RescaleOp rop,

                                           BufferedImage srcImg)

    {

        int numFactors = rop.getNumFactors();

        ColorModel srcCM = srcImg.getColorModel();

        if (srcCM instanceof IndexColorModel) {

            throw new

                IllegalArgumentException("Rescaling cannot be "+

                                         "performed on an indexed image");

        }

        if (numFactors != 1 &&

            numFactors != srcCM.getNumColorComponents() &&

            numFactors != srcCM.getNumComponents())

        {

            throw new IllegalArgumentException("Number of scaling constants "+

                                               "does not equal the number of"+

                                               " of color or color/alpha "+

                                               " components");

        }

        int csType = srcCM.getColorSpace().getType();

        if (csType != ColorSpace.TYPE_RGB &&

            csType != ColorSpace.TYPE_GRAY)

        {

            // Not prepared to deal with other color spaces

            return false;

        }

        if (numFactors == 2 || numFactors > 4) {

            // Not really prepared to handle this at the native level, so...

            return false;

        }

        return true;

    }

    private static void enableRescaleOp(RenderQueue rq,

                                        SurfaceData srcData,

                                        BufferedImage srcImg,

                                        RescaleOp rop)

    {

        // assert rq.lock.isHeldByCurrentThread();

        ColorModel srcCM = srcImg.getColorModel();

        boolean nonPremult =

            srcCM.hasAlpha() &&

            srcCM.isAlphaPremultiplied();

        /*

         * Note: The user-provided scale factors and offsets are arranged

         * in R/G/B/A order, regardless of the raw data order of the

         * underlying Raster/DataBuffer.  The source image data is ultimately

         * converted into RGBA data when uploaded to an OpenGL texture

         * (even for TYPE_GRAY), so the scale factors and offsets are already

         * in the order expected by the native OpenGL code.

         *

         * However, the offsets provided by the user are in a range dictated

         * by the size of each color/alpha band in the source image.  For

         * example, for 8/8/8 data each offset is in the range [0,255],

         * for 5/5/5 data each offset is in the range [0,31], and so on.

         * The OpenGL shader only thinks in terms of [0,1], so below we need

         * to normalize the user-provided offset values into the range [0,1].

         */

        int numFactors = rop.getNumFactors();

        float[] origScaleFactors = rop.getScaleFactors(null);

        float[] origOffsets = rop.getOffsets(null);

        // To make things easier, we will always pass all four bands

        // down to native code...

        float[] normScaleFactors;

        float[] normOffsets;

        if (numFactors == 1) {

            normScaleFactors = new float[4];

            normOffsets      = new float[4];

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

                normScaleFactors[i] = origScaleFactors[0];

                normOffsets[i]      = origOffsets[0];

            }

            // Leave alpha untouched...

            normScaleFactors[3] = 1.0f;

            normOffsets[3]      = 0.0f;

        } else if (numFactors == 3) {

            normScaleFactors = new float[4];

            normOffsets      = new float[4];

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

                normScaleFactors[i] = origScaleFactors[i];

                normOffsets[i]      = origOffsets[i];

            }

            // Leave alpha untouched...

            normScaleFactors[3] = 1.0f;

            normOffsets[3]      = 0.0f;

        } else { // (numFactors == 4)

            normScaleFactors = origScaleFactors;

            normOffsets      = origOffsets;

        }

        // The user-provided offsets are specified in the range

        // of each source color band, but the OpenGL shader only wants

        // to deal with data in the range [0,1], so we need to normalize

        // each offset value to the range [0,1] here.

        if (srcCM.getNumComponents() == 1) {

            // Gray data

            int nBits = srcCM.getComponentSize(0);

            int maxValue = (1 << nBits) - 1;

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

                normOffsets[i] /= maxValue;

            }

        } else {

            // RGB(A) data

            for (int i = 0; i < srcCM.getNumComponents(); i++) {

                int nBits = srcCM.getComponentSize(i);

                int maxValue = (1 << nBits) - 1;

                normOffsets[i] /= maxValue;

            }

        }

        int sizeofFloat = 4;

        int totalBytesRequired = 4 + 8 + 4 + (4 * sizeofFloat * 2);

        RenderBuffer buf = rq.getBuffer();

        rq.ensureCapacityAndAlignment(totalBytesRequired, 4);

        buf.putInt(ENABLE_RESCALE_OP);

        buf.putLong(srcData.getNativeOps());

        buf.putInt(nonPremult ? 1 : 0);

        buf.put(normScaleFactors);

        buf.put(normOffsets);

    }

    private static void disableRescaleOp(RenderQueue rq) {

        // assert rq.lock.isHeldByCurrentThread();

        RenderBuffer buf = rq.getBuffer();

        rq.ensureCapacity(4);

        buf.putInt(DISABLE_RESCALE_OP);

    }

/**************************** LookupOp support ******************************/

    public static boolean isLookupOpValid(LookupOp lop,

                                          BufferedImage srcImg)

    {

        LookupTable table = lop.getTable();

        int numComps = table.getNumComponents();

        ColorModel srcCM = srcImg.getColorModel();

        if (srcCM instanceof IndexColorModel) {

            throw new

                IllegalArgumentException("LookupOp cannot be "+

                                         "performed on an indexed image");

        }

        if (numComps != 1 &&

            numComps != srcCM.getNumComponents() &&

            numComps != srcCM.getNumColorComponents())

        {

            throw new IllegalArgumentException("Number of arrays in the "+

                                               " lookup table ("+

                                               numComps+

                                               ") is not compatible with"+

                                               " the src image: "+srcImg);

        }

        int csType = srcCM.getColorSpace().getType();

        if (csType != ColorSpace.TYPE_RGB &&

            csType != ColorSpace.TYPE_GRAY)

        {

            // Not prepared to deal with other color spaces

            return false;

        }

        if (numComps == 2 || numComps > 4) {

            // Not really prepared to handle this at the native level, so...

            return false;

        }

        // The LookupTable spec says that "all arrays must be the

        // same size" but unfortunately the constructors do not

        // enforce that.  Also, our native code only works with

        // arrays no larger than 256 elements, so check both of

        // these restrictions here.

        if (table instanceof ByteLookupTable) {

            byte[][] data = ((ByteLookupTable)table).getTable();

            for (int i = 1; i < data.length; i++) {

                if (data[i].length > 256 ||

                    data[i].length != data[i-1].length)

                {

                    return false;

                }

            }

        } else if (table instanceof ShortLookupTable) {

            short[][] data = ((ShortLookupTable)table).getTable();

            for (int i = 1; i < data.length; i++) {

                if (data[i].length > 256 ||

                    data[i].length != data[i-1].length)

                {

                    return false;

                }

            }

        } else {

            return false;

        }

        return true;

    }

    private static void enableLookupOp(RenderQueue rq,

                                       SurfaceData srcData,

                                       BufferedImage srcImg,

                                       LookupOp lop)

    {

        // assert rq.lock.isHeldByCurrentThread();

        boolean nonPremult =

            srcImg.getColorModel().hasAlpha() &&

            srcImg.isAlphaPremultiplied();

        LookupTable table = lop.getTable();

        int numBands = table.getNumComponents();

        int offset = table.getOffset();

        int bandLength;

        int bytesPerElem;

        boolean shortData;

        if (table instanceof ShortLookupTable) {

            short[][] data = ((ShortLookupTable)table).getTable();

            bandLength = data[0].length;

            bytesPerElem = 2;

            shortData = true;

        } else { // (table instanceof ByteLookupTable)

            byte[][] data = ((ByteLookupTable)table).getTable();

            bandLength = data[0].length;

            bytesPerElem = 1;

            shortData = false;

        }

        // Adjust the LUT length so that it ends on a 4-byte boundary

        int totalLutBytes = numBands * bandLength * bytesPerElem;

        int paddedLutBytes = (totalLutBytes + 3) & (~3);

        int padding = paddedLutBytes - totalLutBytes;

        int totalBytesRequired = 4 + 8 + 20 + paddedLutBytes;

        RenderBuffer buf = rq.getBuffer();

        rq.ensureCapacityAndAlignment(totalBytesRequired, 4);

        buf.putInt(ENABLE_LOOKUP_OP);

        buf.putLong(srcData.getNativeOps());

        buf.putInt(nonPremult ? 1 : 0);

        buf.putInt(shortData ? 1 : 0);

        buf.putInt(numBands);

        buf.putInt(bandLength);

        buf.putInt(offset);

        if (shortData) {

            short[][] data = ((ShortLookupTable)table).getTable();

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

                buf.put(data[i]);

            }

        } else {

            byte[][] data = ((ByteLookupTable)table).getTable();

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

                buf.put(data[i]);

            }

        }

        if (padding != 0) {

            buf.position(buf.position() + padding);

        }

    }

    private static void disableLookupOp(RenderQueue rq) {

        // assert rq.lock.isHeldByCurrentThread();

        RenderBuffer buf = rq.getBuffer();

        rq.ensureCapacity(4);

        buf.putInt(DISABLE_LOOKUP_OP);

    }

}