/*

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

 */

#include "D3DBadHardware.h"

#include "D3DPipelineManager.h"

#include "D3DRenderQueue.h"

#include "WindowsFlags.h"

#include "awt_Win32GraphicsDevice.h"

// state of the adapter prior to initialization

#define CONTEXT_NOT_INITED 0

// this state is set if adapter initialization had failed

#define CONTEXT_INIT_FAILED (-1)

// this state is set if adapter was successfully created

#define CONTEXT_CREATED 1

static BOOL bNoHwCheck = (getenv("J2D_D3D_NO_HWCHECK") != NULL);

D3DPipelineManager *D3DPipelineManager::pMgr = NULL;

D3DPipelineManager * D3DPipelineManager::CreateInstance(void)

{

    if (!IsD3DEnabled() ||

        FAILED((D3DPipelineManager::CheckOSVersion())) ||

        FAILED((D3DPipelineManager::GDICheckForBadHardware())))

    {

        return NULL;

    }

    if (pMgr == NULL) {

        pMgr = new D3DPipelineManager();

        if (FAILED(pMgr->InitD3D())) {

            SAFE_DELETE(pMgr);

        }

    } else {

        // this should never happen so to be on the safe side do not

        // use this unexpected pointer, do not try to release it, just null

        // it out and fail safely

        J2dRlsTraceLn1(J2D_TRACE_ERROR,

                       "D3DPPLM::CreateInstance: unexpected instance: 0x%x,"\

                       " abort.", pMgr);

        pMgr = NULL;

    }

    return pMgr;

}

void D3DPipelineManager::DeleteInstance()

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::DeleteInstance()");

    SAFE_DELETE(pMgr);

}

D3DPipelineManager * D3DPipelineManager::GetInstance(void)

{

    return pMgr;

}

D3DPipelineManager::D3DPipelineManager(void)

{

    pd3d9 = NULL;

    hLibD3D9 = NULL;

    pAdapters = NULL;

    adapterCount = 0;

    currentFSFocusAdapter = -1;

    defaultFocusWindow = 0;

    devType = SelectDeviceType();

}

D3DPipelineManager::~D3DPipelineManager(void)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::~D3DPipelineManager()");

    ReleaseD3D();

}

HRESULT D3DPipelineManager::ReleaseD3D(void)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::ReleaseD3D()");

    ReleaseAdapters();

    SAFE_RELEASE(pd3d9);

    if (hLibD3D9 != NULL) {

        ::FreeLibrary(hLibD3D9);

        hLibD3D9 = NULL;

    }

    return S_OK;

}

// Creates a Direct3D9 object and initializes adapters.

// If succeeded, returns S_OK, otherwise returns the error code.

HRESULT D3DPipelineManager::InitD3D(void)

{

    typedef IDirect3D9 * WINAPI FnDirect3DCreate9(UINT SDKVersion);

    hLibD3D9 = ::LoadLibrary(TEXT("d3d9.dll"));

    if (hLibD3D9 == NULL) {

        J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: no d3d9.dll");

        return E_FAIL;

    }

    FnDirect3DCreate9 *d3dcreate9 = NULL;

    d3dcreate9 = (FnDirect3DCreate9*)

        ::GetProcAddress(hLibD3D9, "Direct3DCreate9");

    if (d3dcreate9 == NULL) {

        J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: no Direct3DCreate9");

        ::FreeLibrary(hLibD3D9);

        return E_FAIL;

    }

    pd3d9 = d3dcreate9(D3D_SDK_VERSION);

    if (pd3d9 == NULL) {

        J2dRlsTraceLn(J2D_TRACE_ERROR,

            "InitD3D: unable to create IDirect3D9 object");

        ::FreeLibrary(hLibD3D9);

        return E_FAIL;

    }

    HRESULT res;

    if (FAILED(res = InitAdapters())) {

        J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: failed to init adapters");

        ReleaseD3D();

        return res;

    }

    return S_OK;

}

HRESULT D3DPipelineManager::ReleaseAdapters()

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::ReleaseAdapters()");

    D3DRQ_ResetCurrentContextAndDestination();

    if (pAdapters != NULL) {

        for (UINT i = 0; i < adapterCount; i++) {

            if (pAdapters[i].pd3dContext != NULL) {

                delete pAdapters[i].pd3dContext;

            }

        }

        delete[] pAdapters;

        pAdapters = NULL;

    }

    if (defaultFocusWindow != 0) {

        DestroyWindow(defaultFocusWindow);

        UnregisterClass(L"D3DFocusWindow", GetModuleHandle(NULL));

        defaultFocusWindow = 0;

    }

    currentFSFocusAdapter = -1;

    return S_OK;

}

