/*

 * Copyright 2005-2006 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

#include "D3DSurfaceData.h"

#include "D3DContext.h"

#include "jlong.h"

#include "jni_util.h"

#include "Trace.h"

#include "ddrawUtils.h"

#include "Devices.h"

#include "Win32SurfaceData.h"

#include "sun_java2d_d3d_D3DBackBufferSurfaceData.h"

extern LockFunc Win32OSSD_Lock;

extern GetRasInfoFunc Win32OSSD_GetRasInfo;

extern UnlockFunc Win32OSSD_Unlock;

extern DisposeFunc Win32OSSD_Dispose;

extern GetDCFunc Win32OSSD_GetDC;

extern ReleaseDCFunc Win32OSSD_ReleaseDC;

extern InvalidateSDFunc Win32OSSD_InvalidateSD;

extern RestoreSurfaceFunc Win32OSSD_RestoreSurface;

extern DisposeFunc Win32BBSD_Dispose;

extern "C" {

RestoreSurfaceFunc D3DSD_RestoreSurface;

/*

 * D3D-surface specific restore function.

 * We need to make sure the D3DContext is notified if the

 * surface is lost (only if this surface is the current target,

 * otherwise it's possible that it'll get restored (along with its

 * depth buffer), and the context will still think that the clipping

 * that's set for this surface is valid.

 * Consider this scenario:

 * do {

 *     vi.validate(gc); // validated, vi's surface is restored, clipping is lost

 *     // render stuff using d3d, clipping is reset

 *     // -> surface loss event happens

 *     // do a DD blit of the VI to the screen

 *     // at this point the VI surface will be marked lost

 *     // and will be restored in validate() next time around,

 *     // losing the clipping w/o notifying the D3D context

 * } while (vi.surfaceLost());

 */

void D3DSD_RestoreSurface(JNIEnv *env, Win32SDOps *wsdo) {

    J2dTraceLn(J2D_TRACE_INFO, "D3DSD_RestoreSurface");

    D3DSDOps *d3dsdo = (D3DSDOps *)wsdo;

    // This is needed only for non-textures, since textures can't

    // lose their surfaces, as they're managed.

    if (!(d3dsdo->d3dType & D3D_TEXTURE_SURFACE) && wsdo->lpSurface != NULL)

    {

        if (wsdo->ddInstance != NULL && wsdo->ddInstance->ddObject != NULL) {

            D3DContext *d3dContext =

                wsdo->ddInstance->ddObject->GetD3dContext();

            if (d3dContext != NULL) {

                d3dContext->InvalidateIfTarget(env, wsdo->lpSurface);

            }

        }

    }

    Win32OSSD_RestoreSurface(env, wsdo);

}

