/*

 * 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.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 <= SunGraphics2D.PAINT_ALPHACOLOR &&

            sg2d.compositeState <= SunGraphics2D.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;

    }

    protected BufImgSurfaceData(SurfaceType surfaceType, ColorModel cm) {

        super(surfaceType, cm);

    }

    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;

            }

        }

    }

}