// static

void D3DPipelineManager::NotifyAdapterEventListeners(UINT adapter,

                                                     jint eventType)

{

    HMONITOR hMon;

    int gdiScreen;

    D3DPipelineManager *pMgr;

    // fix for 6946559: if d3d preloading fails jmv may be NULL

    if (jvm == NULL) {

        return;

    }

    JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

    pMgr = D3DPipelineManager::GetInstance();

    RETURN_IF_NULL(pMgr);

    hMon = pMgr->pd3d9->GetAdapterMonitor(adapter);

    gdiScreen = AwtWin32GraphicsDevice::GetScreenFromHMONITOR(hMon);

    JNU_CallStaticMethodByName(env, NULL,

        "sun/java2d/pipe/hw/AccelDeviceEventNotifier",

        "eventOccured", "(II)V",

        gdiScreen, eventType);

}

UINT D3DPipelineManager::GetAdapterOrdinalForScreen(jint gdiScreen)

{

    HMONITOR mHnd = AwtWin32GraphicsDevice::GetMonitor(gdiScreen);

    if (mHnd == (HMONITOR)0) {

        return D3DADAPTER_DEFAULT;

    }

    return GetAdapterOrdinalByHmon((HMONITOR)mHnd);

}

// static

HRESULT D3DPipelineManager::HandleAdaptersChange(HMONITOR *pHMONITORs, UINT monNum)

{

    HRESULT res = S_OK;

    BOOL bResetD3D = FALSE, bFound;

    D3DPipelineManager *pMgr = D3DPipelineManager::GetInstance();

    RETURN_STATUS_IF_NULL(pHMONITORs, E_FAIL);

    if (pMgr == NULL) {

        // NULL pMgr is valid when the pipeline is not enabled or if it hasn't

        // been created yet

        return S_OK;

    }

    RETURN_STATUS_IF_NULL(pMgr->pAdapters, E_FAIL);

    RETURN_STATUS_IF_NULL(pMgr->pd3d9, E_FAIL);

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::HandleAdaptersChange");

    if (monNum != pMgr->adapterCount) {

        J2dTraceLn2(J2D_TRACE_VERBOSE,

                   "  number of adapters changed (old=%d, new=%d)",

                   pMgr->adapterCount, monNum);

        bResetD3D = TRUE;

    } else {

        for (UINT i = 0; i < pMgr->adapterCount; i++) {

            HMONITOR hMon = pMgr->pd3d9->GetAdapterMonitor(i);

            if (hMon == (HMONITOR)0x0) {

                J2dTraceLn1(J2D_TRACE_VERBOSE, "  adapter %d: removed", i);

                bResetD3D = TRUE;

                break;

            }

            bFound = FALSE;

            for (UINT mon = 0; mon < monNum; mon++) {

                if (pHMONITORs[mon] == hMon) {

                    J2dTraceLn3(J2D_TRACE_VERBOSE,

                            "  adapter %d: found hmnd[%d]=0x%x", i, mon, hMon);

                    bFound = TRUE;

                    break;

                }

            }

            if (!bFound) {

                J2dTraceLn2(J2D_TRACE_VERBOSE,

                            "  adapter %d: could not find hmnd=0x%x "\

                            "in the list of new hmnds", i, hMon);

                bResetD3D = TRUE;

                break;

            }

        }

    }

    if (bResetD3D) {

        J2dTraceLn(J2D_TRACE_VERBOSE, "  adapters changed: resetting d3d");

        pMgr->ReleaseD3D();

        res = pMgr->InitD3D();

    }

    return res;

}