/*

 * Class:     sun_java2d_d3d_D3DSurfaceData

 * Method:    initOps

 * Signature: (Ljava/lang/Object;)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_d3d_D3DSurfaceData_initOps(JNIEnv *env,

                                           jobject wsd,

                                           jint depth,

                                           jint transparency)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DSurfaceData_initOps");

    Win32SDOps *wsdo = (Win32SDOps *)SurfaceData_InitOps(env, wsd,

                                                         sizeof(D3DSDOps));

    wsdo->sdOps.Lock = Win32OSSD_Lock;

    wsdo->sdOps.GetRasInfo = Win32OSSD_GetRasInfo;

    wsdo->sdOps.Unlock = Win32OSSD_Unlock;

    wsdo->sdOps.Dispose = Win32OSSD_Dispose;

    wsdo->RestoreSurface = D3DSD_RestoreSurface;

    wsdo->GetDC = Win32OSSD_GetDC;

    wsdo->ReleaseDC = Win32OSSD_ReleaseDC;

    wsdo->InvalidateSD = Win32OSSD_InvalidateSD;

    wsdo->invalid = JNI_FALSE;

    wsdo->lockType = WIN32SD_LOCK_UNLOCKED;

    wsdo->window = NULL;

    wsdo->backBufferCount = 0;

    wsdo->depth = depth;

    switch (depth) {

        case 8:

            wsdo->pixelStride = 1;

            break;

        case 15: //555

            wsdo->pixelStride = 2;

            wsdo->pixelMasks[0] = 0x1f << 10;

            wsdo->pixelMasks[1] = 0x1f << 5;

            wsdo->pixelMasks[2] = 0x1f;

            break;

        case 16: //565

            wsdo->pixelStride = 2;

            wsdo->pixelMasks[0] = 0x1f << 11;

            wsdo->pixelMasks[1] = 0x3f << 5;

            wsdo->pixelMasks[2] = 0x1f;

            break;

        case 24:

            wsdo->pixelStride = 3;

            break;

        case 32: //x888

            wsdo->pixelStride = 4;

            wsdo->pixelMasks[0] = 0xff0000;

            wsdo->pixelMasks[1] = 0x00ff00;

            wsdo->pixelMasks[2] = 0x0000ff;

            break;

    }

    wsdo->surfaceLock = new CriticalSection();

    wsdo->surfaceLost = FALSE;

    wsdo->transparency = transparency;

    wsdo->surfacePuntData.usingDDSystem = FALSE;

    wsdo->surfacePuntData.lpSurfaceSystem = NULL;

    wsdo->surfacePuntData.lpSurfaceVram = NULL;

    wsdo->surfacePuntData.numBltsSinceRead = 0;

    wsdo->surfacePuntData.pixelsReadSinceBlt = 0;

    wsdo->surfacePuntData.numBltsThreshold = 2;

    wsdo->gdiOpPending = FALSE;

}

jboolean init_D3DSDO(JNIEnv* env, Win32SDOps* wsdo, jint width, jint height,

                     jint d3dSurfaceType, jint screen)

{

    // default in case of an error

    wsdo->lpSurface = NULL;

    wsdo->ddInstance = NULL;

    {

        Devices::InstanceAccess devices;

        wsdo->device = devices->GetDeviceReference(screen, FALSE);

    }

    if (wsdo->device == NULL) {

        J2dTraceLn1(J2D_TRACE_WARNING,

                    "init_D3DSDO: Incorrect "\

                    "screen number (screen=%d)", screen);

        wsdo->invalid = TRUE;

        return JNI_FALSE;

    }

    wsdo->w = width;

    wsdo->h = height;

    wsdo->surfacePuntData.disablePunts = TRUE;

    return JNI_TRUE;

}

/*

 * Class:     sun_java2d_d3d_D3DSurfaceData

 * Method:    initOffScreenSurface

 * Signature: (JJJIIII)I

 */

JNIEXPORT jint JNICALL

Java_sun_java2d_d3d_D3DSurfaceData_initOffScreenSurface

    (JNIEnv *env, jobject sData,

     jlong pCtx,

     jlong pData, jlong parentPdata,

     jint width, jint height,

     jint d3dSurfaceType, jint screen)

