/*

 * Copyright (c) 2007, 2014, 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.d3d;

import java.awt.AlphaComposite;

import java.awt.BufferCapabilities;

import java.awt.Component;

import java.awt.GraphicsConfiguration;

import java.awt.GraphicsDevice;

import java.awt.GraphicsEnvironment;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.Transparency;

import java.awt.image.ColorModel;

import java.awt.image.DataBuffer;

import java.awt.image.DirectColorModel;

import java.awt.image.Raster;

import java.awt.image.SampleModel;

import java.awt.image.SinglePixelPackedSampleModel;

import sun.awt.SunHints;

import sun.awt.image.DataBufferNative;

import sun.awt.image.PixelConverter;

import sun.awt.image.SurfaceManager;

import sun.awt.image.WritableRasterNative;

import sun.awt.windows.WComponentPeer;

import sun.java2d.pipe.hw.AccelSurface;

import sun.java2d.InvalidPipeException;

import sun.java2d.SunGraphics2D;

import sun.java2d.SurfaceData;

import sun.java2d.loops.GraphicsPrimitive;

import sun.java2d.loops.MaskFill;

import sun.java2d.loops.SurfaceType;

import sun.java2d.loops.CompositeType;

import sun.java2d.pipe.ParallelogramPipe;

import sun.java2d.pipe.PixelToParallelogramConverter;

import sun.java2d.pipe.RenderBuffer;

import sun.java2d.pipe.TextPipe;

import static sun.java2d.pipe.BufferedOpCodes.*;

import static sun.java2d.d3d.D3DContext.D3DContextCaps.*;

import static sun.java2d.pipe.hw.ExtendedBufferCapabilities.VSyncType.*;

import sun.java2d.pipe.hw.ExtendedBufferCapabilities.VSyncType;

import java.awt.BufferCapabilities.FlipContents;

import java.awt.Window;

import sun.awt.SunToolkit;

import sun.awt.image.SunVolatileImage;

import sun.java2d.ScreenUpdateManager;

import sun.java2d.StateTracker;

import sun.java2d.SurfaceDataProxy;

import sun.java2d.pipe.hw.ExtendedBufferCapabilities;

/**

 * This class describes a D3D "surface", that is, a region of pixels

 * managed via D3D.  An D3DSurfaceData can be tagged with one of three

 * different SurfaceType objects for the purpose of registering loops, etc.

 * This diagram shows the hierarchy of D3D SurfaceTypes:

 *

 *                               Any

 *                             /     \

 *                    D3DSurface     D3DTexture

 *                         |

 *                   D3DSurfaceRTT

 *

 * D3DSurface

 * This kind of surface can be rendered to using D3D APIs.  It is also

 * possible to copy a D3DSurface to another D3DSurface (or to itself).

 *

 * D3DTexture

 * This kind of surface cannot be rendered to using D3D (in the same sense

 * as in D3DSurface).  However, it is possible to upload a region of pixels

 * to a D3DTexture object via Lock/UnlockRect().  One can also copy a

 * surface of type D3DTexture to a D3DSurface by binding the texture

 * to a quad and then rendering it to the destination surface (this process

 * is known as "texture mapping").

 *

 * D3DSurfaceRTT

 * This kind of surface can be thought of as a sort of hybrid between

 * D3DSurface and D3DTexture, in that one can render to this kind of

 * surface as if it were of type D3DSurface, but the process of copying

 * this kind of surface to another is more like a D3DTexture.  (Note that

 * "RTT" stands for "render-to-texture".)

 *

 * In addition to these SurfaceType variants, we have also defined some

 * constants that describe in more detail the type of underlying D3D

 * surface.  This table helps explain the relationships between those

 * "type" constants and their corresponding SurfaceType:

 *

 * D3D Type          Corresponding SurfaceType

 * --------          -------------------------

 * RT_PLAIN          D3DSurface

 * TEXTURE           D3DTexture

 * FLIP_BACKBUFFER   D3DSurface

 * RT_TEXTURE        D3DSurfaceRTT

 */

public class D3DSurfaceData extends SurfaceData implements AccelSurface {

