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