{

    Win32SDOps *wsdo = (Win32SDOps *)jlong_to_ptr(pData);

    D3DContext *pd3dc = (D3DContext *)jlong_to_ptr(pCtx);

    J2dTraceLn(J2D_TRACE_INFO, "D3DSurfaceData_initOffScreenSurface");

    J2dTraceLn4(J2D_TRACE_VERBOSE,

                "  width=%-4d height=%-4d type=%-3d scr=%-3d",

                width, height, d3dSurfaceType, screen);

    // REMIND: ideally this should be done in initOps

    if (d3dSurfaceType == D3D_ATTACHED_SURFACE) {

        wsdo->sdOps.Dispose = Win32BBSD_Dispose;

    }

    if (init_D3DSDO(env, wsdo, width, height,

                    d3dSurfaceType, screen) == JNI_FALSE)

    {

        SurfaceData_ThrowInvalidPipeException(env,

            "Can't create offscreen surface");

        return PF_INVALID;

    }

    HMONITOR hMon = (HMONITOR)wsdo->device->GetMonitor();

    DDrawObjectStruct *ddInstance = GetDDInstanceForDevice(hMon);

    if (!ddInstance || !ddInstance->valid || !pd3dc) {

        return PF_INVALID;

    }

    if (d3dSurfaceType == D3D_ATTACHED_SURFACE) {

        // REMIND: still using the old path. ideally the creation of attached

        // surface shoudld be done in the same way as other types of surfaces,

        // that is, in D3DContext::CreateSurface, but we really don't use

        // anything from D3DContext to get an attached surface, so this

        // was left here.

        Win32SDOps *wsdo_parent = (Win32SDOps *)jlong_to_ptr(parentPdata);

        // we're being explicit here: requesting backbuffer, and render target

        DDrawSurface* pNew = wsdo_parent->lpSurface == NULL ?

            NULL :

            wsdo_parent->lpSurface->

                GetDDAttachedSurface(DDSCAPS_BACKBUFFER|DDSCAPS_3DDEVICE);

        if (pNew == NULL ||

            FAILED(pd3dc->AttachDepthBuffer(pNew->GetDXSurface())))

        {

            J2dRlsTraceLn1(J2D_TRACE_ERROR,

                           "D3DSD_initSurface: GetAttachedSurface for parent"\

                           " wsdo_parent->lpSurface=0x%x failed",

                           wsdo_parent->lpSurface);

            if (pNew != NULL) {

                delete pNew;

            }

            SurfaceData_ThrowInvalidPipeException(env,

                "Can't create attached offscreen surface");

            return PF_INVALID;

        }

        wsdo->lpSurface = pNew;

        wsdo->ddInstance = ddInstance;

        J2dTraceLn2(J2D_TRACE_VERBOSE,

                    "D3DSD_initSurface: created attached surface: "\

                    "wsdo->lpSurface=0x%x for parent "\

                    "wsdo_parent->lpSurface=0x%x",

                    wsdo->lpSurface, wsdo_parent->lpSurface);

        // we don't care about pixel format for non-texture surfaces

        return PF_INVALID;

    }

    DXSurface *dxSurface = NULL;

    jint pf = PF_INVALID;

    HRESULT res;

    if (SUCCEEDED(res = pd3dc->CreateSurface(env, wsdo->w, wsdo->h,

                                             wsdo->depth, wsdo->transparency,

                                             d3dSurfaceType,

                                             &dxSurface, &pf)))

    {

        // REMIND: put all the error-handling stuff here from

        // DDCreateOffScreenSurface

        wsdo->lpSurface = new DDrawSurface(ddInstance->ddObject, dxSurface);

        wsdo->surfacePuntData.lpSurfaceVram = wsdo->lpSurface;

        wsdo->ddInstance = ddInstance;

        // the dimensions of the surface may be adjusted in case of

        // textures

        wsdo->w = dxSurface->GetWidth();

        wsdo->h = dxSurface->GetHeight();

        J2dTraceLn1(J2D_TRACE_VERBOSE,

                    "D3DSurfaceData_initSurface: created surface: "\

                    "wsdo->lpSurface=0x%x", wsdo->lpSurface);

    } else {

        DebugPrintDirectDrawError(res,

                                  "D3DSurfaceData_initSurface: "\

                                  "CreateSurface failed");

        // REMIND: should use some other way to signal that

        // surface creation was unsuccessful

        SurfaceData_ThrowInvalidPipeException(env,

                                              "Can't create offscreen surf");

    }

    return pf;

}

/*

 * Class:     sun_java2d_d3d_D3DBackBufferSurfaceData

 * Method:    restoreDepthBuffer

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_d3d_D3DBackBufferSurfaceData_restoreDepthBuffer(JNIEnv *env,

                                                                jobject sData)

{

    Win32SDOps *wsdo = Win32SurfaceData_GetOpsNoSetup(env, sData);

    J2dTraceLn1(J2D_TRACE_INFO,

                "D3DBBSD_restoreDepthBuffer: wsdo=0x%x", wsdo);

    if (wsdo != NULL) {

        if (!DDRestoreSurface(wsdo)) {

            // Failure - throw exception

            J2dRlsTraceLn(J2D_TRACE_ERROR,

                          "D3DBBSD_restoreDepthBuffer: failed to "\

                          "restore depth buffer");

            SurfaceData_ThrowInvalidPipeException(env,

                                                  "RestoreDepthBuffer failure");

        }

    }

}

}