/*

 * 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

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

 *

 * 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.

 *

 */

#include "sun_java2d_d3d_D3DGraphicsDevice.h"

#include "D3DGraphicsDevice.h"

#include "D3DPipelineManager.h"

#include "D3DRenderQueue.h"

#include "Trace.h"

#include "awt_Toolkit.h"

#include "awt_Window.h"

extern jobject CreateDisplayMode(JNIEnv* env, jint width, jint height,

                                 jint bitDepth, jint refreshRate);

extern void addDisplayMode(JNIEnv* env, jobject arrayList, jint width,

                           jint height, jint bitDepth, jint refreshRate);

void InitD3D(void *pReturn)

{

    J2dTraceLn(J2D_TRACE_INFO, "InitD3D");

    jboolean *pRet = (jboolean *)pReturn;

    D3DPipelineManager *pMgr = D3DPipelineManager::CreateInstance();

    if (pMgr == NULL) {

        J2dTraceLn(J2D_TRACE_ERROR, "InitD3D: could not create or init d3d");

        *pRet = JNI_FALSE;

    } else {

        J2dTraceLn(J2D_TRACE_INFO, "InitD3D: successfully initialized d3d");

        *pRet = JNI_TRUE;

    }

}

extern "C" {

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    initD3D

 * Signature: ()Z

 */

JNIEXPORT jboolean JNICALL Java_sun_java2d_d3d_D3DGraphicsDevice_initD3D

  (JNIEnv *env, jclass)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_initD3D");

    jboolean result = JNI_FALSE;

    AwtToolkit::GetInstance().InvokeFunction(InitD3D, &result);

    J2dTraceLn1(J2D_TRACE_INFO, "D3DGD_initD3D: result=%x", result);

    return result;

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    getDeviceIdNative

 * Signature: (I)Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_sun_java2d_d3d_D3DGraphicsDevice_getDeviceIdNative

  (JNIEnv *env, jclass d3dsdc, jint gdiScreen)

{

    D3DPipelineManager *pMgr;

    UINT adapter;

    D3DADAPTER_IDENTIFIER9 aid;

    IDirect3D9 *pd3d9;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_getDeviceIdNative");

    pMgr = D3DPipelineManager::GetInstance();

    RETURN_STATUS_IF_NULL(pMgr, NULL);

    pd3d9 = pMgr->GetD3DObject();

    RETURN_STATUS_IF_NULL(pd3d9, NULL);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(pd3d9->GetAdapterIdentifier(adapter, 0, &aid))) {

        return NULL;

    }

    // ('%d.' will take no more than 6+1 chars since we are printing a WORD)

    //            AAAA&BBBB MAX_DEVICE_IDENTIFIER_STRING (%d.%d.%d.%d)0

    size_t len = (4+1+4  +1+MAX_DEVICE_IDENTIFIER_STRING+1 +1+(6+1)*4+1 +1);

    WCHAR *pAdapterId = new WCHAR[len];

    RETURN_STATUS_IF_NULL(pAdapterId, NULL);

    _snwprintf(pAdapterId, len, L"%x&%x %S (%d.%d.%d.%d)",

               0xffff & aid.VendorId, 0xffff & aid.DeviceId, aid.Description,

               HIWORD(aid.DriverVersion.HighPart),

               LOWORD(aid.DriverVersion.HighPart),

               HIWORD(aid.DriverVersion.LowPart),

               LOWORD(aid.DriverVersion.LowPart));

    // _snwprintf doesn't add 0 at the end if the formatted string didn't fit

    // in the buffer so we have to make sure it is null terminated

    pAdapterId[len-1] = (WCHAR)0;

    J2dTraceLn1(J2D_TRACE_VERBOSE, "  id=%S", pAdapterId);

    jstring ret = JNU_NewStringPlatform(env, pAdapterId);

    delete pAdapterId;

    return ret;

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    getDeviceCapsNative

 * Signature: (I)I

 */

JNIEXPORT jint JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_getDeviceCapsNative

  (JNIEnv *env, jclass d3dsdc, jint gdiScreen)

{

    D3DPipelineManager *pMgr;

    D3DContext *pCtx;

    UINT adapter;

    J2dRlsTraceLn(J2D_TRACE_INFO, "D3DGD_getDeviceCapsNative");

    pMgr = D3DPipelineManager::GetInstance();

    RETURN_STATUS_IF_NULL(pMgr, CAPS_EMPTY);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(pMgr->GetD3DContext(adapter, &pCtx))) {

        J2dRlsTraceLn1(J2D_TRACE_ERROR,

                      "D3DGD_getDeviceCapsNative: device %d disabled", adapter);

        return CAPS_EMPTY;

    }

    return pCtx->GetContextCaps();

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    enterFullScreenExclusiveNative

 * Signature: (IJ)V

 */

JNIEXPORT jboolean JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_enterFullScreenExclusiveNative

  (JNIEnv *env, jclass gdc, jint gdiScreen, jlong window)

{

    HRESULT res;

    D3DPipelineManager *pMgr;

    D3DContext *pCtx;

    HWND hWnd;

    AwtWindow *w;

    D3DPRESENT_PARAMETERS newParams, *pCurParams;

    D3DDISPLAYMODE dm;

    UINT adapter;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_enterFullScreenExclusiveNative");

    RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), JNI_FALSE);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(res = pMgr->GetD3DContext(adapter, &pCtx))) {

        D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

        return JNI_FALSE;

    }

    w = (AwtWindow *)AwtComponent::GetComponent((HWND)window);

    if (w == NULL || !::IsWindow(hWnd = w->GetTopLevelHWnd())) {

        J2dTraceLn(J2D_TRACE_WARNING,

                   "D3DGD_enterFullScreenExclusiveNative: disposed window");

        return JNI_FALSE;

    }

    // REMIND: should we also move the non-topleve window from

    // being on top here (it's moved to front in GraphicsDevice.setFSW())?

    pCtx->Get3DObject()->GetAdapterDisplayMode(adapter, &dm);

    pCurParams = pCtx->GetPresentationParams();

    // let the mananger know that we're entering the fs mode, it will

    // set the proper current focus window for us, which ConfigureContext will

    // use when creating the device

    pMgr->SetFSFocusWindow(adapter, hWnd);

    newParams = *pCurParams;

    newParams.hDeviceWindow = hWnd;

    newParams.Windowed = FALSE;

    newParams.BackBufferCount = 1;

    newParams.BackBufferFormat = dm.Format;

    newParams.FullScreen_RefreshRateInHz = dm.RefreshRate;

    newParams.BackBufferWidth = dm.Width;

    newParams.BackBufferHeight = dm.Height;

    newParams.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;

    newParams.SwapEffect = D3DSWAPEFFECT_DISCARD;

    res = pCtx->ConfigureContext(&newParams);

    D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

    return SUCCEEDED(res);

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    exitFullScreenExclusiveNative

 * Signature: (I)V

 */