HRESULT D3DPipelineManager::HandleLostDevices()

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::HandleLostDevices()");

    BOOL bAllClear = TRUE;

    HWND hwnd = GetCurrentFocusWindow();

    if (hwnd != defaultFocusWindow) {

        // we're in full-screen mode

        WINDOWPLACEMENT wp;

        ::ZeroMemory(&wp, sizeof(WINDOWPLACEMENT));

        wp.length = sizeof(WINDOWPLACEMENT);

        ::GetWindowPlacement(hwnd, &wp);

        // Only attempt to restore the devices if we're in full-screen mode

        // and the fs window is active; sleep otherwise.

        // Restoring a window while minimized causes problems on Vista:

        // sometimes we restore the window too quickly and it pops up back from

        // minimized state when the device is restored.

        //

        // WARNING: this is a sleep on the Toolkit thread! We may reconsider

        // this if we find any issues later.

        if ((wp.showCmd & SW_SHOWMINNOACTIVE) && !(wp.showCmd & SW_SHOWNORMAL)){

            static DWORD prevCallTime = 0;

            J2dTraceLn(J2D_TRACE_VERBOSE, "  fs focus window is minimized");

            DWORD currentTime = ::GetTickCount();

            if ((currentTime - prevCallTime) < 100) {

                J2dTraceLn(J2D_TRACE_VERBOSE, "  tight loop detected, sleep");

                ::Sleep(100);

            }

            prevCallTime = currentTime;

            return D3DERR_DEVICELOST;

        }

    }

    if (pAdapters != NULL) {

        for (UINT i = 0; i < adapterCount; i++) {

            if (pAdapters[i].pd3dContext != NULL) {

                J2dTraceLn1(J2D_TRACE_VERBOSE,

                            "  HandleLostDevices: checking adapter %d", i);

                D3DContext *d3dc = pAdapters[i].pd3dContext;

                if (FAILED(d3dc->CheckAndResetDevice())) {

                    bAllClear = FALSE;

                }

            }

        }

    }

    return bAllClear ? S_OK : D3DERR_DEVICELOST;

}

HRESULT D3DPipelineManager::InitAdapters()

{

    HRESULT res = E_FAIL;

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::InitAdapters()");

    if (pAdapters != NULL) {

        ReleaseAdapters();

    }

    adapterCount = pd3d9->GetAdapterCount();

    pAdapters = new D3DAdapter[adapterCount];

    if (pAdapters == NULL) {

        J2dRlsTraceLn(J2D_TRACE_ERROR, "InitAdapters: out of memory");

        adapterCount = 0;

        return E_FAIL;

    }

    ZeroMemory(pAdapters, adapterCount * sizeof(D3DAdapter));

    res = CheckAdaptersInfo();

    RETURN_STATUS_IF_FAILED(res);

    currentFSFocusAdapter = -1;

    if (CreateDefaultFocusWindow() == 0) {

        return E_FAIL;

    }

    return S_OK;

}

// static

HRESULT

D3DPipelineManager::CheckOSVersion()

{

    // require Windows XP or newer client-class OS

    if (IS_WINVER_ATLEAST(5, 1) &&

        !D3DPPLM_OsVersionMatches(OS_WINSERV_2008|OS_WINSERV_2003))

    {

        J2dTraceLn(J2D_TRACE_INFO,

                   "D3DPPLM::CheckOSVersion: Windows XP or newer client-classs"\

                   " OS detected, passed");

        return S_OK;

    }

    J2dRlsTraceLn(J2D_TRACE_ERROR,

                  "D3DPPLM::CheckOSVersion: Windows 2000 or earlier (or a "\

                  "server) OS detected, failed");

    if (bNoHwCheck) {

        J2dRlsTraceLn(J2D_TRACE_WARNING,

                      "  OS check overridden via J2D_D3D_NO_HWCHECK");

        return S_OK;

    }

    return E_FAIL;

}

// static

HRESULT

D3DPipelineManager::GDICheckForBadHardware()

{

    DISPLAY_DEVICE dd;

    dd.cb = sizeof(DISPLAY_DEVICE);

    int failedDevices = 0;

    int attachedDevices = 0;

    int i = 0;

    WCHAR *id;

    WCHAR vendorId[5];

    WCHAR deviceId[5];

    DWORD dwDId, dwVId;

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::GDICheckForBadHardware");

    // i<20 is to guard against buggy drivers

    while (EnumDisplayDevices(NULL, i, &dd, 0) && i < 20) {

        if (dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) {

            attachedDevices++;

            id = dd.DeviceID;

            if (wcslen(id) > 21) {

                // get vendor ID

                wcsncpy(vendorId, id+8, 4);

                int args1 = swscanf(vendorId, L"%X", &dwVId);

                // get device ID

                wcsncpy(deviceId, id+17, 4);

                int args2 = swscanf(deviceId, L"%X", &dwDId);

                if (args1 == 1 && args2 == 1) {

                    J2dTraceLn2(J2D_TRACE_VERBOSE,

                                "  device: vendorID=0x%04x, deviceId=0x%04x",

                                dwVId, dwDId);

                    // since we don't have a driver version here we will

                    // just ask to ignore the version for now; bad hw

                    // entries with specific drivers information will be

                    // processed later when d3d is initialized and we can

                    // obtain a driver version

                    if (FAILED(CheckForBadHardware(dwVId, dwDId, MAX_VERSION))){

                        failedDevices++;

                    }

                }

            }

        }

        i++;

    }

    if (failedDevices == attachedDevices) {

        J2dRlsTraceLn(J2D_TRACE_ERROR,

            "D3DPPLM::GDICheckForBadHardware: no suitable devices found");

        return E_FAIL;

    }

    return S_OK;

}