    /**

     * To be used with getNativeResource() only.

     * @see #getNativeResource

     */

    public static final int D3D_DEVICE_RESOURCE= 100;

    /*

     * Surface types.

     * We use these surface types when copying from a sw surface

     * to a surface or texture.

     */

    public static final int ST_INT_ARGB        = 0;

    public static final int ST_INT_ARGB_PRE    = 1;

    public static final int ST_INT_ARGB_BM     = 2;

    public static final int ST_INT_RGB         = 3;

    public static final int ST_INT_BGR         = 4;

    public static final int ST_USHORT_565_RGB  = 5;

    public static final int ST_USHORT_555_RGB  = 6;

    public static final int ST_BYTE_INDEXED    = 7;

    public static final int ST_BYTE_INDEXED_BM = 8;

    public static final int ST_3BYTE_BGR       = 9;

    /** Equals to D3DSWAPEFFECT_DISCARD */

    public static final int SWAP_DISCARD       = 1;

    /** Equals to D3DSWAPEFFECT_FLIP    */

    public static final int SWAP_FLIP          = 2;

    /** Equals to D3DSWAPEFFECT_COPY    */

    public static final int SWAP_COPY          = 3;

    /*

     * SurfaceTypes

     */

    private static final String DESC_D3D_SURFACE = "D3D Surface";

    private static final String DESC_D3D_SURFACE_RTT =

        "D3D Surface (render-to-texture)";

    private static final String DESC_D3D_TEXTURE = "D3D Texture";

    // REMIND: regarding ArgbPre??

    static final SurfaceType D3DSurface =

        SurfaceType.Any.deriveSubType(DESC_D3D_SURFACE,

                                      PixelConverter.ArgbPre.instance);

    static final SurfaceType D3DSurfaceRTT =

        D3DSurface.deriveSubType(DESC_D3D_SURFACE_RTT);

    static final SurfaceType D3DTexture =

        SurfaceType.Any.deriveSubType(DESC_D3D_TEXTURE);

    private int type;

    private int width, height;

    // these fields are set from the native code when the surface is

    // initialized

    private int nativeWidth, nativeHeight;

    protected WComponentPeer peer;

    private Image offscreenImage;

    protected D3DGraphicsDevice graphicsDevice;

    private int swapEffect;

    private VSyncType syncType;

    private int backBuffersNum;

    private WritableRasterNative wrn;

    protected static D3DRenderer d3dRenderPipe;

    protected static PixelToParallelogramConverter d3dTxRenderPipe;

    protected static ParallelogramPipe d3dAAPgramPipe;

    protected static D3DTextRenderer d3dTextPipe;

    protected static D3DDrawImage d3dImagePipe;

    private native boolean initTexture(long pData, boolean isRTT,

                                       boolean isOpaque);

    private native boolean initFlipBackbuffer(long pData, long pPeerData,

                                              int numbuffers,

                                              int swapEffect, int syncType);

    private native boolean initRTSurface(long pData, boolean isOpaque);

    private native void initOps(int screen, int width, int height);

    static {

        D3DRenderQueue rq = D3DRenderQueue.getInstance();

        d3dImagePipe = new D3DDrawImage();

        d3dTextPipe = new D3DTextRenderer(rq);

        d3dRenderPipe = new D3DRenderer(rq);

        if (GraphicsPrimitive.tracingEnabled()) {

            d3dTextPipe = d3dTextPipe.traceWrap();

            d3dRenderPipe = d3dRenderPipe.traceWrap();

            //The wrapped d3dRenderPipe will wrap the AA pipe as well...

            //d3dAAPgramPipe = d3dRenderPipe.traceWrap();

        }

        d3dAAPgramPipe = d3dRenderPipe.getAAParallelogramPipe();

        d3dTxRenderPipe =

            new PixelToParallelogramConverter(d3dRenderPipe, d3dRenderPipe,

                                              1.0, 0.25, true);

        D3DBlitLoops.register();

        D3DMaskFill.register();

        D3DMaskBlit.register();

    }

