/*
* Copyright (c) 1999, 2010, 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.awt.image;
import java.awt.Color;
import java.awt.Rectangle;
import java.awt.GraphicsConfiguration;
import java.awt.image.ColorModel;
import java.awt.image.SampleModel;
import java.awt.image.DirectColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.Raster;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import sun.java2d.SurfaceData;
import sun.java2d.SunGraphics2D;
import sun.java2d.StateTrackable;
import sun.java2d.StateTracker;
import sun.java2d.loops.SurfaceType;
import sun.java2d.loops.CompositeType;
import sun.java2d.loops.RenderLoops;
public class BufImgSurfaceData extends SurfaceData {
BufferedImage bufImg;
private BufferedImageGraphicsConfig graphicsConfig;
RenderLoops solidloops;
private static native void initIDs(Class ICM, Class ICMColorData);
private static final int DCM_RGBX_RED_MASK = 0xff000000;
private static final int DCM_RGBX_GREEN_MASK = 0x00ff0000;
private static final int DCM_RGBX_BLUE_MASK = 0x0000ff00;
private static final int DCM_555X_RED_MASK = 0xF800;
private static final int DCM_555X_GREEN_MASK = 0x07C0;
private static final int DCM_555X_BLUE_MASK = 0x003E;
private static final int DCM_4444_RED_MASK = 0x0f00;
private static final int DCM_4444_GREEN_MASK = 0x00f0;
private static final int DCM_4444_BLUE_MASK = 0x000f;
private static final int DCM_4444_ALPHA_MASK = 0xf000;
private static final int DCM_ARGBBM_ALPHA_MASK = 0x01000000;
private static final int DCM_ARGBBM_RED_MASK = 0x00ff0000;
private static final int DCM_ARGBBM_GREEN_MASK = 0x0000ff00;
private static final int DCM_ARGBBM_BLUE_MASK = 0x000000ff;
static {
initIDs(IndexColorModel.class, ICMColorData.class);
}
public static SurfaceData createData(BufferedImage bufImg) {
if (bufImg == null) {
throw new NullPointerException("BufferedImage cannot be null");
}
SurfaceData sData;
ColorModel cm = bufImg.getColorModel();
int type = bufImg.getType();
// REMIND: Check the image type and pick an appropriate subclass
switch (type) {
case BufferedImage.TYPE_INT_BGR:
sData = createDataIC(bufImg, SurfaceType.IntBgr);
break;
case BufferedImage.TYPE_INT_RGB:
sData = createDataIC(bufImg, SurfaceType.IntRgb);
break;
case BufferedImage.TYPE_INT_ARGB:
sData = createDataIC(bufImg, SurfaceType.IntArgb);
break;
case BufferedImage.TYPE_INT_ARGB_PRE:
sData = createDataIC(bufImg, SurfaceType.IntArgbPre);
break;
case BufferedImage.TYPE_3BYTE_BGR:
sData = createDataBC(bufImg, SurfaceType.ThreeByteBgr, 2);
break;
case BufferedImage.TYPE_4BYTE_ABGR:
sData = createDataBC(bufImg, SurfaceType.FourByteAbgr, 3);
break;
case BufferedImage.TYPE_4BYTE_ABGR_PRE:
sData = createDataBC(bufImg, SurfaceType.FourByteAbgrPre, 3);
break;
case BufferedImage.TYPE_USHORT_565_RGB:
sData = createDataSC(bufImg, SurfaceType.Ushort565Rgb, null);
break;
case BufferedImage.TYPE_USHORT_555_RGB:
sData = createDataSC(bufImg, SurfaceType.Ushort555Rgb, null);
break;
case BufferedImage.TYPE_BYTE_INDEXED:
{
SurfaceType sType;
switch (cm.getTransparency()) {
case OPAQUE:
if (isOpaqueGray((IndexColorModel)cm)) {
sType = SurfaceType.Index8Gray;
} else {
sType = SurfaceType.ByteIndexedOpaque;
}
break;
case BITMASK:
sType = SurfaceType.ByteIndexedBm;
break;
case TRANSLUCENT:
sType = SurfaceType.ByteIndexed;
break;
default:
throw new InternalError("Unrecognized transparency");
}
sData = createDataBC(bufImg, sType, 0);
}
break;
case BufferedImage.TYPE_BYTE_GRAY:
sData = createDataBC(bufImg, SurfaceType.ByteGray, 0);
break;
case BufferedImage.TYPE_USHORT_GRAY:
sData = createDataSC(bufImg, SurfaceType.UshortGray, null);
break;
case BufferedImage.TYPE_BYTE_BINARY:
{
SurfaceType sType;
SampleModel sm = bufImg.getRaster().getSampleModel();
switch (sm.getSampleSize(0)) {
case 1:
sType = SurfaceType.ByteBinary1Bit;
break;
case 2:
sType = SurfaceType.ByteBinary2Bit;
break;
case 4:
sType = SurfaceType.ByteBinary4Bit;
break;
default:
throw new InternalError("Unrecognized pixel size");
}
sData = createDataBP(bufImg, sType);
}
break;
case BufferedImage.TYPE_CUSTOM:
default:
{
Raster raster = bufImg.getRaster();
int numBands = raster.getNumBands();
if (raster instanceof IntegerComponentRaster &&
raster.getNumDataElements() == 1 &&
((IntegerComponentRaster)raster).getPixelStride() == 1)
{
SurfaceType sType = SurfaceType.AnyInt;
if (cm instanceof DirectColorModel) {
DirectColorModel dcm = (DirectColorModel) cm;
int aMask = dcm.getAlphaMask();
int rMask = dcm.getRedMask();
int gMask = dcm.getGreenMask();
int bMask = dcm.getBlueMask();
if (numBands == 3 &&
aMask == 0 &&
rMask == DCM_RGBX_RED_MASK &&
gMask == DCM_RGBX_GREEN_MASK &&
bMask == DCM_RGBX_BLUE_MASK)
{
sType = SurfaceType.IntRgbx;
} else if (numBands == 4 &&
aMask == DCM_ARGBBM_ALPHA_MASK &&
rMask == DCM_ARGBBM_RED_MASK &&
gMask == DCM_ARGBBM_GREEN_MASK &&
bMask == DCM_ARGBBM_BLUE_MASK)
{
sType = SurfaceType.IntArgbBm;
} else {
sType = SurfaceType.AnyDcm;
}
}
sData = createDataIC(bufImg, sType);
break;
} else if (raster instanceof ShortComponentRaster &&
raster.getNumDataElements() == 1 &&
((ShortComponentRaster)raster).getPixelStride() == 1)
{
SurfaceType sType = SurfaceType.AnyShort;
IndexColorModel icm = null;
if (cm instanceof DirectColorModel) {
DirectColorModel dcm = (DirectColorModel) cm;
int aMask = dcm.getAlphaMask();
int rMask = dcm.getRedMask();
int gMask = dcm.getGreenMask();
int bMask = dcm.getBlueMask();
if (numBands == 3 &&
aMask == 0 &&
rMask == DCM_555X_RED_MASK &&
gMask == DCM_555X_GREEN_MASK &&
bMask == DCM_555X_BLUE_MASK)
{
sType = SurfaceType.Ushort555Rgbx;
} else
if (numBands == 4 &&
aMask == DCM_4444_ALPHA_MASK &&
rMask == DCM_4444_RED_MASK &&
gMask == DCM_4444_GREEN_MASK &&
bMask == DCM_4444_BLUE_MASK)
{
sType = SurfaceType.Ushort4444Argb;
}
} else if (cm instanceof IndexColorModel) {
icm = (IndexColorModel)cm;
if (icm.getPixelSize() == 12) {
if (isOpaqueGray(icm)) {
sType = SurfaceType.Index12Gray;
} else {
sType = SurfaceType.UshortIndexed;
}
} else {
icm = null;
}
}
sData = createDataSC(bufImg, sType, icm);
break;
}
sData = new BufImgSurfaceData(raster.getDataBuffer(),
bufImg, SurfaceType.Custom);
}
break;
}
((BufImgSurfaceData) sData).initSolidLoops();
return sData;
}
public static SurfaceData createData(Raster ras, ColorModel cm) {
throw new InternalError("SurfaceData not implemented for Raster/CM");
}
public static SurfaceData createDataIC(BufferedImage bImg,
SurfaceType sType) {
IntegerComponentRaster icRaster =
(IntegerComponentRaster)bImg.getRaster();
BufImgSurfaceData bisd =
new BufImgSurfaceData(icRaster.getDataBuffer(), bImg, sType);
bisd.initRaster(icRaster.getDataStorage(),
icRaster.getDataOffset(0) * 4, 0,
icRaster.getWidth(),
icRaster.getHeight(),
icRaster.getPixelStride() * 4,
icRaster.getScanlineStride() * 4,
null);
return bisd;
}
public static SurfaceData createDataSC(BufferedImage bImg,
SurfaceType sType,
IndexColorModel icm) {
ShortComponentRaster scRaster =
(ShortComponentRaster)bImg.getRaster();
BufImgSurfaceData bisd =
new BufImgSurfaceData(scRaster.getDataBuffer(), bImg, sType);
bisd.initRaster(scRaster.getDataStorage(),
scRaster.getDataOffset(0) * 2, 0,
scRaster.getWidth(),
scRaster.getHeight(),
scRaster.getPixelStride() * 2,
scRaster.getScanlineStride() * 2,
icm);
return bisd;
}
public static SurfaceData createDataBC(BufferedImage bImg,
SurfaceType sType,
int primaryBank) {
ByteComponentRaster bcRaster =
(ByteComponentRaster)bImg.getRaster();
BufImgSurfaceData bisd =
new BufImgSurfaceData(bcRaster.getDataBuffer(), bImg, sType);
ColorModel cm = bImg.getColorModel();
IndexColorModel icm = ((cm instanceof IndexColorModel)
? (IndexColorModel) cm
: null);
bisd.initRaster(bcRaster.getDataStorage(),
bcRaster.getDataOffset(primaryBank), 0,
bcRaster.getWidth(),
bcRaster.getHeight(),
bcRaster.getPixelStride(),
bcRaster.getScanlineStride(),
icm);
return bisd;
}
public static SurfaceData createDataBP(BufferedImage bImg,
SurfaceType sType) {
BytePackedRaster bpRaster =
(BytePackedRaster)bImg.getRaster();
BufImgSurfaceData bisd =
new BufImgSurfaceData(bpRaster.getDataBuffer(), bImg, sType);
ColorModel cm = bImg.getColorModel();
IndexColorModel icm = ((cm instanceof IndexColorModel)
? (IndexColorModel) cm
: null);
bisd.initRaster(bpRaster.getDataStorage(),
bpRaster.getDataBitOffset() / 8,
bpRaster.getDataBitOffset() & 7,
bpRaster.getWidth(),
bpRaster.getHeight(),
0,
bpRaster.getScanlineStride(),
icm);
return bisd;
}
public RenderLoops getRenderLoops(SunGraphics2D sg2d) {
if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&
sg2d.compositeState <= sg2d.COMP_ISCOPY)
{
return solidloops;
}
return super.getRenderLoops(sg2d);
}
public java.awt.image.Raster getRaster(int x, int y, int w, int h) {
return bufImg.getRaster();
}
/**
* Initializes the native Ops pointer.
*/
protected native void initRaster(Object theArray,
int offset,
int bitoffset,
int width,
int height,
int pixStr,
int scanStr,
IndexColorModel icm);
public BufImgSurfaceData(DataBuffer db,
BufferedImage bufImg, SurfaceType sType)
{
super(SunWritableRaster.stealTrackable(db),
sType, bufImg.getColorModel());
this.bufImg = bufImg;
}
public void initSolidLoops() {
this.solidloops = getSolidLoops(getSurfaceType());
}
private static final int CACHE_SIZE = 5;
private static RenderLoops loopcache[] = new RenderLoops[CACHE_SIZE];
private static SurfaceType typecache[] = new SurfaceType[CACHE_SIZE];
public static synchronized RenderLoops getSolidLoops(SurfaceType type) {
for (int i = CACHE_SIZE - 1; i >= 0; i--) {
SurfaceType t = typecache[i];
if (t == type) {
return loopcache[i];
} else if (t == null) {
break;
}
}
RenderLoops l = makeRenderLoops(SurfaceType.OpaqueColor,
CompositeType.SrcNoEa,
type);
System.arraycopy(loopcache, 1, loopcache, 0, CACHE_SIZE-1);
System.arraycopy(typecache, 1, typecache, 0, CACHE_SIZE-1);
loopcache[CACHE_SIZE - 1] = l;
typecache[CACHE_SIZE - 1] = type;
return l;
}
public SurfaceData getReplacement() {
// BufImgSurfaceData objects should never lose their contents,
// so this method should never be called.
return restoreContents(bufImg);
}
public synchronized GraphicsConfiguration getDeviceConfiguration() {
if (graphicsConfig == null) {
graphicsConfig = BufferedImageGraphicsConfig.getConfig(bufImg);
}
return graphicsConfig;
}
public java.awt.Rectangle getBounds() {
return new Rectangle(bufImg.getWidth(), bufImg.getHeight());
}
protected void checkCustomComposite() {
// BufferedImages always allow Custom Composite objects since
// their pixels are immediately retrievable anyway.
}
private static native void freeNativeICMData(long pData);
/**
* Returns destination Image associated with this SurfaceData.
*/
public Object getDestination() {
return bufImg;
}
public static final class ICMColorData {
private long pData = 0L;
private ICMColorData(long pData) {
this.pData = pData;
}
public void finalize() {
if (pData != 0L) {
BufImgSurfaceData.freeNativeICMData(pData);
pData = 0L;
}
}
}
}