JNIEXPORT jboolean JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_exitFullScreenExclusiveNative

  (JNIEnv *env, jclass gdc, jint gdiScreen)

{

    HRESULT res;

    D3DPipelineManager *pMgr;

    D3DContext *pCtx;

    D3DPRESENT_PARAMETERS newParams, *pCurParams;

    UINT adapter;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_exitFullScreenExclusiveNative");

    RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), JNI_FALSE);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(res = pMgr->GetD3DContext(adapter, &pCtx))) {

        D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

        return JNI_FALSE;

    }

    pCurParams = pCtx->GetPresentationParams();

    newParams = *pCurParams;

    // we're exiting fs, the device window can be 0

    newParams.hDeviceWindow = 0;

    newParams.Windowed = TRUE;

    newParams.BackBufferFormat = D3DFMT_UNKNOWN;

    newParams.BackBufferCount = 1;

    newParams.FullScreen_RefreshRateInHz = 0;

    newParams.BackBufferWidth = 0;

    newParams.BackBufferHeight = 0;

    newParams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

    newParams.SwapEffect = D3DSWAPEFFECT_COPY;

    res = pCtx->ConfigureContext(&newParams);

    D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

    // exited fs, update current focus window

    // note that we call this after this adapter exited fs mode so that

    // the rest of the adapters can be reset

    pMgr->SetFSFocusWindow(adapter, 0);

    return SUCCEEDED(res);

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    configDisplayModeNative

 * Signature: (IJIIII)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_configDisplayModeNative

  (JNIEnv *env, jclass gdc, jint gdiScreen, jlong window,

   jint width, jint height, jint bitDepth, jint refreshRate)

