/* * Copyright (c) 2007, 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 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);    }}