    protected D3DSurfaceData(WComponentPeer peer, D3DGraphicsConfig gc,

                             int width, int height, Image image,

                             ColorModel cm, int numBackBuffers,

                             int swapEffect, VSyncType vSyncType,

                             int type)

    {

        super(getCustomSurfaceType(type), cm);

        this.graphicsDevice = gc.getD3DDevice();

        this.peer = peer;

        this.type = type;

        this.offscreenImage = image;

        this.backBuffersNum = numBackBuffers;

        this.swapEffect = swapEffect;

        this.syncType = vSyncType;

        if (type == WINDOW) {

            // we put the surface into the "lost"

            // state; it will be restored by the D3DScreenUpdateManager

            // prior to rendering to it for the first time. This is done

            // so that vram is not wasted for surfaces never rendered to

            setSurfaceLost(true);

        } else {

            initSurface();

        }

        setBlitProxyKey(gc.getProxyKey());

    }

    @Override

    public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {

        return D3DSurfaceDataProxy.

            createProxy(srcData,

                        (D3DGraphicsConfig)graphicsDevice.getDefaultConfiguration());

    }

    /**

     * Creates a SurfaceData object representing the back buffer of a

     * double-buffered on-screen Window.

     */

    public static D3DSurfaceData createData(WComponentPeer peer, Image image) {

        D3DGraphicsConfig gc = getGC(peer);

        if (gc == null || !peer.isAccelCapable()) {

            return null;

        }

        BufferCapabilities caps = peer.getBackBufferCaps();

        VSyncType vSyncType = VSYNC_DEFAULT;

        if (caps instanceof ExtendedBufferCapabilities) {

            vSyncType = ((ExtendedBufferCapabilities)caps).getVSync();

        }

        Rectangle r = peer.getBounds();

        BufferCapabilities.FlipContents flip = caps.getFlipContents();

        int swapEffect;

        if (flip == FlipContents.COPIED) {

            swapEffect = SWAP_COPY;

        } else if (flip == FlipContents.PRIOR) {

            swapEffect = SWAP_FLIP;

        } else { // flip == FlipContents.UNDEFINED || .BACKGROUND

            swapEffect = SWAP_DISCARD;

        }

        return new D3DSurfaceData(peer, gc, r.width, r.height,

                                  image, peer.getColorModel(),

                                  peer.getBackBuffersNum(),

                                  swapEffect, vSyncType, FLIP_BACKBUFFER);

    }

    /**

     * Returns a WINDOW type of surface - a

     * swap chain which serves as an on-screen surface,

     * handled by the D3DScreenUpdateManager.

     *

     * Note that the native surface is not initialized

     * when the surface is created to avoid using excessive

     * resources, and the surface is placed into the lost

     * state. It will be restored prior to any rendering

     * to it.

     *

     * @param peer peer for which the onscreen surface is to be created

     * @return a D3DWindowSurfaceData (flip chain) surface

     */

    public static D3DSurfaceData createData(WComponentPeer peer) {

        D3DGraphicsConfig gc = getGC(peer);

        if (gc == null || !peer.isAccelCapable()) {

            return null;

        }

        return new D3DWindowSurfaceData(peer, gc);

    }

    /**

     * Creates a SurfaceData object representing an off-screen buffer (either

     * a plain surface or Texture).

     */

    public static D3DSurfaceData createData(D3DGraphicsConfig gc,

                                            int width, int height,

                                            ColorModel cm,

                                            Image image, int type)

    {

        if (type == RT_TEXTURE) {

            boolean isOpaque = cm.getTransparency() == Transparency.OPAQUE;

            int cap = isOpaque ? CAPS_RT_TEXTURE_OPAQUE : CAPS_RT_TEXTURE_ALPHA;

            if (!gc.getD3DDevice().isCapPresent(cap)) {

                type = RT_PLAIN;

            }

        }

        D3DSurfaceData ret = null;

        try {

            ret = new D3DSurfaceData(null, gc, width, height,

                                     image, cm, 0, SWAP_DISCARD, VSYNC_DEFAULT,

                                     type);

        } catch (InvalidPipeException ipe) {

            // try again - we might have ran out of vram, and rt textures

            // could take up more than a plain surface, so it might succeed

            if (type == RT_TEXTURE) {

                // If a RT_TEXTURE was requested do not attempt to create a

                // plain surface. (note that RT_TEXTURE can only be requested

                // from a VI so the cast is safe)

                if (((SunVolatileImage)image).getForcedAccelSurfaceType() !=

                    RT_TEXTURE)

                {

                    type = RT_PLAIN;

                    ret = new D3DSurfaceData(null, gc, width, height,

                                             image, cm, 0, SWAP_DISCARD,

                                             VSYNC_DEFAULT, type);

                }

            }

        }

        return ret;

    }