{

    HRESULT res;

    D3DPipelineManager *pMgr;

    D3DContext *pCtx;

    D3DPRESENT_PARAMETERS newParams, *pCurParams;

    UINT adapter;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_configDisplayModeNative");

    RETURN_IF_NULL(pMgr = D3DPipelineManager::GetInstance());

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(res = pMgr->GetD3DContext(adapter, &pCtx))) {

        D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

        return;

    }

    pCurParams = pCtx->GetPresentationParams();

    newParams = *pCurParams;

    newParams.BackBufferWidth = width;

    newParams.BackBufferHeight = height;

    newParams.FullScreen_RefreshRateInHz = refreshRate;

    newParams.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;

    // we leave the swap effect so that it's more likely

    // to be the one user selected initially

//    newParams.SwapEffect = D3DSWAPEFFECT_DISCARD;

    if (bitDepth == 32) {

        newParams.BackBufferFormat = D3DFMT_X8R8G8B8;

    } else if (bitDepth == 16) {

        UINT modeNum;

        D3DDISPLAYMODE mode;

        IDirect3D9 *pd3d9;

        UINT modesCount;

        RETURN_IF_NULL(pd3d9 = pMgr->GetD3DObject());

        modesCount = pd3d9->GetAdapterModeCount(adapter, D3DFMT_R5G6B5);

        if (modesCount == 0) {

            modesCount = pd3d9->GetAdapterModeCount(adapter, D3DFMT_X1R5G5B5);

        }

        newParams.BackBufferFormat = D3DFMT_UNKNOWN;

        for (modeNum = 0; modeNum < modesCount; modeNum++) {

            if (SUCCEEDED(pd3d9->EnumAdapterModes(adapter, D3DFMT_R5G6B5,

                                                  modeNum, &mode)))

            {

                if (mode.Width == width && mode.Height == height &&

                    mode.RefreshRate == refreshRate)

                {

                    // prefer 565 over 555

                    if (mode.Format == D3DFMT_R5G6B5) {

                        newParams.BackBufferFormat = D3DFMT_R5G6B5;

                        break;

                    } else if (mode.Format == D3DFMT_X1R5G5B5) {

                        newParams.BackBufferFormat = D3DFMT_X1R5G5B5;

                    }

                }

            }

        }

        if (newParams.BackBufferFormat == D3DFMT_UNKNOWN) {

            J2dRlsTraceLn(J2D_TRACE_ERROR,

                          "D3DGD_configDisplayModeNative: no 16-bit formats");

            return;

        }

    } else {

        J2dRlsTraceLn1(J2D_TRACE_ERROR,

                       "D3DGD_configDisplayModeNative: unsupported depth: %d",

                       bitDepth);

        return;

    }

    J2dTraceLn4(J2D_TRACE_VERBOSE, "  changing to dm: %dx%dx%d@%d",

                newParams.BackBufferWidth, newParams.BackBufferHeight,

                bitDepth, refreshRate);

    J2dTraceLn1(J2D_TRACE_VERBOSE, "  selected backbuffer format: %d",

                newParams.BackBufferFormat);

    res = pCtx->ConfigureContext(&newParams);

    if (SUCCEEDED(res)) {

        // the full screen window doesn't receive WM_SIZE event when

        // the display mode changes (it does get resized though) so we need to

        // generate the event ourselves

        ::SendMessage(newParams.hDeviceWindow, WM_SIZE, width, height);

    }

    D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    getCurrentDisplayModeNative

 * Signature: (I)Ljava/awt/DisplayMode;

 */

JNIEXPORT jobject JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_getCurrentDisplayModeNative

  (JNIEnv *env, jclass gdc, jint gdiScreen)

{

    D3DPipelineManager *pMgr;

    IDirect3D9 *pd3d9;

    jobject ret = NULL;

    D3DDISPLAYMODE mode;

    UINT adapter;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_getCurrentDisplayModeNative");

    RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), NULL);

    RETURN_STATUS_IF_NULL(pd3d9 = pMgr->GetD3DObject(), NULL);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (SUCCEEDED(pd3d9->GetAdapterDisplayMode(adapter, &mode))) {

        int bitDepth = -1;

        // these are the only three valid screen formats

        switch (mode.Format) {

            case D3DFMT_X8R8G8B8: bitDepth = 32; break;

            case D3DFMT_R5G6B5:

            case D3DFMT_X1R5G5B5: bitDepth = 16; break;

        }

        J2dTraceLn4(J2D_TRACE_VERBOSE,

                    "  current dm: %dx%dx%d@%d",

                    mode.Width, mode.Height, bitDepth, mode.RefreshRate);

        ret = CreateDisplayMode(env, mode.Width, mode.Height, bitDepth,

                                mode.RefreshRate);

    }

    return ret;

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    enumDisplayModesNative

 * Signature: (ILjava/util/ArrayList;)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_enumDisplayModesNative

  (JNIEnv *env, jclass gdc, jint gdiScreen, jobject arrayList)