BOOL D3DPPLM_OsVersionMatches(USHORT osInfo) {

    static USHORT currentOS = OS_UNDEFINED;

    if (currentOS == OS_UNDEFINED) {

        BOOL bVersOk;

        OSVERSIONINFOEX osvi;

        ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));

        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

        bVersOk = GetVersionEx((OSVERSIONINFO *) &osvi);

        J2dRlsTrace(J2D_TRACE_INFO, "[I] OS Version = ");

        if (bVersOk && osvi.dwPlatformId == VER_PLATFORM_WIN32_NT &&

            osvi.dwMajorVersion > 4)

        {

            if (osvi.dwMajorVersion >= 6 && osvi.dwMinorVersion >= 0) {

                if (osvi.wProductType == VER_NT_WORKSTATION) {

                    J2dRlsTrace(J2D_TRACE_INFO, "OS_VISTA or newer\n");

                    currentOS = OS_VISTA;

                } else {

                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINSERV_2008 or newer\n");

                    currentOS = OS_WINSERV_2008;

                }

            } else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) {

                if (osvi.wProductType == VER_NT_WORKSTATION) {

                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINXP_64\n");

                    currentOS = OS_WINXP_64;

                } else {

                    J2dRlsTrace(J2D_TRACE_INFO, "OS_WINSERV_2003\n");

                    currentOS = OS_WINSERV_2003;

                }

            } else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) {

                J2dRlsTrace(J2D_TRACE_INFO, "OS_WINXP ");

                currentOS = OS_WINXP;

                if (osvi.wSuiteMask & VER_SUITE_PERSONAL) {

                    J2dRlsTrace(J2D_TRACE_INFO, "Home\n");

                } else {

                    J2dRlsTrace(J2D_TRACE_INFO, "Pro\n");

                }

            } else {

                J2dRlsTrace2(J2D_TRACE_INFO,

                            "OS_UNKNOWN: dwMajorVersion=%d dwMinorVersion=%d\n",

                             osvi.dwMajorVersion, osvi.dwMinorVersion);

                currentOS = OS_UNKNOWN;

            }

        } else {

            if (bVersOk) {

                J2dRlsTrace2(J2D_TRACE_INFO,

                             "OS_UNKNOWN: dwPlatformId=%d dwMajorVersion=%d\n",

                             osvi.dwPlatformId, osvi.dwMajorVersion);

            } else {

                J2dRlsTrace(J2D_TRACE_INFO,"OS_UNKNOWN: GetVersionEx failed\n");

            }

            currentOS = OS_UNKNOWN;

        }

    }

    return (currentOS & osInfo);

}

// static

HRESULT

D3DPipelineManager::CheckForBadHardware(DWORD vId, DWORD dId, LONGLONG version)

{

    DWORD vendorId, deviceId;

    UINT adapterInfo = 0;

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::CheckForBadHardware");

    while ((vendorId = badHardware[adapterInfo].VendorId) != 0x0000 &&

           (deviceId = badHardware[adapterInfo].DeviceId) != 0x0000)

    {

        if (vendorId == vId && (deviceId == dId || deviceId == ALL_DEVICEIDS)) {

            LONGLONG goodVersion = badHardware[adapterInfo].DriverVersion;

            USHORT osInfo = badHardware[adapterInfo].OsInfo;

            // the hardware check fails if:

            // - we have an entry for this OS and

            // - hardware is bad for all driver versions (NO_VERSION), or

            //   we have a driver version which is older than the

            //   minimum required for this OS

            if (D3DPPLM_OsVersionMatches(osInfo) &&

                (goodVersion == NO_VERSION || version < goodVersion))

            {

                J2dRlsTraceLn2(J2D_TRACE_ERROR,

                    "D3DPPLM::CheckForBadHardware: found matching "\

                    "hardware: VendorId=0x%04x DeviceId=0x%04x",

                    vendorId, deviceId);

                if (goodVersion != NO_VERSION) {

                    // this was a match by the driver version

                    LARGE_INTEGER li;

                    li.QuadPart = goodVersion;

                    J2dRlsTraceLn(J2D_TRACE_ERROR,

                                  "  bad driver found, device disabled");

                    J2dRlsTraceLn4(J2D_TRACE_ERROR,

                                   "  update your driver to at "\

                                   "least version %d.%d.%d.%d",

                                   HIWORD(li.HighPart), LOWORD(li.HighPart),