    /**

     * Returns the appropriate SurfaceType corresponding to the given D3D

     * surface type constant (e.g. TEXTURE -> D3DTexture).

     */

    private static SurfaceType getCustomSurfaceType(int d3dType) {

        switch (d3dType) {

        case TEXTURE:

            return D3DTexture;

        case RT_TEXTURE:

            return D3DSurfaceRTT;

        default:

            return D3DSurface;

        }

    }

    private boolean initSurfaceNow() {

        boolean isOpaque = (getTransparency() == Transparency.OPAQUE);

        switch (type) {

            case RT_PLAIN:

                return initRTSurface(getNativeOps(), isOpaque);

            case TEXTURE:

                return initTexture(getNativeOps(), false/*isRTT*/, isOpaque);

            case RT_TEXTURE:

                return initTexture(getNativeOps(), true/*isRTT*/,  isOpaque);

            // REMIND: we may want to pass the exact type to the native

            // level here so that we could choose the right presentation

            // interval for the frontbuffer (immediate vs v-synced)

            case WINDOW:

            case FLIP_BACKBUFFER:

                return initFlipBackbuffer(getNativeOps(), peer.getData(),

                                          backBuffersNum, swapEffect,

                                          syncType.id());

            default:

                return false;

        }

    }

    /**

     * Initializes the appropriate D3D offscreen surface based on the value

     * of the type parameter.  If the surface creation fails for any reason,

     * an OutOfMemoryError will be thrown.

     */

    protected void initSurface() {

        // any time we create or restore the surface, recreate the raster

        synchronized (this) {

            wrn = null;

        }

        // REMIND: somewhere a puppy died

        class Status {

            boolean success = false;

        };

        final Status status = new Status();

        D3DRenderQueue rq = D3DRenderQueue.getInstance();

        rq.lock();

        try {

            rq.flushAndInvokeNow(new Runnable() {

                public void run() {

                    status.success = initSurfaceNow();

                }

            });

            if (!status.success) {

                throw new InvalidPipeException("Error creating D3DSurface");

            }

        } finally {

            rq.unlock();

        }

    }

    /**

     * Returns the D3DContext for the GraphicsConfig associated with this

     * surface.

     */

    public final D3DContext getContext() {

        return graphicsDevice.getContext();

    }

    /**

     * Returns one of the surface type constants defined above.

     */

    public final int getType() {

        return type;

    }

    private static native int  dbGetPixelNative(long pData, int x, int y);

    private static native void dbSetPixelNative(long pData, int x, int y,

                                                int pixel);

    static class D3DDataBufferNative extends DataBufferNative {

        int pixel;

        protected D3DDataBufferNative(SurfaceData sData,

                                      int type, int w, int h)

        {

            super(sData, type, w, h);

        }

        protected int getElem(final int x, final int y,

                              final SurfaceData sData)

        {

            if (sData.isSurfaceLost()) {

                return 0;

            }

            int retPixel;

            D3DRenderQueue rq = D3DRenderQueue.getInstance();

            rq.lock();

            try {

                rq.flushAndInvokeNow(new Runnable() {

                    public void run() {

                        pixel = dbGetPixelNative(sData.getNativeOps(), x, y);

                    }

                });

            } finally {

                retPixel = pixel;

                rq.unlock();

            }

            return retPixel;

        }

        protected void setElem(final int x, final int y, final int pixel,

                               final SurfaceData sData)

        {

            if (sData.isSurfaceLost()) {

                  return;

            }