Back to index...

	/*
	* 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);
	}
	}

Back to index...