/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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
// this state is set if adapter was successfully created
{
if (!IsD3DEnabled() ||
{
return NULL;
}
pMgr = new D3DPipelineManager();
}
} 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
"D3DPPLM::CreateInstance: unexpected instance: 0x%x,"\
" abort.", pMgr);
}
return pMgr;
}
{
}
{
return pMgr;
}
{
adapterCount = 0;
currentFSFocusAdapter = -1;
defaultFocusWindow = 0;
devType = SelectDeviceType();
}
D3DPipelineManager::~D3DPipelineManager(void)
{
ReleaseD3D();
}
{
::FreeLibrary(hLibD3D9);
}
return S_OK;
}
// Creates a Direct3D9 object and initializes adapters.
// If succeeded, returns S_OK, otherwise returns the error code.
{
return E_FAIL;
}
if (d3dcreate9 == NULL) {
::FreeLibrary(hLibD3D9);
return E_FAIL;
}
"InitD3D: unable to create IDirect3D9 object");
::FreeLibrary(hLibD3D9);
return E_FAIL;
}
ReleaseD3D();
return res;
}
return S_OK;
}
{
for (UINT i = 0; i < adapterCount; i++) {
delete pAdapters[i].pd3dContext;
}
}
delete[] pAdapters;
}
if (defaultFocusWindow != 0) {
defaultFocusWindow = 0;
}
currentFSFocusAdapter = -1;
return S_OK;
}
// static
{
int gdiScreen;
// fix for 6946559: if d3d preloading fails jmv may be NULL
return;
}
/*
* If we don't have devices initialized yet, no sense to clear them.
*/
if (!Devices::GetInstance()){
return;
}
"eventOccured", "(II)V",
}
{
return D3DADAPTER_DEFAULT;
}
}
// static
{
// NULL pMgr is valid when the pipeline is not enabled or if it hasn't
// been created yet
return S_OK;
}
" number of adapters changed (old=%d, new=%d)",
} else {
break;
}
break;
}
}
if (!bFound) {
" adapter %d: could not find hmnd=0x%x "\
"in the list of new hmnds", i, hMon);
break;
}
}
}
if (bResetD3D) {
pMgr->ReleaseD3D();
}
return res;
}
{
if (hwnd != defaultFocusWindow) {
// we're in full-screen mode
// 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.
::Sleep(100);
}
return D3DERR_DEVICELOST;
}
}
for (UINT i = 0; i < adapterCount; i++) {
" HandleLostDevices: checking adapter %d", i);
}
}
}
}
}
{
}
adapterCount = 0;
return E_FAIL;
}
res = CheckAdaptersInfo();
currentFSFocusAdapter = -1;
if (CreateDefaultFocusWindow() == 0) {
return E_FAIL;
}
return S_OK;
}
// static
{
// require Windows XP or newer client-class OS
{
"D3DPPLM::CheckOSVersion: Windows XP or newer client-classs"\
" OS detected, passed");
return S_OK;
}
"D3DPPLM::CheckOSVersion: Windows 2000 or earlier (or a "\
"server) OS detected, failed");
if (bNoHwCheck) {
" OS check overridden via J2D_D3D_NO_HWCHECK");
return S_OK;
}
return E_FAIL;
}
// static
{
int failedDevices = 0;
int attachedDevices = 0;
int i = 0;
// i<20 is to guard against buggy drivers
// get vendor ID
// get device ID
" device: vendorID=0x%04x, deviceId=0x%04x",
// 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
}
}
}
}
i++;
}
if (failedDevices == attachedDevices) {
"D3DPPLM::GDICheckForBadHardware: no suitable devices found");
return E_FAIL;
}
return S_OK;
}
if (currentOS == OS_UNDEFINED) {
{
} else {
}
} else {
}
} else {
}
} else {
}
} else {
"OS_UNKNOWN: dwMajorVersion=%d dwMinorVersion=%d\n",
}
} else {
if (bVersOk) {
"OS_UNKNOWN: dwPlatformId=%d dwMajorVersion=%d\n",
} else {
}
}
}
}
// static
{
{
// 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) &&
{
"D3DPPLM::CheckForBadHardware: found matching "\
"hardware: VendorId=0x%04x DeviceId=0x%04x",
if (goodVersion != NO_VERSION) {
// this was a match by the driver version
" bad driver found, device disabled");
" update your driver to at "\
"least version %d.%d.%d.%d",
} else {
// this was a match by the device (no good driver for this
// device)
"D3DPPLM::CheckForBadHardware: bad hardware "\
"found, device disabled");
}
if (!bNoHwCheck) {
return D3DERR_INVALIDDEVICE;
}
"overridden (via J2D_D3D_NO_HWCHECK)");
}
}
adapterInfo++;
}
return S_OK;
}
{
continue;
}
"[I] GUID : {%08X-%04X-%04X-",
{
}
}
if (failedAdaptersCount == adapterCount) {
"D3DPPLM::CheckAdaptersInfo: no suitable adapters found");
return E_FAIL;
}
return S_OK;
}
{
} else {
"unknown rasterizer: %s, only (ref|hal|nul) "\
"supported, hal selected instead", pRas);
}
}
return dtype;
}
do { \
"D3DPPLM::CheckDeviceCaps: adapter %d: Failed "\
"(cap %s not supported)", \
return E_FAIL; \
} \
} while (0)
{
// by requiring hardware tnl we are hoping for better drivers quality
if (!IsD3DForced()) {
// fail if not hw tnl unless d3d was forced
}
}
"D3DPPLM::CheckDeviceCaps: adapter %d: Failed "\
"(pixel shaders 2.0 required)", adapter);
return E_FAIL;
}
"D3DPPLM::CheckDeviceCaps: adapter %d: Passed", adapter);
return S_OK;
}
{
"D3DPPLM::D3DEnabledOnAdapter: no " \
"suitable d3d device on adapter %d", adapter);
}
return res;
}
{
break;
}
}
}
return ret;
}
{
for (int i = 0; i < 4; i++) {
D3DRTYPE_SURFACE, formats[i]);
break;
}
return newFormat;
}
{
"D3DPPLM::CreateDefaultFocusWindow: adapter=%d",
if (defaultFocusWindow != 0) {
"D3DPPLM::CreateDefaultFocusWindow: "\
"existing default focus window!");
return defaultFocusWindow;
}
if (RegisterClass(&wc) == 0) {
"D3DPPLM::CreateDefaultFocusWindow: "\
"error registering window class");
return 0;
}
"D3DPPLM::CreateDefaultFocusWindow: "\
"error getting monitor info for adapter=%d", adapterOrdinal);
return 0;
}
if (hWnd == 0) {
"D3DPPLM::CreateDefaultFocusWindow: CreateWindow failed");
} else {
" Created default focus window %x for adapter %d",
}
return hWnd;
}
{
if (currentFSFocusAdapter < 0) {
" no fs windows, using default focus window=0x%x",
return defaultFocusWindow;
}
}
{
if (currentFSFocusAdapter < 0) {
// first fs window
// REMIND: we might want to reset the rest of the context here as well
// like we do when the an adapter exits fs mode; currently they will
// be reset sometime later
} else {
// there's already a fs window
if (currentFSFocusAdapter == adapterOrdinal) {
// it's current fs window => we're exiting fs mode on this adapter;
// look for a new fs focus window
if (hWnd == 0) {
UINT i;
currentFSFocusAdapter = -1;
for (i = 0; i < adapterCount; i++) {
if (pAdapters[i].fsFocusWindow != 0) {
" adapter %d is still in fs mode", i);
break;
}
}
// we have to reset all devices any time current focus device
// exits fs mode, and also to prevent some of them being left in
// a lost state when the last device exits fs - when non-last
// adapters exit fs mode they would not be able to create the
// device and will be put in a lost state forever
" adapter exited full-screen, reset all adapters");
for (i = 0; i < adapterCount; i++) {
}
}
} else {
"D3DPM::SetFSFocusWindow: setting the fs "\
"window again for adapter %d", adapterOrdinal);
}
}
}
return prev;
}
{
{
"D3DPPLM::GetD3DContext: invalid parameters or "\
"failed init for adapter %d", adapterOrdinal);
*ppd3dContext = NULL;
return E_FAIL;
}
"uninitialized adapter %d", adapterOrdinal);
} else {
" initializing context for adapter %d",adapterOrdinal);
"D3DPPLM::GetD3DContext: failed to create context "\
"for adapter=%d", adapterOrdinal);
}
} else {
"D3DPPLM::GetContext: no d3d on adapter %d",adapterOrdinal);
}
}
}
return res;
}
//==============================================================
// D3DInitializer
//==============================================================
{
}
{
if (pAdapterIniters) {
delete[] pAdapterIniters;
}
}
{
bComInitialized = true;
}
// init adapters if we are preloading
for (UINT i=0; i<adapterCount; i++) {
pAdapterIniters[i].setAdapter(i);
}
}
}
}
{
if (bComInitialized) {
}
}
{
return;
}
}
{
// nothing to do - D3DPipelineManager cleans adapters
}
extern "C" {
/*
* Export function to start D3D preloading
*/
{
return 1;
}
}