michael@0: /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
michael@0:  * This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "DeviceManagerD3D9.h"
michael@0: #include "LayerManagerD3D9Shaders.h"
michael@0: #include "ThebesLayerD3D9.h"
michael@0: #include "nsIServiceManager.h"
michael@0: #include "nsIConsoleService.h"
michael@0: #include "nsPrintfCString.h"
michael@0: #include "Nv3DVUtils.h"
michael@0: #include "plstr.h"
michael@0: #include <algorithm>
michael@0: #include "gfx2DGlue.h"
michael@0: #include "gfxPlatform.h"
michael@0: #include "gfxWindowsPlatform.h"
michael@0: #include "TextureD3D9.h"
michael@0: #include "mozilla/gfx/Point.h"
michael@0: 
michael@0: using namespace mozilla::gfx;
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace layers {
michael@0: 
michael@0: const LPCWSTR kClassName       = L"D3D9WindowClass";
michael@0: 
michael@0: #define USE_D3D9EX
michael@0: 
michael@0: struct vertex {
michael@0:   float x, y;
michael@0: };
michael@0: 
michael@0: SwapChainD3D9::SwapChainD3D9(DeviceManagerD3D9 *aDeviceManager)
michael@0:   : mDeviceManager(aDeviceManager)
michael@0:   , mWnd(0)
michael@0: {
michael@0:   mDeviceManager->mSwapChains.AppendElement(this);
michael@0: }
michael@0: 
michael@0: SwapChainD3D9::~SwapChainD3D9()
michael@0: {
michael@0:   mDeviceManager->mSwapChains.RemoveElement(this);
michael@0: }
michael@0: 
michael@0: bool
michael@0: SwapChainD3D9::Init(HWND hWnd)
michael@0: {
michael@0:   RECT r;
michael@0:   ::GetClientRect(hWnd, &r);
michael@0: 
michael@0:   mWnd = hWnd;
michael@0: 
michael@0:   D3DPRESENT_PARAMETERS pp;
michael@0:   memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS));
michael@0: 
michael@0:   pp.BackBufferFormat = D3DFMT_A8R8G8B8;
michael@0:   pp.SwapEffect = D3DSWAPEFFECT_COPY;
michael@0:   pp.Windowed = TRUE;
michael@0:   pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
michael@0:   pp.hDeviceWindow = mWnd;
michael@0:   if (r.left == r.right || r.top == r.bottom) {
michael@0:     pp.BackBufferHeight = 1;
michael@0:     pp.BackBufferWidth = 1;
michael@0:   }
michael@0: 
michael@0:   HRESULT hr = mDeviceManager->device()->
michael@0:     CreateAdditionalSwapChain(&pp,
michael@0:                               getter_AddRefs(mSwapChain));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     NS_WARNING("Failed to create swap chain for window.");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: already_AddRefed<IDirect3DSurface9>
michael@0: SwapChainD3D9::GetBackBuffer()
michael@0: {
michael@0:   nsRefPtr<IDirect3DSurface9> backBuffer;
michael@0:     mSwapChain->GetBackBuffer(0,
michael@0:                               D3DBACKBUFFER_TYPE_MONO,
michael@0:                               getter_AddRefs(backBuffer));
michael@0:   return backBuffer.forget();
michael@0: }
michael@0: 
michael@0: DeviceManagerState
michael@0: SwapChainD3D9::PrepareForRendering()
michael@0: {
michael@0:   RECT r;
michael@0:   if (!::GetClientRect(mWnd, &r)) {
michael@0:     return DeviceFail;
michael@0:   }
michael@0: 
michael@0:   DeviceManagerState deviceState = mDeviceManager->VerifyReadyForRendering();
michael@0:   if (deviceState != DeviceOK) {
michael@0:     return deviceState;
michael@0:   }
michael@0: 
michael@0:   if (!mSwapChain) {
michael@0:     Init(mWnd);
michael@0:   }
michael@0: 
michael@0:   if (mSwapChain) {
michael@0:     nsRefPtr<IDirect3DSurface9> backBuffer = GetBackBuffer();
michael@0: 
michael@0:     D3DSURFACE_DESC desc;
michael@0:     backBuffer->GetDesc(&desc);
michael@0: 
michael@0:     if (desc.Width == r.right - r.left && desc.Height == r.bottom - r.top) {
michael@0:       mDeviceManager->device()->SetRenderTarget(0, backBuffer);
michael@0:       return DeviceOK;
michael@0:     }
michael@0: 
michael@0:     mSwapChain = nullptr;
michael@0:     
michael@0:     Init(mWnd);
michael@0:     
michael@0:     if (!mSwapChain) {
michael@0:       return DeviceFail;
michael@0:     }
michael@0:     
michael@0:     backBuffer = GetBackBuffer();
michael@0:     mDeviceManager->device()->SetRenderTarget(0, backBuffer);
michael@0:     
michael@0:     return DeviceOK;
michael@0:   }
michael@0: 
michael@0:   return DeviceFail;
michael@0: }
michael@0: 
michael@0: void
michael@0: SwapChainD3D9::Present(const nsIntRect &aRect)
michael@0: {
michael@0:   RECT r;
michael@0:   r.left = aRect.x;
michael@0:   r.top = aRect.y;
michael@0:   r.right = aRect.XMost();
michael@0:   r.bottom = aRect.YMost();
michael@0: 
michael@0:   mSwapChain->Present(&r, &r, 0, 0, 0);
michael@0: }
michael@0: 
michael@0: void
michael@0: SwapChainD3D9::Present()
michael@0: {
michael@0:   mSwapChain->Present(nullptr, nullptr, 0, 0, 0);
michael@0: }
michael@0: 
michael@0: void
michael@0: SwapChainD3D9::Reset()
michael@0: {
michael@0:   mSwapChain = nullptr;
michael@0: }
michael@0: 
michael@0: #define HAS_CAP(a, b) (((a) & (b)) == (b))
michael@0: #define LACKS_CAP(a, b) !(((a) & (b)) == (b))
michael@0: 
michael@0: uint32_t DeviceManagerD3D9::sMaskQuadRegister = 11;
michael@0: 
michael@0: DeviceManagerD3D9::DeviceManagerD3D9()
michael@0:   : mTextureHostList(nullptr)
michael@0:   , mDeviceResetCount(0)
michael@0:   , mMaxTextureSize(0)
michael@0:   , mTextureAddressingMode(D3DTADDRESS_CLAMP)
michael@0:   , mHasDynamicTextures(false)
michael@0:   , mDeviceWasRemoved(false)
michael@0: {
michael@0: }
michael@0: 
michael@0: DeviceManagerD3D9::~DeviceManagerD3D9()
michael@0: {
michael@0:   DestroyDevice();
michael@0: }
michael@0: 
michael@0: bool
michael@0: DeviceManagerD3D9::Init()
michael@0: {
michael@0:   WNDCLASSW wc;
michael@0:   HRESULT hr;
michael@0: 
michael@0:   if (!GetClassInfoW(GetModuleHandle(nullptr), kClassName, &wc)) {
michael@0:       ZeroMemory(&wc, sizeof(WNDCLASSW));
michael@0:       wc.hInstance = GetModuleHandle(nullptr);
michael@0:       wc.lpfnWndProc = ::DefWindowProc;
michael@0:       wc.lpszClassName = kClassName;
michael@0:       if (!RegisterClassW(&wc)) {
michael@0:           NS_WARNING("Failed to register window class for DeviceManager.");
michael@0:           return false;
michael@0:       }
michael@0:   }
michael@0: 
michael@0:   mFocusWnd = ::CreateWindowW(kClassName, L"D3D9Window", WS_OVERLAPPEDWINDOW,
michael@0:                               CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr,
michael@0:                               nullptr, GetModuleHandle(nullptr), nullptr);
michael@0: 
michael@0:   if (!mFocusWnd) {
michael@0:     NS_WARNING("Failed to create DeviceManagerD3D9 Window.");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   /* Create an Nv3DVUtils instance */ 
michael@0:   if (!mNv3DVUtils) { 
michael@0:     mNv3DVUtils = new Nv3DVUtils(); 
michael@0:     if (!mNv3DVUtils) { 
michael@0:       NS_WARNING("Could not create a new instance of Nv3DVUtils.\n"); 
michael@0:     } 
michael@0:   } 
michael@0: 
michael@0:   /* Initialize the Nv3DVUtils object */ 
michael@0:   if (mNv3DVUtils) { 
michael@0:     mNv3DVUtils->Initialize(); 
michael@0:   } 
michael@0: 
michael@0:   HMODULE d3d9 = LoadLibraryW(L"d3d9.dll");
michael@0:   decltype(Direct3DCreate9)* d3d9Create = (decltype(Direct3DCreate9)*)
michael@0:     GetProcAddress(d3d9, "Direct3DCreate9");
michael@0:   decltype(Direct3DCreate9Ex)* d3d9CreateEx = (decltype(Direct3DCreate9Ex)*)
michael@0:     GetProcAddress(d3d9, "Direct3DCreate9Ex");
michael@0: 
michael@0: #ifdef USE_D3D9EX
michael@0:   if (d3d9CreateEx) {
michael@0:     hr = d3d9CreateEx(D3D_SDK_VERSION, getter_AddRefs(mD3D9Ex));
michael@0:     if (SUCCEEDED(hr)) {
michael@0:       mD3D9 = mD3D9Ex;
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (!mD3D9) {
michael@0:     if (!d3d9Create) {
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     mD3D9 = dont_AddRef(d3d9Create(D3D_SDK_VERSION));
michael@0: 
michael@0:     if (!mD3D9) {
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   D3DADAPTER_IDENTIFIER9 ident;
michael@0:   hr = mD3D9->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &ident);
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   D3DPRESENT_PARAMETERS pp;
michael@0:   memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS));
michael@0: 
michael@0:   pp.BackBufferWidth = 1;
michael@0:   pp.BackBufferHeight = 1;
michael@0:   pp.BackBufferFormat = D3DFMT_A8R8G8B8;
michael@0:   pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
michael@0:   pp.Windowed = TRUE;
michael@0:   pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
michael@0:   pp.hDeviceWindow = mFocusWnd;
michael@0: 
michael@0:   if (mD3D9Ex) {
michael@0:     hr = mD3D9Ex->CreateDeviceEx(D3DADAPTER_DEFAULT,
michael@0:                                  D3DDEVTYPE_HAL,
michael@0:                                  mFocusWnd,
michael@0:                                  D3DCREATE_FPU_PRESERVE |
michael@0:                                  D3DCREATE_MULTITHREADED |
michael@0:                                  D3DCREATE_MIXED_VERTEXPROCESSING,
michael@0:                                  &pp,
michael@0:                                  nullptr,
michael@0:                                  getter_AddRefs(mDeviceEx));
michael@0:     if (SUCCEEDED(hr)) {
michael@0:       mDevice = mDeviceEx;
michael@0:     }
michael@0: 
michael@0:     D3DCAPS9 caps;
michael@0:     if (mDeviceEx && mDeviceEx->GetDeviceCaps(&caps)) {
michael@0:       if (LACKS_CAP(caps.Caps2, D3DCAPS2_DYNAMICTEXTURES)) {
michael@0:         // XXX - Should we actually hit this we'll need a CanvasLayer that
michael@0:         // supports static D3DPOOL_DEFAULT textures.
michael@0:         NS_WARNING("D3D9Ex device not used because of lack of support for \
michael@0:                    dynamic textures. This is unexpected.");
michael@0:         mDevice = nullptr;
michael@0:         mDeviceEx = nullptr;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (!mDevice) {
michael@0:     hr = mD3D9->CreateDevice(D3DADAPTER_DEFAULT,
michael@0:                              D3DDEVTYPE_HAL,
michael@0:                              mFocusWnd,
michael@0:                              D3DCREATE_FPU_PRESERVE |
michael@0:                              D3DCREATE_MULTITHREADED |
michael@0:                              D3DCREATE_MIXED_VERTEXPROCESSING,
michael@0:                              &pp,
michael@0:                              getter_AddRefs(mDevice));
michael@0: 
michael@0:     if (FAILED(hr)) {
michael@0:       NS_WARNING("Failed to create Device for DeviceManagerD3D9.");
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (!VerifyCaps()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   /* Grab the associated HMONITOR so that we can find out
michael@0:    * if it changed later */
michael@0:   D3DDEVICE_CREATION_PARAMETERS parameters;
michael@0:   if (FAILED(mDevice->GetCreationParameters(&parameters)))
michael@0:     return false;
michael@0:   mDeviceMonitor = mD3D9->GetAdapterMonitor(parameters.AdapterOrdinal);
michael@0: 
michael@0: 
michael@0:   /* 
michael@0:    * Do some post device creation setup 
michael@0:    */ 
michael@0:   if (mNv3DVUtils) { 
michael@0:     IUnknown* devUnknown = nullptr; 
michael@0:     if (mDevice) { 
michael@0:       mDevice->QueryInterface(IID_IUnknown, (void **)&devUnknown); 
michael@0:     } 
michael@0:     mNv3DVUtils->SetDeviceInfo(devUnknown); 
michael@0:   } 
michael@0: 
michael@0:   hr = mDevice->CreateVertexShader((DWORD*)LayerQuadVS,
michael@0:                                    getter_AddRefs(mLayerVS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)RGBShaderPS,
michael@0:                                   getter_AddRefs(mRGBPS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)RGBAShaderPS,
michael@0:                                   getter_AddRefs(mRGBAPS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)ComponentPass1ShaderPS,
michael@0:                                   getter_AddRefs(mComponentPass1PS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)ComponentPass2ShaderPS,
michael@0:                                   getter_AddRefs(mComponentPass2PS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)YCbCrShaderPS,
michael@0:                                   getter_AddRefs(mYCbCrPS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)SolidColorShaderPS,
michael@0:                                   getter_AddRefs(mSolidColorPS));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreateVertexShader((DWORD*)LayerQuadVSMask,
michael@0:                                    getter_AddRefs(mLayerVSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0:   hr = mDevice->CreateVertexShader((DWORD*)LayerQuadVSMask3D,
michael@0:                                    getter_AddRefs(mLayerVSMask3D));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)RGBShaderPSMask,
michael@0:                                   getter_AddRefs(mRGBPSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)RGBAShaderPSMask,
michael@0:                                   getter_AddRefs(mRGBAPSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)RGBAShaderPSMask3D,
michael@0:                                   getter_AddRefs(mRGBAPSMask3D));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)ComponentPass1ShaderPSMask,
michael@0:                                   getter_AddRefs(mComponentPass1PSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)ComponentPass2ShaderPSMask,
michael@0:                                   getter_AddRefs(mComponentPass2PSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)YCbCrShaderPSMask,
michael@0:                                   getter_AddRefs(mYCbCrPSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->CreatePixelShader((DWORD*)SolidColorShaderPSMask,
michael@0:                                   getter_AddRefs(mSolidColorPSMask));
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (!CreateVertexBuffer()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   hr = mDevice->SetStreamSource(0, mVB, 0, sizeof(vertex));
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   D3DVERTEXELEMENT9 elements[] = {
michael@0:     { 0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT,
michael@0:       D3DDECLUSAGE_POSITION, 0 },
michael@0:     D3DDECL_END()
michael@0:   };
michael@0: 
michael@0:   mDevice->CreateVertexDeclaration(elements, getter_AddRefs(mVD));
michael@0: 
michael@0:   nsCOMPtr<nsIConsoleService>
michael@0:     console(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
michael@0: 
michael@0:   D3DADAPTER_IDENTIFIER9 identifier;
michael@0:   mD3D9->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier);
michael@0: 
michael@0:   if (console) {
michael@0:     nsString msg;
michael@0:     msg +=
michael@0:       NS_LITERAL_STRING("Direct3D 9 DeviceManager Initialized Successfully.\nDriver: ");
michael@0:     msg += NS_ConvertUTF8toUTF16(
michael@0:       nsDependentCString((const char*)identifier.Driver));
michael@0:     msg += NS_LITERAL_STRING("\nDescription: ");
michael@0:     msg += NS_ConvertUTF8toUTF16(
michael@0:       nsDependentCString((const char*)identifier.Description));
michael@0:     msg += NS_LITERAL_STRING("\nVersion: ");
michael@0:     msg += NS_ConvertUTF8toUTF16(
michael@0:       nsPrintfCString("%d.%d.%d.%d",
michael@0:                       HIWORD(identifier.DriverVersion.HighPart),
michael@0:                       LOWORD(identifier.DriverVersion.HighPart),
michael@0:                       HIWORD(identifier.DriverVersion.LowPart),
michael@0:                       LOWORD(identifier.DriverVersion.LowPart)));
michael@0:     console->LogStringMessage(msg.get());
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: DeviceManagerD3D9::SetupRenderState()
michael@0: {
michael@0:   mDevice->SetStreamSource(0, mVB, 0, sizeof(vertex));
michael@0:   mDevice->SetVertexDeclaration(mVD);
michael@0:   mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
michael@0:   mDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
michael@0:   mDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
michael@0:   mDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
michael@0:   mDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
michael@0:   mDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
michael@0:   mDevice->SetRenderState(D3DRS_SRCBLENDALPHA, D3DBLEND_ONE);
michael@0:   mDevice->SetRenderState(D3DRS_DESTBLENDALPHA, D3DBLEND_INVSRCALPHA);
michael@0:   mDevice->SetRenderState(D3DRS_BLENDOPALPHA, D3DBLENDOP_ADD);
michael@0:   mDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
michael@0:   mDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
michael@0:   mDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
michael@0:   mDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
michael@0:   mDevice->SetSamplerState(2, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
michael@0:   mDevice->SetSamplerState(2, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
michael@0:   mDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, mTextureAddressingMode);
michael@0:   mDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, mTextureAddressingMode);
michael@0:   mDevice->SetSamplerState(1, D3DSAMP_ADDRESSU, mTextureAddressingMode);
michael@0:   mDevice->SetSamplerState(1, D3DSAMP_ADDRESSV, mTextureAddressingMode);
michael@0:   mDevice->SetSamplerState(2, D3DSAMP_ADDRESSU, mTextureAddressingMode);
michael@0:   mDevice->SetSamplerState(2, D3DSAMP_ADDRESSV, mTextureAddressingMode);
michael@0: }
michael@0: 
michael@0: already_AddRefed<SwapChainD3D9>
michael@0: DeviceManagerD3D9::CreateSwapChain(HWND hWnd)
michael@0: {
michael@0:   nsRefPtr<SwapChainD3D9> swapChain = new SwapChainD3D9(this);
michael@0:   
michael@0:   // See bug 604647. This line means that if we create a window while the
michael@0:   // device is lost LayerManager initialization will fail, this window
michael@0:   // will be permanently unaccelerated. This should be a rare situation
michael@0:   // though and the need for a low-risk fix for this bug outweighs the
michael@0:   // downside.
michael@0:   if (VerifyReadyForRendering() != DeviceOK) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (!swapChain->Init(hWnd)) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   return swapChain.forget();
michael@0: }
michael@0: 
michael@0: /*
michael@0:   * Finds a texture for the mask layer and sets it as an
michael@0:   * input to the shaders.
michael@0:   * Returns true if a texture is loaded, false if 
michael@0:   * a texture for the mask layer could not be loaded.
michael@0:   */
michael@0: bool
michael@0: LoadMaskTexture(Layer* aMask, IDirect3DDevice9* aDevice,
michael@0:                 uint32_t aMaskTexRegister)
michael@0: {
michael@0:   IntSize size;
michael@0:   nsRefPtr<IDirect3DTexture9> texture =
michael@0:     static_cast<LayerD3D9*>(aMask->ImplData())->GetAsTexture(&size);
michael@0: 
michael@0:   if (!texture) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   Matrix maskTransform;
michael@0:   Matrix4x4 effectiveTransform = aMask->GetEffectiveTransform();
michael@0:   bool maskIs2D = effectiveTransform.CanDraw2D(&maskTransform);
michael@0:   NS_ASSERTION(maskIs2D, "How did we end up with a 3D transform here?!");
michael@0:   Rect bounds = Rect(Point(), Size(size));
michael@0:   bounds = maskTransform.TransformBounds(bounds);
michael@0: 
michael@0:   aDevice->SetVertexShaderConstantF(DeviceManagerD3D9::sMaskQuadRegister,
michael@0:                                     ShaderConstantRect((float)bounds.x,
michael@0:                                                        (float)bounds.y,
michael@0:                                                        (float)bounds.width,
michael@0:                                                        (float)bounds.height),
michael@0:                                     1);
michael@0: 
michael@0:   aDevice->SetTexture(aMaskTexRegister, texture);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: DeviceManagerD3D9::SetShaderMode(ShaderMode aMode, MaskType aMaskType)
michael@0: {
michael@0:   if (aMaskType == MaskNone) {
michael@0:     switch (aMode) {
michael@0:       case RGBLAYER:
michael@0:         mDevice->SetVertexShader(mLayerVS);
michael@0:         mDevice->SetPixelShader(mRGBPS);
michael@0:         break;
michael@0:       case RGBALAYER:
michael@0:         mDevice->SetVertexShader(mLayerVS);
michael@0:         mDevice->SetPixelShader(mRGBAPS);
michael@0:         break;
michael@0:       case COMPONENTLAYERPASS1:
michael@0:         mDevice->SetVertexShader(mLayerVS);
michael@0:         mDevice->SetPixelShader(mComponentPass1PS);
michael@0:         break;
michael@0:       case COMPONENTLAYERPASS2:
michael@0:         mDevice->SetVertexShader(mLayerVS);
michael@0:         mDevice->SetPixelShader(mComponentPass2PS);
michael@0:         break;
michael@0:       case YCBCRLAYER:
michael@0:         mDevice->SetVertexShader(mLayerVS);
michael@0:         mDevice->SetPixelShader(mYCbCrPS);
michael@0:         break;
michael@0:       case SOLIDCOLORLAYER:
michael@0:         mDevice->SetVertexShader(mLayerVS);
michael@0:         mDevice->SetPixelShader(mSolidColorPS);
michael@0:         break;
michael@0:     }
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   uint32_t maskTexRegister;
michael@0:   switch (aMode) {
michael@0:     case RGBLAYER:
michael@0:       mDevice->SetVertexShader(mLayerVSMask);
michael@0:       mDevice->SetPixelShader(mRGBPSMask);
michael@0:       maskTexRegister = 1;
michael@0:       break;
michael@0:     case RGBALAYER:
michael@0:       if (aMaskType == Mask2d) {
michael@0:         mDevice->SetVertexShader(mLayerVSMask);
michael@0:         mDevice->SetPixelShader(mRGBAPSMask);
michael@0:       } else {
michael@0:         mDevice->SetVertexShader(mLayerVSMask3D);
michael@0:         mDevice->SetPixelShader(mRGBAPSMask3D);
michael@0:       }
michael@0:       maskTexRegister = 1;
michael@0:       break;
michael@0:     case COMPONENTLAYERPASS1:
michael@0:       mDevice->SetVertexShader(mLayerVSMask);
michael@0:       mDevice->SetPixelShader(mComponentPass1PSMask);
michael@0:       maskTexRegister = 2;
michael@0:       break;
michael@0:     case COMPONENTLAYERPASS2:
michael@0:       mDevice->SetVertexShader(mLayerVSMask);
michael@0:       mDevice->SetPixelShader(mComponentPass2PSMask);
michael@0:       maskTexRegister = 2;
michael@0:       break;
michael@0:     case YCBCRLAYER:
michael@0:       mDevice->SetVertexShader(mLayerVSMask);
michael@0:       mDevice->SetPixelShader(mYCbCrPSMask);
michael@0:       maskTexRegister = 3;
michael@0:       break;
michael@0:     case SOLIDCOLORLAYER:
michael@0:       mDevice->SetVertexShader(mLayerVSMask);
michael@0:       mDevice->SetPixelShader(mSolidColorPSMask);
michael@0:       maskTexRegister = 0;
michael@0:       break;
michael@0:   }
michael@0:   return maskTexRegister;
michael@0: }
michael@0: 
michael@0: void
michael@0: DeviceManagerD3D9::SetShaderMode(ShaderMode aMode, Layer* aMask, bool aIs2D)
michael@0: {
michael@0:   MaskType maskType = MaskNone;
michael@0:   if (aMask) {
michael@0:     maskType = aIs2D ? Mask2d : Mask3d;
michael@0:   }
michael@0:   uint32_t maskTexRegister = SetShaderMode(aMode, maskType);
michael@0:   if (aMask) {
michael@0:     // register allocations are taken from LayerManagerD3D9Shaders.h after
michael@0:     // the shaders are compiled (genshaders.sh)
michael@0:     if (!LoadMaskTexture(aMask, mDevice, maskTexRegister)) {
michael@0:       // if we can't load the mask, fall back to unmasked rendering
michael@0:       NS_WARNING("Could not load texture for mask layer.");
michael@0:       SetShaderMode(aMode, MaskNone);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: DeviceManagerD3D9::DestroyDevice()
michael@0: {
michael@0:   ++mDeviceResetCount;
michael@0:   mDeviceWasRemoved = true;
michael@0:   if (!IsD3D9Ex()) {
michael@0:     ReleaseTextureResources();
michael@0:   }
michael@0:   gfxWindowsPlatform::GetPlatform()->OnDeviceManagerDestroy(this);
michael@0: }
michael@0: 
michael@0: DeviceManagerState
michael@0: DeviceManagerD3D9::VerifyReadyForRendering()
michael@0: {
michael@0:   if (mDeviceWasRemoved) {
michael@0:     return DeviceMustRecreate;
michael@0:   }
michael@0: 
michael@0:   HRESULT hr = mDevice->TestCooperativeLevel();
michael@0: 
michael@0:   if (SUCCEEDED(hr)) {
michael@0:     if (IsD3D9Ex()) {
michael@0:       hr = mDeviceEx->CheckDeviceState(mFocusWnd);
michael@0: 
michael@0:       if (FAILED(hr)) {
michael@0:         DestroyDevice();
michael@0:         return DeviceMustRecreate;
michael@0:       }
michael@0:     }
michael@0:     return DeviceOK;
michael@0:   }
michael@0: 
michael@0:   // We need to release all texture resources and swap chains before resetting.
michael@0:   for (unsigned int i = 0; i < mLayersWithResources.Length(); i++) {
michael@0:     mLayersWithResources[i]->CleanResources();
michael@0:   }
michael@0:   ReleaseTextureResources();
michael@0:   for (unsigned int i = 0; i < mSwapChains.Length(); i++) {
michael@0:     mSwapChains[i]->Reset();
michael@0:   }
michael@0: 
michael@0:   mVB = nullptr;
michael@0: 
michael@0:   D3DPRESENT_PARAMETERS pp;
michael@0:   memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS));
michael@0: 
michael@0:   pp.BackBufferWidth = 1;
michael@0:   pp.BackBufferHeight = 1;
michael@0:   pp.BackBufferFormat = D3DFMT_A8R8G8B8;
michael@0:   pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
michael@0:   pp.Windowed = TRUE;
michael@0:   pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
michael@0:   pp.hDeviceWindow = mFocusWnd;
michael@0: 
michael@0:   // Whatever happens from now on, either we reset the device, or we should
michael@0:   // pretend we reset the device so that the layer manager or compositor
michael@0:   // doesn't ignore it.
michael@0:   ++mDeviceResetCount;
michael@0: 
michael@0:   // if we got this far, we know !SUCCEEDEED(hr), that means hr is one of
michael@0:   // D3DERR_DEVICELOST, D3DERR_DEVICENOTRESET, D3DERR_DRIVERINTERNALERROR.
michael@0:   // It is only worth resetting if we get D3DERR_DEVICENOTRESET. If we get
michael@0:   // D3DERR_DEVICELOST we can wait and see if we get D3DERR_DEVICENOTRESET
michael@0:   // later, then reset.
michael@0:   if (hr == D3DERR_DEVICELOST) {
michael@0:     HMONITOR hMonitorWindow;
michael@0:     hMonitorWindow = MonitorFromWindow(mFocusWnd, MONITOR_DEFAULTTOPRIMARY);
michael@0:     if (hMonitorWindow != mDeviceMonitor) {
michael@0:       /* jrmuizel: I'm not sure how to trigger this case. Usually, we get
michael@0:        * DEVICENOTRESET right away and Reset() succeeds without going through a
michael@0:        * set of DEVICELOSTs. This is presumeably because we don't call
michael@0:        * VerifyReadyForRendering when we don't have any reason to paint.
michael@0:        * Hopefully comparing HMONITORs is not overly aggressive.
michael@0:        * See bug 626678.
michael@0:        */
michael@0:       /* The monitor has changed. We have to assume that the
michael@0:        * DEVICENOTRESET will not be coming. */
michael@0:       DestroyDevice();
michael@0:       return DeviceMustRecreate;
michael@0:     }
michael@0:     return DeviceFail;
michael@0:   }
michael@0:   if (hr == D3DERR_DEVICENOTRESET) {
michael@0:     hr = mDevice->Reset(&pp);
michael@0:   }
michael@0: 
michael@0:   if (FAILED(hr) || !CreateVertexBuffer()) {
michael@0:     DestroyDevice();
michael@0:     return DeviceMustRecreate;
michael@0:   }
michael@0: 
michael@0:   return DeviceOK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: DeviceManagerD3D9::VerifyCaps()
michael@0: {
michael@0:   D3DCAPS9 caps;
michael@0:   HRESULT hr = mDevice->GetDeviceCaps(&caps);
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.DevCaps, D3DDEVCAPS_TEXTUREVIDEOMEMORY)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.PrimitiveMiscCaps, D3DPMISCCAPS_CULLNONE)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.SrcBlendCaps, D3DPBLENDCAPS_ONE) ||
michael@0:       LACKS_CAP(caps.SrcBlendCaps, D3DBLEND_SRCALPHA) ||
michael@0:       LACKS_CAP(caps.DestBlendCaps, D3DPBLENDCAPS_INVSRCALPHA)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.RasterCaps, D3DPRASTERCAPS_SCISSORTEST)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.TextureCaps, D3DPTEXTURECAPS_ALPHA) ||
michael@0:       HAS_CAP(caps.TextureCaps, D3DPTEXTURECAPS_SQUAREONLY) ||
michael@0:       (HAS_CAP(caps.TextureCaps, D3DPTEXTURECAPS_POW2) &&
michael@0:        LACKS_CAP(caps.TextureCaps, D3DPTEXTURECAPS_NONPOW2CONDITIONAL))) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.TextureFilterCaps, D3DPTFILTERCAPS_MAGFLINEAR) ||
michael@0:       LACKS_CAP(caps.TextureFilterCaps, D3DPTFILTERCAPS_MINFLINEAR)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (LACKS_CAP(caps.TextureAddressCaps, D3DPTADDRESSCAPS_CLAMP)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (caps.MaxTextureHeight < 4096 ||
michael@0:       caps.MaxTextureWidth < 4096) {
michael@0:     return false;
michael@0:   }
michael@0:   mMaxTextureSize = std::min(caps.MaxTextureHeight, caps.MaxTextureWidth);
michael@0: 
michael@0:   if ((caps.PixelShaderVersion & 0xffff) < 0x200 ||
michael@0:       (caps.VertexShaderVersion & 0xffff) < 0x200) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (HAS_CAP(caps.Caps2, D3DCAPS2_DYNAMICTEXTURES)) {
michael@0:     mHasDynamicTextures = true;
michael@0:   }
michael@0: 
michael@0:   if (HAS_CAP(caps.TextureAddressCaps, D3DPTADDRESSCAPS_WRAP) &&
michael@0:       LACKS_CAP(caps.TextureCaps, D3DPTEXTURECAPS_NONPOW2CONDITIONAL)) {
michael@0:     mTextureAddressingMode = D3DTADDRESS_WRAP;
michael@0:   } else {
michael@0:     gfxPlatform::DisableBufferRotation();
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: DeviceManagerD3D9::CreateVertexBuffer()
michael@0: {
michael@0:   HRESULT hr;
michael@0: 
michael@0:   hr = mDevice->CreateVertexBuffer(sizeof(vertex) * 4,
michael@0:                                    D3DUSAGE_WRITEONLY,
michael@0:                                    0,
michael@0:                                    D3DPOOL_DEFAULT,
michael@0:                                    getter_AddRefs(mVB),
michael@0:                                    nullptr);
michael@0: 
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   vertex *vertices;
michael@0:   hr = mVB->Lock(0, 0, (void**)&vertices, 0);
michael@0:   if (FAILED(hr)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   vertices[0].x = vertices[0].y = 0;
michael@0:   vertices[1].x = 1; vertices[1].y = 0;
michael@0:   vertices[2].x = 0; vertices[2].y = 1;
michael@0:   vertices[3].x = 1; vertices[3].y = 1;
michael@0: 
michael@0:   mVB->Unlock();
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: TemporaryRef<IDirect3DTexture9>
michael@0: DeviceManagerD3D9::CreateTexture(const IntSize &aSize,
michael@0:                                  _D3DFORMAT aFormat,
michael@0:                                  D3DPOOL aPool,
michael@0:                                  TextureSourceD3D9* aTextureHost)
michael@0: {
michael@0:   if (mDeviceWasRemoved) {
michael@0:     return nullptr;
michael@0:   }
michael@0:   RefPtr<IDirect3DTexture9> result;
michael@0:   if (FAILED(device()->CreateTexture(aSize.width, aSize.height,
michael@0:                                      1, 0, aFormat, aPool,
michael@0:                                      byRef(result), nullptr))) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(aPool != D3DPOOL_MANAGED,
michael@0:                "Should not be using MANAGED texture pool. We will get an error when we have to recreate the device");
michael@0:   if (aPool == D3DPOOL_DEFAULT) {
michael@0:     MOZ_ASSERT(aTextureHost, "We need a texture host to track so we can release the texture.");
michael@0:     RegisterTextureHost(aTextureHost);
michael@0:   }
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG
michael@0: bool
michael@0: DeviceManagerD3D9::IsInTextureHostList(TextureSourceD3D9* aFind)
michael@0: {
michael@0:   TextureSourceD3D9* cur = mTextureHostList;
michael@0:   while(cur) {
michael@0:     if (cur == aFind) {
michael@0:       return true;
michael@0:     }
michael@0:     cur = cur->mNextHost;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: void
michael@0: DeviceManagerD3D9::RegisterTextureHost(TextureSourceD3D9* aHost)
michael@0: {
michael@0:   if (!aHost) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Don't add aHost to the list twice.
michael@0:   if (aHost->mPreviousHost ||
michael@0:       mTextureHostList == aHost) {
michael@0:     MOZ_ASSERT(IsInTextureHostList(aHost));
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(!aHost->mNextHost);
michael@0:   MOZ_ASSERT(!IsInTextureHostList(aHost));
michael@0: 
michael@0:   if (mTextureHostList) {
michael@0:     MOZ_ASSERT(!mTextureHostList->mPreviousHost);
michael@0:     mTextureHostList->mPreviousHost = aHost;
michael@0:     aHost->mNextHost = mTextureHostList;
michael@0:   }
michael@0:   mTextureHostList = aHost;
michael@0:   MOZ_ASSERT(!aHost->mCreatingDeviceManager, "Already created texture?");
michael@0:   MOZ_ASSERT(IsInTextureHostList(aHost));
michael@0:   aHost->mCreatingDeviceManager = this;
michael@0: }
michael@0: 
michael@0: void
michael@0: DeviceManagerD3D9::ReleaseTextureResources()
michael@0: {
michael@0:   TextureSourceD3D9* host = mTextureHostList;
michael@0:   while (host) {
michael@0:     host->ReleaseTextureResources();
michael@0:     TextureSourceD3D9* oldHost = host;
michael@0:     host = oldHost->mNextHost;
michael@0:     oldHost->mPreviousHost = nullptr;
michael@0:     oldHost->mNextHost = nullptr;
michael@0:     oldHost->mCreatingDeviceManager = nullptr;
michael@0:   }
michael@0:   mTextureHostList = nullptr;
michael@0: }
michael@0: 
michael@0: void
michael@0: DeviceManagerD3D9::RemoveTextureListHead(TextureSourceD3D9* aHost)
michael@0: {
michael@0:   MOZ_ASSERT(!aHost->mCreatingDeviceManager || aHost->mCreatingDeviceManager == this,
michael@0:              "Wrong device manager");
michael@0:   MOZ_ASSERT(aHost && mTextureHostList == aHost,
michael@0:              "aHost is not the head of the texture host list");
michael@0:   mTextureHostList = aHost->mNextHost;
michael@0: }
michael@0: 
michael@0: } /* namespace layers */
michael@0: } /* namespace mozilla */