{

    D3DPipelineManager *pMgr;

    IDirect3D9 *pd3d9;

    jobject ret = NULL;

    D3DDISPLAYMODE mode;

    UINT formatNum, modeNum, modesCount;

    UINT adapter;

    // EnumAdapterModes treats 555 and 565 formats as equivalents

    static D3DFORMAT formats[] =

        { D3DFMT_X8R8G8B8, D3DFMT_R5G6B5 };

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_enumDisplayModesNative");

    RETURN_IF_NULL(pMgr = D3DPipelineManager::GetInstance());

    RETURN_IF_NULL(pd3d9 = pMgr->GetD3DObject());

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    for (formatNum = 0; formatNum < 3; formatNum++) {

        modesCount = pd3d9->GetAdapterModeCount(adapter, formats[formatNum]);

        for (modeNum = 0; modeNum < modesCount; modeNum++) {

            if (SUCCEEDED(pd3d9->EnumAdapterModes(adapter, formats[formatNum],

                                                  modeNum, &mode)))

            {

                int bitDepth = -1;

                // these are the only three valid screen formats,

                // 30-bit is returned as X8R8G8B8

                switch (mode.Format) {

                    case D3DFMT_X8R8G8B8: bitDepth = 32; break;

                    case D3DFMT_R5G6B5:

                    case D3DFMT_X1R5G5B5: bitDepth = 16; break;

                }

                J2dTraceLn4(J2D_TRACE_VERBOSE, "  found dm: %dx%dx%d@%d",

                            mode.Width, mode.Height, bitDepth,mode.RefreshRate);

                addDisplayMode(env, arrayList, mode.Width, mode.Height,

                               bitDepth, mode.RefreshRate);

            }

        }

    }

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    getAvailableAcceleratedMemoryNative

 * Signature: (I)J

 */

JNIEXPORT jlong JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_getAvailableAcceleratedMemoryNative

  (JNIEnv *env, jclass gdc, jint gdiScreen)

{

    // REMIND: looks like Direct3D provides information about texture memory

    // only via IDirect3DDevice9::GetAvailableTextureMem, however, it

    // seems to report the same amount as direct draw used to.

    HRESULT res;

    D3DPipelineManager *pMgr;

    D3DContext *pCtx;

    IDirect3DDevice9 *pd3dDevice;

    UINT adapter;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_getAvailableAcceleratedMemoryNative");

    RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), 0L);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(res = pMgr->GetD3DContext(adapter, &pCtx))) {

        D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

        return 0L;

    }

    RETURN_STATUS_IF_NULL(pd3dDevice = pCtx->Get3DDevice(), 0L);

    UINT mem = pd3dDevice->GetAvailableTextureMem();

    J2dTraceLn1(J2D_TRACE_VERBOSE, "  available memory=%d", mem);

    return mem;

}

/*

 * Class:     sun_java2d_d3d_D3DGraphicsDevice

 * Method:    isD3DAvailableOnDeviceNative

 * Signature: (I)Z

 */

JNIEXPORT jboolean JNICALL

Java_sun_java2d_d3d_D3DGraphicsDevice_isD3DAvailableOnDeviceNative

  (JNIEnv *env, jclass gdc, jint gdiScreen)

{

    HRESULT res;

    D3DPipelineManager *pMgr;

    D3DContext *pCtx;

    UINT adapter;

    J2dTraceLn(J2D_TRACE_INFO, "D3DGD_isD3DAvailableOnDeviceNative");

    RETURN_STATUS_IF_NULL(pMgr = D3DPipelineManager::GetInstance(), JNI_FALSE);

    adapter = pMgr->GetAdapterOrdinalForScreen(gdiScreen);

    if (FAILED(res = pMgr->GetD3DContext(adapter, &pCtx))) {

        D3DRQ_MarkLostIfNeeded(res, D3DRQ_GetCurrentDestination());

        return JNI_FALSE;

    }

    return JNI_TRUE;

}

} // extern "C"