summaryrefslogtreecommitdiffstats
path: root/gfx/layers/d3d11
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--gfx/layers/d3d11/BlendShaderConstants.h18
-rw-r--r--gfx/layers/d3d11/CompositorD3D11.cpp1400
-rw-r--r--gfx/layers/d3d11/CompositorD3D11.h227
-rw-r--r--gfx/layers/d3d11/CompositorD3D11.hlsl186
-rw-r--r--gfx/layers/d3d11/DeviceAttachmentsD3D11.cpp249
-rw-r--r--gfx/layers/d3d11/DeviceAttachmentsD3D11.h96
-rw-r--r--gfx/layers/d3d11/HelpersD3D11.h67
-rw-r--r--gfx/layers/d3d11/ShaderDefinitionsD3D11.h40
-rw-r--r--gfx/layers/d3d11/TextureD3D11.cpp1962
-rw-r--r--gfx/layers/d3d11/TextureD3D11.h649
-rw-r--r--gfx/layers/d3d11/genshaders.py176
-rw-r--r--gfx/layers/d3d11/shaders.manifest13
12 files changed, 5083 insertions, 0 deletions
diff --git a/gfx/layers/d3d11/BlendShaderConstants.h b/gfx/layers/d3d11/BlendShaderConstants.h
new file mode 100644
index 0000000000..4c7493b6db
--- /dev/null
+++ b/gfx/layers/d3d11/BlendShaderConstants.h
@@ -0,0 +1,18 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_LAYERS_D3D11_BLENDSHADERCONSTANTS_H_
+#define MOZILLA_GFX_LAYERS_D3D11_BLENDSHADERCONSTANTS_H_
+
+// These constants are shared between CompositorD3D11 and the blend pixel
+// shader.
+#define PS_LAYER_RGB 0
+#define PS_LAYER_RGBA 1
+#define PS_LAYER_YCBCR 2
+#define PS_LAYER_COLOR 3
+#define PS_LAYER_NV12 4
+
+#endif // MOZILLA_GFX_LAYERS_D3D11_BLENDSHADERCONSTANTS_H_
diff --git a/gfx/layers/d3d11/CompositorD3D11.cpp b/gfx/layers/d3d11/CompositorD3D11.cpp
new file mode 100644
index 0000000000..662fc47132
--- /dev/null
+++ b/gfx/layers/d3d11/CompositorD3D11.cpp
@@ -0,0 +1,1400 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "CompositorD3D11.h"
+
+#include "TextureD3D11.h"
+
+#include "gfxWindowsPlatform.h"
+#include "nsIWidget.h"
+#include "mozilla/gfx/D3D11Checks.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/gfx/GPUParent.h"
+#include "mozilla/gfx/Swizzle.h"
+#include "mozilla/layers/Diagnostics.h"
+#include "mozilla/layers/Effects.h"
+#include "mozilla/layers/HelpersD3D11.h"
+#include "nsWindowsHelpers.h"
+#include "gfxConfig.h"
+#include "gfxCrashReporterUtils.h"
+#include "gfxUtils.h"
+#include "mozilla/gfx/StackArray.h"
+#include "mozilla/widget/WinCompositorWidget.h"
+
+#include "mozilla/EnumeratedArray.h"
+#include "mozilla/ProfilerState.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/StaticPrefs_layers.h"
+#include "mozilla/Telemetry.h"
+
+#include "D3D11ShareHandleImage.h"
+#include "DeviceAttachmentsD3D11.h"
+#include "BlendShaderConstants.h"
+
+#include <versionhelpers.h> // For IsWindows8OrGreater
+#include <winsdkver.h>
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace layers {
+
+bool CanUsePartialPresents(ID3D11Device* aDevice);
+
+const FLOAT sBlendFactor[] = {0, 0, 0, 0};
+
+class AsyncReadbackBufferD3D11 final : public AsyncReadbackBuffer {
+ public:
+ AsyncReadbackBufferD3D11(ID3D11DeviceContext* aContext,
+ ID3D11Texture2D* aTexture, const IntSize& aSize);
+
+ bool MapAndCopyInto(DataSourceSurface* aSurface,
+ const IntSize& aReadSize) const override;
+
+ ID3D11Texture2D* GetTexture() { return mTexture; }
+
+ private:
+ RefPtr<ID3D11DeviceContext> mContext;
+ RefPtr<ID3D11Texture2D> mTexture;
+};
+
+AsyncReadbackBufferD3D11::AsyncReadbackBufferD3D11(
+ ID3D11DeviceContext* aContext, ID3D11Texture2D* aTexture,
+ const IntSize& aSize)
+ : AsyncReadbackBuffer(aSize), mContext(aContext), mTexture(aTexture) {}
+
+bool AsyncReadbackBufferD3D11::MapAndCopyInto(DataSourceSurface* aSurface,
+ const IntSize& aReadSize) const {
+ D3D11_MAPPED_SUBRESOURCE map;
+ HRESULT hr = mContext->Map(mTexture, 0, D3D11_MAP_READ, 0, &map);
+
+ if (FAILED(hr)) {
+ return false;
+ }
+
+ RefPtr<DataSourceSurface> sourceSurface =
+ Factory::CreateWrappingDataSourceSurface(static_cast<uint8_t*>(map.pData),
+ map.RowPitch, mSize,
+ SurfaceFormat::B8G8R8A8);
+
+ bool result;
+ {
+ DataSourceSurface::ScopedMap sourceMap(sourceSurface,
+ DataSourceSurface::READ);
+ DataSourceSurface::ScopedMap destMap(aSurface, DataSourceSurface::WRITE);
+
+ result = SwizzleData(sourceMap.GetData(), sourceMap.GetStride(),
+ SurfaceFormat::B8G8R8A8, destMap.GetData(),
+ destMap.GetStride(), aSurface->GetFormat(), aReadSize);
+ }
+
+ mContext->Unmap(mTexture, 0);
+
+ return result;
+}
+
+CompositorD3D11::CompositorD3D11(widget::CompositorWidget* aWidget)
+ : Compositor(aWidget),
+ mWindowRTCopy(nullptr),
+ mAttachments(nullptr),
+ mHwnd(nullptr),
+ mDisableSequenceForNextFrame(false),
+ mAllowPartialPresents(false),
+ mIsDoubleBuffered(false),
+ mVerifyBuffersFailed(false),
+ mUseMutexOnPresent(false) {
+ mUseMutexOnPresent = StaticPrefs::gfx_use_mutex_on_present_AtStartup();
+}
+
+CompositorD3D11::~CompositorD3D11() {}
+
+template <typename VertexType>
+void CompositorD3D11::SetVertexBuffer(ID3D11Buffer* aBuffer) {
+ UINT size = sizeof(VertexType);
+ UINT offset = 0;
+ mContext->IASetVertexBuffers(0, 1, &aBuffer, &size, &offset);
+}
+
+bool CompositorD3D11::Initialize(nsCString* const out_failureReason) {
+ ScopedGfxFeatureReporter reporter("D3D11 Layers");
+
+ HRESULT hr;
+
+ DeviceManagerDx::Get()->GetCompositorDevices(&mDevice, &mAttachments);
+ if (!mDevice) {
+ gfxCriticalNote << "[D3D11] failed to get compositor device.";
+ *out_failureReason = "FEATURE_FAILURE_D3D11_NO_DEVICE";
+ return false;
+ }
+ if (!mAttachments || !mAttachments->IsValid()) {
+ gfxCriticalNote << "[D3D11] failed to get compositor device attachments";
+ *out_failureReason = mAttachments ? mAttachments->GetFailureId()
+ : "FEATURE_FAILURE_NO_ATTACHMENTS"_ns;
+ return false;
+ }
+
+ mDevice->GetImmediateContext(getter_AddRefs(mContext));
+ if (!mContext) {
+ gfxCriticalNote << "[D3D11] failed to get immediate context";
+ *out_failureReason = "FEATURE_FAILURE_D3D11_CONTEXT";
+ return false;
+ }
+
+ mFeatureLevel = mDevice->GetFeatureLevel();
+
+ mHwnd = mWidget->AsWindows()->GetHwnd();
+
+ memset(&mVSConstants, 0, sizeof(VertexShaderConstants));
+
+ RefPtr<IDXGIDevice> dxgiDevice;
+ RefPtr<IDXGIAdapter> dxgiAdapter;
+
+ mDevice->QueryInterface(dxgiDevice.StartAssignment());
+ dxgiDevice->GetAdapter(getter_AddRefs(dxgiAdapter));
+
+ {
+ RefPtr<IDXGIFactory> dxgiFactory;
+ dxgiAdapter->GetParent(IID_PPV_ARGS(dxgiFactory.StartAssignment()));
+
+ RefPtr<IDXGIFactory2> dxgiFactory2;
+ hr = dxgiFactory->QueryInterface(
+ (IDXGIFactory2**)getter_AddRefs(dxgiFactory2));
+
+#if (_WIN32_WINDOWS_MAXVER >= 0x0A00)
+ if (gfxVars::UseDoubleBufferingWithCompositor() && SUCCEEDED(hr) &&
+ dxgiFactory2) {
+ // DXGI_SCALING_NONE is not available on Windows 7 with Platform Update.
+ // This looks awful for things like the awesome bar and browser window
+ // resizing so we don't use a flip buffer chain here. When using
+ // EFFECT_SEQUENTIAL it looks like windows doesn't stretch the surface
+ // when resizing. We chose not to run this before Windows 10 because it
+ // appears sometimes this breaks our ability to test ASAP compositing.
+ RefPtr<IDXGISwapChain1> swapChain;
+
+ DXGI_SWAP_CHAIN_DESC1 swapDesc;
+ ::ZeroMemory(&swapDesc, sizeof(swapDesc));
+ swapDesc.Width = 0;
+ swapDesc.Height = 0;
+ swapDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+ swapDesc.SampleDesc.Count = 1;
+ swapDesc.SampleDesc.Quality = 0;
+ swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ swapDesc.BufferCount = 2;
+ swapDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
+ swapDesc.Scaling = DXGI_SCALING_NONE;
+ mIsDoubleBuffered = true;
+ swapDesc.Flags = 0;
+
+ /**
+ * Create a swap chain, this swap chain will contain the backbuffer for
+ * the window we draw to. The front buffer is the full screen front
+ * buffer.
+ */
+ hr = dxgiFactory2->CreateSwapChainForHwnd(mDevice, mHwnd, &swapDesc,
+ nullptr, nullptr,
+ getter_AddRefs(swapChain));
+ if (SUCCEEDED(hr)) {
+ DXGI_RGBA color = {1.0f, 1.0f, 1.0f, 1.0f};
+ swapChain->SetBackgroundColor(&color);
+
+ mSwapChain = swapChain;
+ } else if (mWidget->AsWindows()->GetCompositorHwnd()) {
+ // Destroy compositor window.
+ mWidget->AsWindows()->DestroyCompositorWindow();
+ mHwnd = mWidget->AsWindows()->GetHwnd();
+ }
+ }
+
+ // In some configurations double buffering may have failed with an
+ // ACCESS_DENIED error.
+ if (!mSwapChain)
+#endif
+ {
+ if (mWidget->AsWindows()->GetCompositorHwnd()) {
+ // Destroy compositor window.
+ mWidget->AsWindows()->DestroyCompositorWindow();
+ mHwnd = mWidget->AsWindows()->GetHwnd();
+ }
+
+ DXGI_SWAP_CHAIN_DESC swapDesc;
+ ::ZeroMemory(&swapDesc, sizeof(swapDesc));
+ swapDesc.BufferDesc.Width = 0;
+ swapDesc.BufferDesc.Height = 0;
+ swapDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+ swapDesc.BufferDesc.RefreshRate.Numerator = 60;
+ swapDesc.BufferDesc.RefreshRate.Denominator = 1;
+ swapDesc.SampleDesc.Count = 1;
+ swapDesc.SampleDesc.Quality = 0;
+ swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ swapDesc.BufferCount = 1;
+ swapDesc.OutputWindow = mHwnd;
+ swapDesc.Windowed = TRUE;
+ swapDesc.Flags = 0;
+ swapDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
+
+ /**
+ * Create a swap chain, this swap chain will contain the backbuffer for
+ * the window we draw to. The front buffer is the full screen front
+ * buffer.
+ */
+ hr = dxgiFactory->CreateSwapChain(dxgiDevice, &swapDesc,
+ getter_AddRefs(mSwapChain));
+ if (Failed(hr, "create swap chain")) {
+ *out_failureReason = "FEATURE_FAILURE_D3D11_SWAP_CHAIN";
+ return false;
+ }
+ }
+
+ // We need this because we don't want DXGI to respond to Alt+Enter.
+ dxgiFactory->MakeWindowAssociation(mHwnd, DXGI_MWA_NO_WINDOW_CHANGES);
+ }
+
+ if (!mWidget->InitCompositor(this)) {
+ *out_failureReason = "FEATURE_FAILURE_D3D11_INIT_COMPOSITOR";
+ return false;
+ }
+
+ mAllowPartialPresents = CanUsePartialPresents(mDevice);
+
+ reporter.SetSuccessful();
+ return true;
+}
+
+bool CanUsePartialPresents(ID3D11Device* aDevice) {
+ if (StaticPrefs::gfx_partialpresent_force() > 0) {
+ return true;
+ }
+ if (StaticPrefs::gfx_partialpresent_force() < 0) {
+ return false;
+ }
+ if (DeviceManagerDx::Get()->IsWARP()) {
+ return true;
+ }
+
+ DXGI_ADAPTER_DESC desc;
+ if (!D3D11Checks::GetDxgiDesc(aDevice, &desc)) {
+ return false;
+ }
+
+ // We have to disable partial presents on NVIDIA (bug 1189940).
+ if (desc.VendorId == 0x10de) {
+ return false;
+ }
+
+ return true;
+}
+
+already_AddRefed<DataTextureSource> CompositorD3D11::CreateDataTextureSource(
+ TextureFlags aFlags) {
+ RefPtr<DataTextureSource> result =
+ new DataTextureSourceD3D11(gfx::SurfaceFormat::UNKNOWN, this, aFlags);
+ return result.forget();
+}
+
+int32_t CompositorD3D11::GetMaxTextureSize() const {
+ return GetMaxTextureSizeForFeatureLevel(mFeatureLevel);
+}
+
+already_AddRefed<CompositingRenderTarget> CompositorD3D11::CreateRenderTarget(
+ const gfx::IntRect& aRect, SurfaceInitMode aInit) {
+ MOZ_ASSERT(!aRect.IsZeroArea());
+
+ if (aRect.IsZeroArea()) {
+ return nullptr;
+ }
+
+ CD3D11_TEXTURE2D_DESC desc(
+ DXGI_FORMAT_B8G8R8A8_UNORM, aRect.width, aRect.height, 1, 1,
+ D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET);
+
+ RefPtr<ID3D11Texture2D> texture;
+ HRESULT hr =
+ mDevice->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture));
+ if (FAILED(hr) || !texture) {
+ gfxCriticalNote << "Failed in CreateRenderTarget " << hexa(hr);
+ return nullptr;
+ }
+
+ RefPtr<CompositingRenderTargetD3D11> rt =
+ new CompositingRenderTargetD3D11(texture, aRect.TopLeft());
+ rt->SetSize(IntSize(aRect.Width(), aRect.Height()));
+
+ if (aInit == INIT_MODE_CLEAR) {
+ FLOAT clear[] = {0, 0, 0, 0};
+ mContext->ClearRenderTargetView(rt->mRTView, clear);
+ }
+
+ return rt.forget();
+}
+
+RefPtr<ID3D11Texture2D> CompositorD3D11::CreateTexture(
+ const gfx::IntRect& aRect, const CompositingRenderTarget* aSource,
+ const gfx::IntPoint& aSourcePoint) {
+ MOZ_ASSERT(!aRect.IsZeroArea());
+
+ if (aRect.IsZeroArea()) {
+ return nullptr;
+ }
+
+ CD3D11_TEXTURE2D_DESC desc(
+ DXGI_FORMAT_B8G8R8A8_UNORM, aRect.Width(), aRect.Height(), 1, 1,
+ D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET);
+
+ RefPtr<ID3D11Texture2D> texture;
+ HRESULT hr =
+ mDevice->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture));
+
+ if (FAILED(hr) || !texture) {
+ gfxCriticalNote << "Failed in CreateRenderTargetFromSource " << hexa(hr);
+ HandleError(hr);
+ return nullptr;
+ }
+
+ if (aSource) {
+ const CompositingRenderTargetD3D11* sourceD3D11 =
+ static_cast<const CompositingRenderTargetD3D11*>(aSource);
+
+ const IntSize& srcSize = sourceD3D11->GetSize();
+ MOZ_ASSERT(srcSize.width >= 0 && srcSize.height >= 0,
+ "render targets should have nonnegative sizes");
+
+ IntRect srcRect(IntPoint(), srcSize);
+ IntRect copyRect(aSourcePoint, aRect.Size());
+ if (!srcRect.Contains(copyRect)) {
+ NS_WARNING("Could not copy the whole copy rect from the render target");
+ }
+
+ copyRect = copyRect.Intersect(srcRect);
+
+ if (!copyRect.IsEmpty()) {
+ D3D11_BOX copyBox;
+ copyBox.front = 0;
+ copyBox.back = 1;
+ copyBox.left = copyRect.X();
+ copyBox.top = copyRect.Y();
+ copyBox.right = copyRect.XMost();
+ copyBox.bottom = copyRect.YMost();
+
+ mContext->CopySubresourceRegion(
+ texture, 0, 0, 0, 0, sourceD3D11->GetD3D11Texture(), 0, &copyBox);
+ }
+ }
+
+ return texture;
+}
+
+bool CompositorD3D11::ShouldAllowFrameRecording() const {
+ return mAllowFrameRecording ||
+ profiler_feature_active(ProfilerFeature::Screenshots);
+}
+
+already_AddRefed<CompositingRenderTarget>
+CompositorD3D11::GetWindowRenderTarget() const {
+ if (!ShouldAllowFrameRecording()) {
+ return nullptr;
+ }
+
+ if (!mDefaultRT) {
+ return nullptr;
+ }
+
+ const IntSize size = mDefaultRT->GetSize();
+
+ RefPtr<ID3D11Texture2D> rtTexture;
+
+ if (!mWindowRTCopy || mWindowRTCopy->GetSize() != size) {
+ /*
+ * The compositor screenshots infrastructure is going to scale down the
+ * render target returned by this method. However, mDefaultRT does not
+ * contain a texture created wth the D3D11_BIND_SHADER_RESOURCE flag, so if
+ * we were to simply return mDefaultRT then scaling would fail.
+ */
+ CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, size.width,
+ size.height, 1, 1, D3D11_BIND_SHADER_RESOURCE);
+
+ HRESULT hr =
+ mDevice->CreateTexture2D(&desc, nullptr, getter_AddRefs(rtTexture));
+ if (FAILED(hr)) {
+ return nullptr;
+ }
+
+ mWindowRTCopy = MakeRefPtr<CompositingRenderTargetD3D11>(
+ rtTexture, IntPoint(0, 0), DXGI_FORMAT_B8G8R8A8_UNORM);
+ mWindowRTCopy->SetSize(size);
+ } else {
+ rtTexture = mWindowRTCopy->GetD3D11Texture();
+ }
+
+ const RefPtr<ID3D11Texture2D> sourceTexture = mDefaultRT->GetD3D11Texture();
+ mContext->CopyResource(rtTexture, sourceTexture);
+
+ return RefPtr<CompositingRenderTarget>(
+ static_cast<CompositingRenderTarget*>(mWindowRTCopy))
+ .forget();
+}
+
+bool CompositorD3D11::ReadbackRenderTarget(CompositingRenderTarget* aSource,
+ AsyncReadbackBuffer* aDest) {
+ RefPtr<CompositingRenderTargetD3D11> srcTexture =
+ static_cast<CompositingRenderTargetD3D11*>(aSource);
+ RefPtr<AsyncReadbackBufferD3D11> destBuffer =
+ static_cast<AsyncReadbackBufferD3D11*>(aDest);
+
+ mContext->CopyResource(destBuffer->GetTexture(),
+ srcTexture->GetD3D11Texture());
+
+ return true;
+}
+
+already_AddRefed<AsyncReadbackBuffer>
+CompositorD3D11::CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) {
+ RefPtr<ID3D11Texture2D> texture;
+
+ CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, aSize.width,
+ aSize.height, 1, 1, 0, D3D11_USAGE_STAGING,
+ D3D11_CPU_ACCESS_READ);
+
+ HRESULT hr =
+ mDevice->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture));
+
+ if (FAILED(hr)) {
+ HandleError(hr);
+ return nullptr;
+ }
+
+ return MakeAndAddRef<AsyncReadbackBufferD3D11>(mContext, texture, aSize);
+}
+
+bool CompositorD3D11::BlitRenderTarget(CompositingRenderTarget* aSource,
+ const gfx::IntSize& aSourceSize,
+ const gfx::IntSize& aDestSize) {
+ RefPtr<CompositingRenderTargetD3D11> source =
+ static_cast<CompositingRenderTargetD3D11*>(aSource);
+
+ RefPtr<TexturedEffect> texturedEffect = CreateTexturedEffect(
+ SurfaceFormat::B8G8R8A8, source, SamplingFilter::LINEAR, true);
+ texturedEffect->mTextureCoords =
+ Rect(0, 0, Float(aSourceSize.width) / Float(source->GetSize().width),
+ Float(aSourceSize.height) / Float(source->GetSize().height));
+
+ EffectChain effect;
+ effect.mPrimaryEffect = texturedEffect;
+
+ const Float scaleX = Float(aDestSize.width) / Float(aSourceSize.width);
+ const Float scaleY = Float(aDestSize.height) / (aSourceSize.height);
+ const Matrix4x4 transform = Matrix4x4::Scaling(scaleX, scaleY, 1.0f);
+
+ const Rect sourceRect(0, 0, aSourceSize.width, aSourceSize.height);
+
+ DrawQuad(sourceRect, IntRect(0, 0, aDestSize.width, aDestSize.height), effect,
+ 1.0f, transform, sourceRect);
+
+ return true;
+}
+
+void CompositorD3D11::SetRenderTarget(CompositingRenderTarget* aRenderTarget) {
+ MOZ_ASSERT(aRenderTarget);
+ CompositingRenderTargetD3D11* newRT =
+ static_cast<CompositingRenderTargetD3D11*>(aRenderTarget);
+ if (mCurrentRT != newRT) {
+ mCurrentRT = newRT;
+ mCurrentRT->BindRenderTarget(mContext);
+ }
+
+ if (newRT->HasComplexProjection()) {
+ gfx::Matrix4x4 projection;
+ bool depthEnable;
+ float zNear, zFar;
+ newRT->GetProjection(projection, depthEnable, zNear, zFar);
+ PrepareViewport(newRT->GetSize(), projection, zNear, zFar);
+ } else {
+ PrepareViewport(newRT->GetSize());
+ }
+}
+
+ID3D11PixelShader* CompositorD3D11::GetPSForEffect(Effect* aEffect) {
+ switch (aEffect->mType) {
+ case EffectTypes::RGB: {
+ SurfaceFormat format =
+ static_cast<TexturedEffect*>(aEffect)->mTexture->GetFormat();
+ return (format == SurfaceFormat::B8G8R8A8 ||
+ format == SurfaceFormat::R8G8B8A8)
+ ? mAttachments->mRGBAShader
+ : mAttachments->mRGBShader;
+ }
+ case EffectTypes::NV12:
+ return mAttachments->mNV12Shader;
+ case EffectTypes::YCBCR:
+ return mAttachments->mYCbCrShader;
+ default:
+ NS_WARNING("No shader to load");
+ return nullptr;
+ }
+}
+
+void CompositorD3D11::ClearRect(const gfx::Rect& aRect) {
+ if (aRect.IsEmpty()) {
+ return;
+ }
+
+ mContext->OMSetBlendState(mAttachments->mDisabledBlendState, sBlendFactor,
+ 0xFFFFFFFF);
+
+ Matrix4x4 identity;
+ memcpy(&mVSConstants.layerTransform, &identity._11, 64);
+
+ mVSConstants.layerQuad = aRect;
+ mVSConstants.renderTargetOffset[0] = 0;
+ mVSConstants.renderTargetOffset[1] = 0;
+ mPSConstants.layerOpacity[0] = 1.0f;
+
+ D3D11_RECT scissor;
+ scissor.left = aRect.X();
+ scissor.right = aRect.XMost();
+ scissor.top = aRect.Y();
+ scissor.bottom = aRect.YMost();
+ mContext->RSSetScissorRects(1, &scissor);
+ mContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+ mContext->VSSetShader(mAttachments->mVSQuadShader, nullptr, 0);
+
+ mContext->PSSetShader(mAttachments->mSolidColorShader, nullptr, 0);
+ mPSConstants.layerColor[0] = 0;
+ mPSConstants.layerColor[1] = 0;
+ mPSConstants.layerColor[2] = 0;
+ mPSConstants.layerColor[3] = 0;
+
+ if (!UpdateConstantBuffers()) {
+ NS_WARNING("Failed to update shader constant buffers");
+ return;
+ }
+
+ mContext->Draw(4, 0);
+
+ // Restore the default blend state.
+ mContext->OMSetBlendState(mAttachments->mPremulBlendState, sBlendFactor,
+ 0xFFFFFFFF);
+}
+
+void CompositorD3D11::PrepareStaticVertexBuffer() {
+ mContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+ mContext->IASetInputLayout(mAttachments->mInputLayout);
+ SetVertexBuffer<Vertex>(mAttachments->mVertexBuffer);
+}
+
+void CompositorD3D11::Draw(const gfx::Rect& aRect,
+ const gfx::Rect* aTexCoords) {
+ Rect layerRects[4] = {aRect};
+ Rect textureRects[4] = {};
+ size_t rects = 1;
+
+ if (aTexCoords) {
+ rects = DecomposeIntoNoRepeatRects(aRect, *aTexCoords, &layerRects,
+ &textureRects);
+ }
+
+ for (size_t i = 0; i < rects; i++) {
+ mVSConstants.layerQuad = layerRects[i];
+ mVSConstants.textureCoords = textureRects[i];
+
+ if (!UpdateConstantBuffers()) {
+ NS_WARNING("Failed to update shader constant buffers");
+ break;
+ }
+
+ mContext->Draw(4, 0);
+ }
+}
+
+void CompositorD3D11::DrawQuad(const gfx::Rect& aRect,
+ const gfx::IntRect& aClipRect,
+ const EffectChain& aEffectChain,
+ gfx::Float aOpacity,
+ const gfx::Matrix4x4& aTransform,
+ const gfx::Rect& aVisibleRect) {
+ if (mCurrentClip.IsEmpty()) {
+ return;
+ }
+
+ MOZ_ASSERT(mCurrentRT, "No render target");
+
+ memcpy(&mVSConstants.layerTransform, &aTransform._11, 64);
+ IntPoint origin = mCurrentRT->GetOrigin();
+ mVSConstants.renderTargetOffset[0] = origin.x;
+ mVSConstants.renderTargetOffset[1] = origin.y;
+
+ mPSConstants.layerOpacity[0] = aOpacity;
+
+ D3D11_RECT scissor;
+
+ IntRect clipRect(aClipRect.X(), aClipRect.Y(), aClipRect.Width(),
+ aClipRect.Height());
+ if (mCurrentRT == mDefaultRT) {
+ clipRect = clipRect.Intersect(mCurrentClip);
+ }
+
+ if (clipRect.IsEmpty()) {
+ return;
+ }
+
+ scissor.left = clipRect.X();
+ scissor.right = clipRect.XMost();
+ scissor.top = clipRect.Y();
+ scissor.bottom = clipRect.YMost();
+
+ bool restoreBlendMode = false;
+
+ mContext->RSSetScissorRects(1, &scissor);
+
+ RefPtr<ID3D11VertexShader> vertexShader = mAttachments->mVSQuadShader;
+
+ RefPtr<ID3D11PixelShader> pixelShader =
+ GetPSForEffect(aEffectChain.mPrimaryEffect);
+
+ mContext->VSSetShader(vertexShader, nullptr, 0);
+ mContext->PSSetShader(pixelShader, nullptr, 0);
+
+ const Rect* pTexCoordRect = nullptr;
+
+ switch (aEffectChain.mPrimaryEffect->mType) {
+ case EffectTypes::RGB: {
+ TexturedEffect* texturedEffect =
+ static_cast<TexturedEffect*>(aEffectChain.mPrimaryEffect.get());
+
+ pTexCoordRect = &texturedEffect->mTextureCoords;
+
+ TextureSourceD3D11* source = texturedEffect->mTexture->AsSourceD3D11();
+
+ if (!source) {
+ NS_WARNING("Missing texture source!");
+ return;
+ }
+
+ ID3D11ShaderResourceView* srView = source->GetShaderResourceView();
+ mContext->PSSetShaderResources(TexSlot::RGB, 1, &srView);
+
+ if (texturedEffect->mPremultipliedCopy) {
+ MOZ_RELEASE_ASSERT(texturedEffect->mPremultiplied);
+ mContext->OMSetBlendState(mAttachments->mPremulCopyState, sBlendFactor,
+ 0xFFFFFFFF);
+ restoreBlendMode = true;
+ } else if (!texturedEffect->mPremultiplied) {
+ mContext->OMSetBlendState(mAttachments->mNonPremulBlendState,
+ sBlendFactor, 0xFFFFFFFF);
+ restoreBlendMode = true;
+ }
+
+ SetSamplerForSamplingFilter(texturedEffect->mSamplingFilter);
+ } break;
+ case EffectTypes::NV12: {
+ EffectNV12* effectNV12 =
+ static_cast<EffectNV12*>(aEffectChain.mPrimaryEffect.get());
+
+ pTexCoordRect = &effectNV12->mTextureCoords;
+
+ TextureSourceD3D11* source = effectNV12->mTexture->AsSourceD3D11();
+ if (!source) {
+ NS_WARNING("Missing texture source!");
+ return;
+ }
+
+ RefPtr<ID3D11Texture2D> texture = source->GetD3D11Texture();
+ if (!texture) {
+ NS_WARNING("No texture found in texture source!");
+ }
+
+ D3D11_TEXTURE2D_DESC sourceDesc;
+ texture->GetDesc(&sourceDesc);
+ MOZ_DIAGNOSTIC_ASSERT(sourceDesc.Format == DXGI_FORMAT_NV12 ||
+ sourceDesc.Format == DXGI_FORMAT_P010 ||
+ sourceDesc.Format == DXGI_FORMAT_P016);
+
+ // Might want to cache these for efficiency.
+ RefPtr<ID3D11ShaderResourceView> srViewY;
+ RefPtr<ID3D11ShaderResourceView> srViewCbCr;
+ D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc =
+ CD3D11_SHADER_RESOURCE_VIEW_DESC(D3D11_SRV_DIMENSION_TEXTURE2D,
+ sourceDesc.Format == DXGI_FORMAT_NV12
+ ? DXGI_FORMAT_R8_UNORM
+ : DXGI_FORMAT_R16_UNORM);
+ mDevice->CreateShaderResourceView(texture, &srvDesc,
+ getter_AddRefs(srViewY));
+ srvDesc.Format = sourceDesc.Format == DXGI_FORMAT_NV12
+ ? DXGI_FORMAT_R8G8_UNORM
+ : DXGI_FORMAT_R16G16_UNORM;
+ mDevice->CreateShaderResourceView(texture, &srvDesc,
+ getter_AddRefs(srViewCbCr));
+
+ ID3D11ShaderResourceView* views[] = {srViewY, srViewCbCr};
+ mContext->PSSetShaderResources(TexSlot::Y, 2, views);
+
+ const float* yuvToRgb =
+ gfxUtils::YuvToRgbMatrix4x3RowMajor(effectNV12->mYUVColorSpace);
+ memcpy(&mPSConstants.yuvColorMatrix, yuvToRgb,
+ sizeof(mPSConstants.yuvColorMatrix));
+ mPSConstants.vCoefficient[0] =
+ RescalingFactorForColorDepth(effectNV12->mColorDepth);
+
+ SetSamplerForSamplingFilter(effectNV12->mSamplingFilter);
+ } break;
+ case EffectTypes::YCBCR: {
+ EffectYCbCr* ycbcrEffect =
+ static_cast<EffectYCbCr*>(aEffectChain.mPrimaryEffect.get());
+
+ SetSamplerForSamplingFilter(SamplingFilter::LINEAR);
+
+ pTexCoordRect = &ycbcrEffect->mTextureCoords;
+
+ const int Y = 0, Cb = 1, Cr = 2;
+ TextureSource* source = ycbcrEffect->mTexture;
+
+ if (!source) {
+ NS_WARNING("No texture to composite");
+ return;
+ }
+
+ if (!source->GetSubSource(Y) || !source->GetSubSource(Cb) ||
+ !source->GetSubSource(Cr)) {
+ // This can happen if we failed to upload the textures, most likely
+ // because of unsupported dimensions (we don't tile YCbCr textures).
+ return;
+ }
+
+ const float* yuvToRgb =
+ gfxUtils::YuvToRgbMatrix4x3RowMajor(ycbcrEffect->mYUVColorSpace);
+ memcpy(&mPSConstants.yuvColorMatrix, yuvToRgb,
+ sizeof(mPSConstants.yuvColorMatrix));
+
+ // Adjust range according to the bit depth.
+ mPSConstants.vCoefficient[0] =
+ RescalingFactorForColorDepth(ycbcrEffect->mColorDepth);
+
+ TextureSourceD3D11* sourceY = source->GetSubSource(Y)->AsSourceD3D11();
+ TextureSourceD3D11* sourceCb = source->GetSubSource(Cb)->AsSourceD3D11();
+ TextureSourceD3D11* sourceCr = source->GetSubSource(Cr)->AsSourceD3D11();
+
+ ID3D11ShaderResourceView* srViews[3] = {
+ sourceY->GetShaderResourceView(), sourceCb->GetShaderResourceView(),
+ sourceCr->GetShaderResourceView()};
+ mContext->PSSetShaderResources(TexSlot::Y, 3, srViews);
+ } break;
+ default:
+ NS_WARNING("Unknown shader type");
+ return;
+ }
+
+ Draw(aRect, pTexCoordRect);
+
+ if (restoreBlendMode) {
+ mContext->OMSetBlendState(mAttachments->mPremulBlendState, sBlendFactor,
+ 0xFFFFFFFF);
+ }
+}
+
+Maybe<IntRect> CompositorD3D11::BeginFrameForWindow(
+ const nsIntRegion& aInvalidRegion, const Maybe<IntRect>& aClipRect,
+ const IntRect& aRenderBounds, const nsIntRegion& aOpaqueRegion) {
+ MOZ_RELEASE_ASSERT(!mTarget, "mTarget not cleared properly");
+ return BeginFrame(aInvalidRegion, aClipRect, aRenderBounds, aOpaqueRegion);
+}
+
+Maybe<IntRect> CompositorD3D11::BeginFrame(const nsIntRegion& aInvalidRegion,
+ const Maybe<IntRect>& aClipRect,
+ const IntRect& aRenderBounds,
+ const nsIntRegion& aOpaqueRegion) {
+ // Don't composite if we are minimised. Other than for the sake of efficency,
+ // this is important because resizing our buffers when mimised will fail and
+ // cause a crash when we're restored.
+ NS_ASSERTION(mHwnd, "Couldn't find an HWND when initialising?");
+ if (mWidget->IsHidden()) {
+ // We are not going to render, and not going to call EndFrame so we have to
+ // read-unlock our textures to prevent them from accumulating.
+ return Nothing();
+ }
+
+ if (mDevice->GetDeviceRemovedReason() != S_OK) {
+ if (!mAttachments->IsDeviceReset()) {
+ gfxCriticalNote << "GFX: D3D11 skip BeginFrame with device-removed.";
+ mAttachments->SetDeviceReset();
+ }
+ return Nothing();
+ }
+
+ LayoutDeviceIntSize oldSize = mSize;
+
+ EnsureSize();
+
+ IntRect rect = IntRect(IntPoint(0, 0), mSize.ToUnknownSize());
+ // Sometimes the invalid region is larger than we want to draw.
+ nsIntRegion invalidRegionSafe;
+
+ if (mSize != oldSize) {
+ invalidRegionSafe = rect;
+ } else {
+ invalidRegionSafe.And(aInvalidRegion, rect);
+ }
+
+ IntRect invalidRect = invalidRegionSafe.GetBounds();
+
+ IntRect clipRect = invalidRect;
+ if (aClipRect) {
+ clipRect.IntersectRect(clipRect, *aClipRect);
+ }
+
+ if (clipRect.IsEmpty()) {
+ CancelFrame();
+ return Nothing();
+ }
+
+ PrepareStaticVertexBuffer();
+
+ mBackBufferInvalid.Or(mBackBufferInvalid, invalidRegionSafe);
+ if (mIsDoubleBuffered) {
+ mFrontBufferInvalid.Or(mFrontBufferInvalid, invalidRegionSafe);
+ }
+
+ // We have to call UpdateRenderTarget after we've determined the invalid regi
+ // Failed to create a render target or the view.
+ if (!UpdateRenderTarget() || !mDefaultRT || !mDefaultRT->mRTView ||
+ mSize.width <= 0 || mSize.height <= 0) {
+ return Nothing();
+ }
+
+ mCurrentClip = mBackBufferInvalid.GetBounds();
+
+ mContext->RSSetState(mAttachments->mRasterizerState);
+
+ SetRenderTarget(mDefaultRT);
+
+ IntRegion regionToClear(mCurrentClip);
+ regionToClear.Sub(regionToClear, aOpaqueRegion);
+
+ ClearRect(Rect(regionToClear.GetBounds()));
+
+ mContext->OMSetBlendState(mAttachments->mPremulBlendState, sBlendFactor,
+ 0xFFFFFFFF);
+
+ if (mAttachments->mSyncObject) {
+ if (!mAttachments->mSyncObject->Synchronize()) {
+ // It's timeout here. Since the timeout is related to the driver-removed,
+ // skip this frame.
+ return Nothing();
+ }
+ }
+
+ return Some(rect);
+}
+
+void CompositorD3D11::EndFrame() {
+ if (!profiler_feature_active(ProfilerFeature::Screenshots) && mWindowRTCopy) {
+ mWindowRTCopy = nullptr;
+ }
+
+ if (!mDefaultRT) {
+ Compositor::EndFrame();
+ mTarget = nullptr;
+ return;
+ }
+
+ if (XRE_IsParentProcess() && mDevice->GetDeviceRemovedReason() != S_OK) {
+ gfxCriticalNote << "GFX: D3D11 skip EndFrame with device-removed.";
+ Compositor::EndFrame();
+ mTarget = nullptr;
+ mCurrentRT = nullptr;
+ return;
+ }
+
+ LayoutDeviceIntSize oldSize = mSize;
+ EnsureSize();
+ if (mSize.width <= 0 || mSize.height <= 0) {
+ Compositor::EndFrame();
+ mTarget = nullptr;
+ return;
+ }
+
+ RefPtr<ID3D11Query> query;
+ if (mRecycledQuery) {
+ query = mRecycledQuery.forget();
+ } else {
+ CD3D11_QUERY_DESC desc(D3D11_QUERY_EVENT);
+ mDevice->CreateQuery(&desc, getter_AddRefs(query));
+ }
+ if (query) {
+ mContext->End(query);
+ }
+
+ if (oldSize == mSize) {
+ Present();
+ if (StaticPrefs::gfx_compositor_clearstate()) {
+ mContext->ClearState();
+ }
+ }
+
+ // Block until the previous frame's work has been completed.
+ if (mQuery) {
+ BOOL result;
+ WaitForFrameGPUQuery(mDevice, mContext, mQuery, &result);
+ // Store the query for recycling
+ mRecycledQuery = mQuery;
+ }
+ // Store the query for this frame so we can flush it next time.
+ mQuery = query;
+
+ Compositor::EndFrame();
+ mTarget = nullptr;
+ mCurrentRT = nullptr;
+}
+
+void CompositorD3D11::Present() {
+ UINT presentInterval = 0;
+
+ bool isWARP = DeviceManagerDx::Get()->IsWARP();
+ if (isWARP) {
+ // When we're using WARP we cannot present immediately as it causes us
+ // to tear when rendering. When not using WARP it appears the DWM takes
+ // care of tearing for us.
+ presentInterval = 1;
+ }
+
+ // This must be called before present so our back buffer has the validated
+ // window content.
+ if (mTarget) {
+ PaintToTarget();
+ }
+
+ RefPtr<IDXGISwapChain1> chain;
+ HRESULT hr =
+ mSwapChain->QueryInterface((IDXGISwapChain1**)getter_AddRefs(chain));
+
+ RefPtr<IDXGIKeyedMutex> mutex;
+ if (mUseMutexOnPresent && mAttachments->mSyncObject) {
+ SyncObjectD3D11Host* d3dSyncObj =
+ (SyncObjectD3D11Host*)mAttachments->mSyncObject.get();
+ mutex = d3dSyncObj->GetKeyedMutex();
+ MOZ_ASSERT(mutex);
+ }
+
+ if (SUCCEEDED(hr) && mAllowPartialPresents) {
+ DXGI_PRESENT_PARAMETERS params;
+ PodZero(&params);
+ params.DirtyRectsCount = mBackBufferInvalid.GetNumRects();
+ StackArray<RECT, 4> rects(params.DirtyRectsCount);
+
+ uint32_t i = 0;
+ for (auto iter = mBackBufferInvalid.RectIter(); !iter.Done(); iter.Next()) {
+ const IntRect& r = iter.Get();
+ rects[i].left = r.X();
+ rects[i].top = r.Y();
+ rects[i].bottom = r.YMost();
+ rects[i].right = r.XMost();
+ i++;
+ }
+
+ params.pDirtyRects = params.DirtyRectsCount ? rects.data() : nullptr;
+
+ if (mutex) {
+ hr = mutex->AcquireSync(0, 2000);
+ NS_ENSURE_TRUE_VOID(SUCCEEDED(hr));
+ }
+
+ chain->Present1(
+ presentInterval,
+ mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0,
+ &params);
+
+ if (mutex) {
+ mutex->ReleaseSync(0);
+ }
+ } else {
+ if (mutex) {
+ hr = mutex->AcquireSync(0, 2000);
+ NS_ENSURE_TRUE_VOID(SUCCEEDED(hr));
+ }
+
+ hr = mSwapChain->Present(
+ 0, mDisableSequenceForNextFrame ? DXGI_PRESENT_DO_NOT_SEQUENCE : 0);
+
+ if (mutex) {
+ mutex->ReleaseSync(0);
+ }
+
+ if (FAILED(hr)) {
+ gfxCriticalNote << "D3D11 swap chain preset failed " << hexa(hr);
+ HandleError(hr);
+ }
+ }
+
+ if (mIsDoubleBuffered) {
+ mBackBufferInvalid = mFrontBufferInvalid;
+ mFrontBufferInvalid.SetEmpty();
+ } else {
+ mBackBufferInvalid.SetEmpty();
+ }
+
+ mDisableSequenceForNextFrame = false;
+}
+
+void CompositorD3D11::CancelFrame(bool aNeedFlush) {
+ // Flush the context, otherwise the driver might hold some resources alive
+ // until the next flush or present.
+ if (aNeedFlush) {
+ mContext->Flush();
+ }
+}
+
+void CompositorD3D11::PrepareViewport(const gfx::IntSize& aSize) {
+ // This view matrix translates coordinates from 0..width and 0..height to
+ // -1..1 on the X axis, and -1..1 on the Y axis (flips the Y coordinate)
+ Matrix viewMatrix = Matrix::Translation(-1.0, 1.0);
+ viewMatrix.PreScale(2.0f / float(aSize.width), 2.0f / float(aSize.height));
+ viewMatrix.PreScale(1.0f, -1.0f);
+
+ Matrix4x4 projection = Matrix4x4::From2D(viewMatrix);
+ projection._33 = 0.0f;
+
+ PrepareViewport(aSize, projection, 0.0f, 1.0f);
+}
+
+void CompositorD3D11::PrepareViewport(const gfx::IntSize& aSize,
+ const gfx::Matrix4x4& aProjection,
+ float aZNear, float aZFar) {
+ D3D11_VIEWPORT viewport;
+ viewport.MaxDepth = aZFar;
+ viewport.MinDepth = aZNear;
+ viewport.Width = aSize.width;
+ viewport.Height = aSize.height;
+ viewport.TopLeftX = 0;
+ viewport.TopLeftY = 0;
+
+ mContext->RSSetViewports(1, &viewport);
+
+ memcpy(&mVSConstants.projection, &aProjection._11,
+ sizeof(mVSConstants.projection));
+}
+
+void CompositorD3D11::EnsureSize() { mSize = mWidget->GetClientSize(); }
+
+bool CompositorD3D11::VerifyBufferSize() {
+ mWidget->AsWindows()->UpdateCompositorWndSizeIfNecessary();
+
+ DXGI_SWAP_CHAIN_DESC swapDesc;
+ HRESULT hr;
+
+ hr = mSwapChain->GetDesc(&swapDesc);
+ if (FAILED(hr)) {
+ gfxCriticalError() << "Failed to get the description " << hexa(hr) << ", "
+ << mSize << ", " << (int)mVerifyBuffersFailed;
+ HandleError(hr);
+ return false;
+ }
+
+ if (((static_cast<int32_t>(swapDesc.BufferDesc.Width) == mSize.width &&
+ static_cast<int32_t>(swapDesc.BufferDesc.Height) == mSize.height) ||
+ mSize.width <= 0 || mSize.height <= 0) &&
+ !mVerifyBuffersFailed) {
+ return true;
+ }
+
+ ID3D11RenderTargetView* view = nullptr;
+ mContext->OMSetRenderTargets(1, &view, nullptr);
+
+ if (mDefaultRT) {
+ RefPtr<ID3D11RenderTargetView> rtView = mDefaultRT->mRTView;
+ RefPtr<ID3D11ShaderResourceView> srView = mDefaultRT->mSRV;
+
+ // Make sure the texture, which belongs to the swapchain, is destroyed
+ // before resizing the swapchain.
+ if (mCurrentRT == mDefaultRT) {
+ mCurrentRT = nullptr;
+ }
+
+ MOZ_ASSERT(mDefaultRT->hasOneRef());
+ mDefaultRT = nullptr;
+
+ RefPtr<ID3D11Resource> resource;
+ rtView->GetResource(getter_AddRefs(resource));
+
+ ULONG newRefCnt = rtView.forget().take()->Release();
+
+ if (newRefCnt > 0) {
+ gfxCriticalError() << "mRTView not destroyed on final release! RefCnt: "
+ << newRefCnt;
+ }
+
+ if (srView) {
+ newRefCnt = srView.forget().take()->Release();
+
+ if (newRefCnt > 0) {
+ gfxCriticalError() << "mSRV not destroyed on final release! RefCnt: "
+ << newRefCnt;
+ }
+ }
+
+ newRefCnt = resource.forget().take()->Release();
+
+ if (newRefCnt > 0) {
+ gfxCriticalError()
+ << "Unexpecting lingering references to backbuffer! RefCnt: "
+ << newRefCnt;
+ }
+ }
+
+ hr = mSwapChain->ResizeBuffers(0, mSize.width, mSize.height,
+ DXGI_FORMAT_B8G8R8A8_UNORM, 0);
+
+ mVerifyBuffersFailed = FAILED(hr);
+ if (mVerifyBuffersFailed) {
+ gfxCriticalNote << "D3D11 swap resize buffers failed " << hexa(hr) << " on "
+ << mSize;
+ HandleError(hr);
+ mBufferSize = LayoutDeviceIntSize();
+ } else {
+ mBufferSize = mSize;
+ }
+
+ mBackBufferInvalid = mFrontBufferInvalid =
+ IntRect(0, 0, mSize.width, mSize.height);
+
+ return !mVerifyBuffersFailed;
+}
+
+bool CompositorD3D11::UpdateRenderTarget() {
+ HRESULT hr;
+
+ RefPtr<ID3D11Texture2D> backBuf;
+
+ if (!VerifyBufferSize()) {
+ gfxCriticalNote << "Failed VerifyBufferSize in UpdateRenderTarget "
+ << mSize;
+ return false;
+ }
+
+ if (mSize.width <= 0 || mSize.height <= 0) {
+ gfxCriticalNote << "Invalid size in UpdateRenderTarget " << mSize << ", "
+ << (int)mVerifyBuffersFailed;
+ return false;
+ }
+
+ hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+ (void**)backBuf.StartAssignment());
+ if (hr == DXGI_ERROR_INVALID_CALL) {
+ // This happens on some GPUs/drivers when there's a TDR.
+ if (mDevice->GetDeviceRemovedReason() != S_OK) {
+ gfxCriticalError() << "GetBuffer returned invalid call! " << mSize << ", "
+ << (int)mVerifyBuffersFailed;
+ return false;
+ }
+ }
+
+ if (FAILED(hr)) {
+ gfxCriticalNote << "Failed in UpdateRenderTarget " << hexa(hr) << ", "
+ << mSize << ", " << (int)mVerifyBuffersFailed;
+ HandleError(hr);
+ return false;
+ }
+
+ IntRegion validFront;
+ validFront.Sub(mBackBufferInvalid, mFrontBufferInvalid);
+
+ if (mIsDoubleBuffered && !validFront.IsEmpty()) {
+ RefPtr<ID3D11Texture2D> frontBuf;
+ hr = mSwapChain->GetBuffer(1, __uuidof(ID3D11Texture2D),
+ (void**)frontBuf.StartAssignment());
+
+ if (SUCCEEDED(hr)) {
+ for (auto iter = validFront.RectIter(); !iter.Done(); iter.Next()) {
+ const IntRect& rect = iter.Get();
+
+ D3D11_BOX box;
+ box.back = 1;
+ box.front = 0;
+ box.left = rect.X();
+ box.right = rect.XMost();
+ box.top = rect.Y();
+ box.bottom = rect.YMost();
+ mContext->CopySubresourceRegion(backBuf, 0, rect.X(), rect.Y(), 0,
+ frontBuf, 0, &box);
+ }
+ mBackBufferInvalid = mFrontBufferInvalid;
+ }
+ }
+
+ mDefaultRT = new CompositingRenderTargetD3D11(backBuf, IntPoint(0, 0));
+ mDefaultRT->SetSize(mSize.ToUnknownSize());
+
+ return true;
+}
+
+bool CompositorD3D11::UpdateConstantBuffers() {
+ HRESULT hr;
+ D3D11_MAPPED_SUBRESOURCE resource;
+ resource.pData = nullptr;
+
+ hr = mContext->Map(mAttachments->mVSConstantBuffer, 0,
+ D3D11_MAP_WRITE_DISCARD, 0, &resource);
+ if (FAILED(hr) || !resource.pData) {
+ gfxCriticalError() << "Failed to map VSConstantBuffer. Result: " << hexa(hr)
+ << ", " << (int)mVerifyBuffersFailed;
+ HandleError(hr);
+ return false;
+ }
+ *(VertexShaderConstants*)resource.pData = mVSConstants;
+ mContext->Unmap(mAttachments->mVSConstantBuffer, 0);
+ resource.pData = nullptr;
+
+ hr = mContext->Map(mAttachments->mPSConstantBuffer, 0,
+ D3D11_MAP_WRITE_DISCARD, 0, &resource);
+ if (FAILED(hr) || !resource.pData) {
+ gfxCriticalError() << "Failed to map PSConstantBuffer. Result: " << hexa(hr)
+ << ", " << (int)mVerifyBuffersFailed;
+ HandleError(hr);
+ return false;
+ }
+ *(PixelShaderConstants*)resource.pData = mPSConstants;
+ mContext->Unmap(mAttachments->mPSConstantBuffer, 0);
+
+ ID3D11Buffer* buffer = mAttachments->mVSConstantBuffer;
+
+ mContext->VSSetConstantBuffers(0, 1, &buffer);
+
+ buffer = mAttachments->mPSConstantBuffer;
+ mContext->PSSetConstantBuffers(0, 1, &buffer);
+ return true;
+}
+
+void CompositorD3D11::SetSamplerForSamplingFilter(
+ SamplingFilter aSamplingFilter) {
+ ID3D11SamplerState* sampler;
+ switch (aSamplingFilter) {
+ case SamplingFilter::POINT:
+ sampler = mAttachments->mPointSamplerState;
+ break;
+ case SamplingFilter::LINEAR:
+ default:
+ sampler = mAttachments->mLinearSamplerState;
+ break;
+ }
+
+ mContext->PSSetSamplers(0, 1, &sampler);
+}
+
+void CompositorD3D11::PaintToTarget() {
+ RefPtr<ID3D11Texture2D> backBuf;
+ HRESULT hr;
+
+ hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+ (void**)backBuf.StartAssignment());
+ if (FAILED(hr)) {
+ gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false))
+ << "Failed in PaintToTarget 1";
+ HandleError(hr);
+ return;
+ }
+
+ D3D11_TEXTURE2D_DESC bbDesc;
+ backBuf->GetDesc(&bbDesc);
+
+ CD3D11_TEXTURE2D_DESC softDesc(bbDesc.Format, bbDesc.Width, bbDesc.Height);
+ softDesc.MipLevels = 1;
+ softDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+ softDesc.Usage = D3D11_USAGE_STAGING;
+ softDesc.BindFlags = 0;
+
+ RefPtr<ID3D11Texture2D> readTexture;
+
+ hr =
+ mDevice->CreateTexture2D(&softDesc, nullptr, getter_AddRefs(readTexture));
+ if (FAILED(hr)) {
+ gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false))
+ << "Failed in PaintToTarget 2";
+ HandleError(hr);
+ return;
+ }
+ mContext->CopyResource(readTexture, backBuf);
+
+ D3D11_MAPPED_SUBRESOURCE map;
+ hr = mContext->Map(readTexture, 0, D3D11_MAP_READ, 0, &map);
+ if (FAILED(hr)) {
+ gfxCriticalErrorOnce(gfxCriticalError::DefaultOptions(false))
+ << "Failed in PaintToTarget 3";
+ HandleError(hr);
+ return;
+ }
+ RefPtr<DataSourceSurface> sourceSurface =
+ Factory::CreateWrappingDataSourceSurface(
+ (uint8_t*)map.pData, map.RowPitch,
+ IntSize(bbDesc.Width, bbDesc.Height), SurfaceFormat::B8G8R8A8);
+ mTarget->CopySurface(sourceSurface,
+ IntRect(0, 0, bbDesc.Width, bbDesc.Height),
+ IntPoint(-mTargetBounds.X(), -mTargetBounds.Y()));
+
+ mTarget->Flush();
+ mContext->Unmap(readTexture, 0);
+}
+
+bool CompositorD3D11::Failed(HRESULT hr, const char* aContext) {
+ if (SUCCEEDED(hr)) return false;
+
+ gfxCriticalNote << "[D3D11] " << aContext << " failed: " << hexa(hr) << ", "
+ << (int)mVerifyBuffersFailed;
+ return true;
+}
+
+SyncObjectHost* CompositorD3D11::GetSyncObject() {
+ if (mAttachments) {
+ return mAttachments->mSyncObject;
+ }
+ return nullptr;
+}
+
+void CompositorD3D11::HandleError(HRESULT hr, Severity aSeverity) {
+ if (SUCCEEDED(hr)) {
+ return;
+ }
+
+ if (aSeverity == Critical) {
+ MOZ_CRASH("GFX: Unrecoverable D3D11 error");
+ }
+
+ if (mDevice && DeviceManagerDx::Get()->GetCompositorDevice() != mDevice) {
+ gfxCriticalNote << "Out of sync D3D11 devices in HandleError, "
+ << (int)mVerifyBuffersFailed;
+ }
+
+ HRESULT hrOnReset = S_OK;
+ bool deviceRemoved = hr == DXGI_ERROR_DEVICE_REMOVED;
+
+ if (deviceRemoved && mDevice) {
+ hrOnReset = mDevice->GetDeviceRemovedReason();
+ } else if (hr == DXGI_ERROR_INVALID_CALL && mDevice) {
+ hrOnReset = mDevice->GetDeviceRemovedReason();
+ if (hrOnReset != S_OK) {
+ deviceRemoved = true;
+ }
+ }
+
+ // Device reset may not be an error on our side, but can mess things up so
+ // it's useful to see it in the reports.
+ gfxCriticalError(CriticalLog::DefaultOptions(!deviceRemoved))
+ << (deviceRemoved ? "[CompositorD3D11] device removed with error code: "
+ : "[CompositorD3D11] error code: ")
+ << hexa(hr) << ", " << hexa(hrOnReset) << ", "
+ << (int)mVerifyBuffersFailed;
+
+ // Crash if we are making invalid calls outside of device removal
+ if (hr == DXGI_ERROR_INVALID_CALL) {
+ gfxDevCrash(deviceRemoved ? LogReason::D3D11InvalidCallDeviceRemoved
+ : LogReason::D3D11InvalidCall)
+ << "Invalid D3D11 api call";
+ }
+
+ if (aSeverity == Recoverable) {
+ NS_WARNING("Encountered a recoverable D3D11 error");
+ }
+}
+
+} // namespace layers
+} // namespace mozilla
diff --git a/gfx/layers/d3d11/CompositorD3D11.h b/gfx/layers/d3d11/CompositorD3D11.h
new file mode 100644
index 0000000000..d8cdd2d2f8
--- /dev/null
+++ b/gfx/layers/d3d11/CompositorD3D11.h
@@ -0,0 +1,227 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_COMPOSITORD3D11_H
+#define MOZILLA_GFX_COMPOSITORD3D11_H
+
+#include "mozilla/gfx/2D.h"
+#include "gfx2DGlue.h"
+#include "mozilla/layers/Compositor.h"
+#include "TextureD3D11.h"
+#include <d3d11.h>
+#include <dxgi1_2.h>
+#include "ShaderDefinitionsD3D11.h"
+
+class nsWidget;
+
+namespace mozilla {
+namespace layers {
+
+#define LOGD3D11(param)
+
+class DeviceAttachmentsD3D11;
+
+class CompositorD3D11 : public Compositor {
+ public:
+ explicit CompositorD3D11(widget::CompositorWidget* aWidget);
+ virtual ~CompositorD3D11();
+
+ CompositorD3D11* AsCompositorD3D11() override { return this; }
+
+ bool Initialize(nsCString* const out_failureReason) override;
+
+ already_AddRefed<DataTextureSource> CreateDataTextureSource(
+ TextureFlags aFlags = TextureFlags::NO_FLAGS) override;
+
+ int32_t GetMaxTextureSize() const final;
+
+ already_AddRefed<CompositingRenderTarget> CreateRenderTarget(
+ const gfx::IntRect& aRect, SurfaceInitMode aInit) override;
+
+ void SetRenderTarget(CompositingRenderTarget* aSurface) override;
+ already_AddRefed<CompositingRenderTarget> GetCurrentRenderTarget()
+ const override {
+ return do_AddRef(mCurrentRT);
+ }
+ already_AddRefed<CompositingRenderTarget> GetWindowRenderTarget()
+ const override;
+
+ bool ReadbackRenderTarget(CompositingRenderTarget* aSource,
+ AsyncReadbackBuffer* aDest) override;
+ already_AddRefed<AsyncReadbackBuffer> CreateAsyncReadbackBuffer(
+ const gfx::IntSize& aSize) override;
+
+ bool BlitRenderTarget(CompositingRenderTarget* aSource,
+ const gfx::IntSize& aSourceSize,
+ const gfx::IntSize& aDestSize) override;
+
+ void SetDestinationSurfaceSize(const gfx::IntSize& aSize) override {}
+
+ void ClearRect(const gfx::Rect& aRect);
+
+ void DrawQuad(const gfx::Rect& aRect, const gfx::IntRect& aClipRect,
+ const EffectChain& aEffectChain, gfx::Float aOpacity,
+ const gfx::Matrix4x4& aTransform,
+ const gfx::Rect& aVisibleRect) override;
+
+ /**
+ * Start a new frame.
+ */
+ Maybe<gfx::IntRect> BeginFrameForWindow(
+ const nsIntRegion& aInvalidRegion, const Maybe<gfx::IntRect>& aClipRect,
+ const gfx::IntRect& aRenderBounds,
+ const nsIntRegion& aOpaqueRegion) override;
+
+ /**
+ * Flush the current frame to the screen.
+ */
+ void EndFrame() override;
+
+ void CancelFrame(bool aNeedFlush = true) override;
+
+ /**
+ * Setup the viewport and projection matrix for rendering
+ * to a window of the given dimensions.
+ */
+ virtual void PrepareViewport(const gfx::IntSize& aSize);
+ virtual void PrepareViewport(const gfx::IntSize& aSize,
+ const gfx::Matrix4x4& aProjection, float aZNear,
+ float aZFar);
+
+#ifdef MOZ_DUMP_PAINTING
+ const char* Name() const override { return "Direct3D 11"; }
+#endif
+
+ // For TextureSourceProvider.
+ ID3D11Device* GetD3D11Device() const override { return mDevice; }
+
+ ID3D11Device* GetDevice() { return mDevice; }
+
+ ID3D11DeviceContext* GetDC() { return mContext; }
+
+ virtual void RequestAllowFrameRecording(bool aWillRecord) override {
+ mAllowFrameRecording = aWillRecord;
+ }
+
+ void Readback(gfx::DrawTarget* aDrawTarget) {
+ mTarget = aDrawTarget;
+ mTargetBounds = gfx::IntRect();
+ PaintToTarget();
+ mTarget = nullptr;
+ }
+
+ SyncObjectHost* GetSyncObject();
+
+ private:
+ enum Severity {
+ Recoverable,
+ DebugAssert,
+ Critical,
+ };
+
+ void HandleError(HRESULT hr, Severity aSeverity = DebugAssert);
+
+ // Same as Failed(), except the severity is critical (with no abort) and
+ // a string prefix must be provided.
+ bool Failed(HRESULT hr, const char* aContext);
+
+ // ensure mSize is up to date with respect to mWidget
+ void EnsureSize();
+ bool VerifyBufferSize();
+ bool UpdateRenderTarget();
+ bool UpdateConstantBuffers();
+ void SetSamplerForSamplingFilter(gfx::SamplingFilter aSamplingFilter);
+
+ ID3D11PixelShader* GetPSForEffect(Effect* aEffect);
+ Maybe<gfx::IntRect> BeginFrame(const nsIntRegion& aInvalidRegion,
+ const Maybe<gfx::IntRect>& aClipRect,
+ const gfx::IntRect& aRenderBounds,
+ const nsIntRegion& aOpaqueRegion);
+ void PaintToTarget();
+ RefPtr<ID3D11Texture2D> CreateTexture(const gfx::IntRect& aRect,
+ const CompositingRenderTarget* aSource,
+ const gfx::IntPoint& aSourcePoint);
+
+ void PrepareStaticVertexBuffer();
+
+ void Draw(const gfx::Rect& aGeometry, const gfx::Rect* aTexCoords);
+
+ void Present();
+
+ template <typename VertexType>
+ void SetVertexBuffer(ID3D11Buffer* aBuffer);
+
+ /**
+ * Whether or not the recorder should be recording frames.
+ *
+ * When this returns true, the CompositorD3D11 will allocate and return window
+ * render targets from |GetWindowRenderTarget|, which otherwise returns
+ * nullptr.
+ *
+ * This will be true when either we are recording a profile with screenshots
+ * enabled or the |LayerManagerComposite| has requested us to record frames
+ * for the |CompositionRecorder|.
+ */
+ bool ShouldAllowFrameRecording() const;
+
+ // The DrawTarget from BeginFrameForTarget, which EndFrame needs to copy the
+ // window contents into.
+ // Only non-null between BeginFrameForTarget and EndFrame.
+ RefPtr<gfx::DrawTarget> mTarget;
+ gfx::IntRect mTargetBounds;
+
+ RefPtr<ID3D11DeviceContext> mContext;
+ RefPtr<ID3D11Device> mDevice;
+ RefPtr<IDXGISwapChain> mSwapChain;
+ RefPtr<CompositingRenderTargetD3D11> mDefaultRT;
+ RefPtr<CompositingRenderTargetD3D11> mCurrentRT;
+ mutable RefPtr<CompositingRenderTargetD3D11> mWindowRTCopy;
+
+ RefPtr<ID3D11Query> mQuery;
+ RefPtr<ID3D11Query> mRecycledQuery;
+
+ RefPtr<DeviceAttachmentsD3D11> mAttachments;
+
+ LayoutDeviceIntSize mSize;
+
+ // The size that we passed to ResizeBuffers to set
+ // the swapchain buffer size.
+ LayoutDeviceIntSize mBufferSize;
+
+ HWND mHwnd;
+
+ D3D_FEATURE_LEVEL mFeatureLevel;
+
+ VertexShaderConstants mVSConstants;
+ PixelShaderConstants mPSConstants;
+ bool mDisableSequenceForNextFrame;
+ bool mAllowPartialPresents;
+ bool mIsDoubleBuffered;
+
+ gfx::IntRegion mFrontBufferInvalid;
+ gfx::IntRegion mBackBufferInvalid;
+ // This is the clip rect applied to the default DrawTarget (i.e. the window)
+ gfx::IntRect mCurrentClip;
+
+ bool mVerifyBuffersFailed;
+ bool mUseMutexOnPresent;
+ bool mAllowFrameRecording;
+};
+
+namespace TexSlot {
+static const int RGB = 0;
+static const int Y = 1;
+static const int Cb = 2;
+static const int Cr = 3;
+static const int RGBWhite = 4;
+static const int Mask = 5;
+static const int Backdrop = 6;
+} // namespace TexSlot
+
+} // namespace layers
+} // namespace mozilla
+
+#endif
diff --git a/gfx/layers/d3d11/CompositorD3D11.hlsl b/gfx/layers/d3d11/CompositorD3D11.hlsl
new file mode 100644
index 0000000000..4e13011782
--- /dev/null
+++ b/gfx/layers/d3d11/CompositorD3D11.hlsl
@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "BlendShaderConstants.h"
+
+typedef float4 rect;
+
+float4x4 mLayerTransform : register(vs, c0);
+float4x4 mProjection : register(vs, c4);
+float4 vRenderTargetOffset : register(vs, c8);
+rect vTextureCoords : register(vs, c9);
+rect vLayerQuad : register(vs, c10);
+
+float4 fLayerColor : register(ps, c0);
+float fLayerOpacity : register(ps, c1);
+
+// x = layer type
+// y = mask type
+// z = blend op
+// w = is premultiplied
+
+float fCoefficient : register(ps, c3);
+
+row_major float3x3 mYuvColorMatrix : register(ps, c4);
+
+sampler sSampler : register(ps, s0);
+
+// The mix-blend mega shader uses all variables, so we have to make sure they
+// are assigned fixed slots.
+Texture2D tRGB : register(ps, t0);
+Texture2D tY : register(ps, t1);
+Texture2D tCb : register(ps, t2);
+Texture2D tCr : register(ps, t3);
+
+struct VS_INPUT {
+ float2 vPosition : POSITION;
+};
+
+struct VS_TEX_INPUT {
+ float2 vPosition : POSITION;
+ float2 vTexCoords : TEXCOORD0;
+};
+
+struct VS_OUTPUT {
+ float4 vPosition : SV_Position;
+ float2 vTexCoords : TEXCOORD0;
+};
+
+struct PS_OUTPUT {
+ float4 vSrc;
+ float4 vAlpha;
+};
+
+float2 TexCoords(const float2 aPosition)
+{
+ float2 result;
+ const float2 size = vTextureCoords.zw;
+ result.x = vTextureCoords.x + aPosition.x * size.x;
+ result.y = vTextureCoords.y + aPosition.y * size.y;
+
+ return result;
+}
+
+SamplerState LayerTextureSamplerLinear
+{
+ Filter = MIN_MAG_MIP_LINEAR;
+ AddressU = Clamp;
+ AddressV = Clamp;
+};
+
+float4 TransformedPosition(float2 aInPosition)
+{
+ // the current vertex's position on the quad
+ // [x,y,0,1] is mandated by the CSS Transforms spec as the point value to transform
+ float4 position = float4(0, 0, 0, 1);
+
+ // We use 4 component floats to uniquely describe a rectangle, by the structure
+ // of x, y, width, height. This allows us to easily generate the 4 corners
+ // of any rectangle from the 4 corners of the 0,0-1,1 quad that we use as the
+ // stream source for our LayerQuad vertex shader. We do this by doing:
+ // Xout = x + Xin * width
+ // Yout = y + Yin * height
+ float2 size = vLayerQuad.zw;
+ position.x = vLayerQuad.x + aInPosition.x * size.x;
+ position.y = vLayerQuad.y + aInPosition.y * size.y;
+
+ position = mul(mLayerTransform, position);
+
+ return position;
+}
+
+float4 VertexPosition(float4 aTransformedPosition)
+{
+ float4 result;
+ result.w = aTransformedPosition.w;
+ result.xyz = aTransformedPosition.xyz / aTransformedPosition.w;
+ result -= vRenderTargetOffset;
+ result.xyz *= result.w;
+
+ result = mul(mProjection, result);
+
+ return result;
+}
+
+VS_OUTPUT LayerQuadVS(const VS_INPUT aVertex)
+{
+ VS_OUTPUT outp;
+ float4 position = TransformedPosition(aVertex.vPosition);
+
+ outp.vPosition = VertexPosition(position);
+ outp.vTexCoords = TexCoords(aVertex.vPosition.xy);
+
+ return outp;
+}
+
+/* From Rec601:
+[R] [1.1643835616438356, 0.0, 1.5960267857142858] [ Y - 16]
+[G] = [1.1643835616438358, -0.3917622900949137, -0.8129676472377708] x [Cb - 128]
+[B] [1.1643835616438356, 2.017232142857143, 8.862867620416422e-17] [Cr - 128]
+
+For [0,1] instead of [0,255], and to 5 places:
+[R] [1.16438, 0.00000, 1.59603] [ Y - 0.06275]
+[G] = [1.16438, -0.39176, -0.81297] x [Cb - 0.50196]
+[B] [1.16438, 2.01723, 0.00000] [Cr - 0.50196]
+
+From Rec709:
+[R] [1.1643835616438356, 4.2781193979771426e-17, 1.7927410714285714] [ Y - 16]
+[G] = [1.1643835616438358, -0.21324861427372963, -0.532909328559444] x [Cb - 128]
+[B] [1.1643835616438356, 2.1124017857142854, 0.0] [Cr - 128]
+
+For [0,1] instead of [0,255], and to 5 places:
+[R] [1.16438, 0.00000, 1.79274] [ Y - 0.06275]
+[G] = [1.16438, -0.21325, -0.53291] x [Cb - 0.50196]
+[B] [1.16438, 2.11240, 0.00000] [Cr - 0.50196]
+*/
+float4 CalculateYCbCrColor(const float2 aTexCoords)
+{
+ float3 yuv = float3(
+ tY.Sample(sSampler, aTexCoords).r,
+ tCb.Sample(sSampler, aTexCoords).r,
+ tCr.Sample(sSampler, aTexCoords).r);
+ yuv = yuv * fCoefficient - float3(0.06275, 0.50196, 0.50196);
+
+ return float4(mul(mYuvColorMatrix, yuv), 1.0);
+}
+
+float4 CalculateNV12Color(const float2 aTexCoords)
+{
+ float3 yuv = float3(
+ tY.Sample(sSampler, aTexCoords).r,
+ tCb.Sample(sSampler, aTexCoords).r,
+ tCb.Sample(sSampler, aTexCoords).g);
+ yuv = yuv * fCoefficient - float3(0.06275, 0.50196, 0.50196);
+
+ return float4(mul(mYuvColorMatrix, yuv), 1.0);
+}
+
+float4 SolidColorShader(const VS_OUTPUT aVertex) : SV_Target
+{
+ return fLayerColor;
+}
+
+float4 RGBAShader(const VS_OUTPUT aVertex) : SV_Target
+{
+ return tRGB.Sample(sSampler, aVertex.vTexCoords) * fLayerOpacity;
+}
+
+float4 RGBShader(const VS_OUTPUT aVertex) : SV_Target
+{
+ float4 result;
+ result = tRGB.Sample(sSampler, aVertex.vTexCoords) * fLayerOpacity;
+ result.a = fLayerOpacity;
+ return result;
+}
+
+float4 YCbCrShader(const VS_OUTPUT aVertex) : SV_Target
+{
+ return CalculateYCbCrColor(aVertex.vTexCoords) * fLayerOpacity;
+}
+
+float4 NV12Shader(const VS_OUTPUT aVertex) : SV_Target
+{
+ return CalculateNV12Color(aVertex.vTexCoords) * fLayerOpacity;
+}
diff --git a/gfx/layers/d3d11/DeviceAttachmentsD3D11.cpp b/gfx/layers/d3d11/DeviceAttachmentsD3D11.cpp
new file mode 100644
index 0000000000..3a80e30cc4
--- /dev/null
+++ b/gfx/layers/d3d11/DeviceAttachmentsD3D11.cpp
@@ -0,0 +1,249 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "DeviceAttachmentsD3D11.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/Compositor.h"
+#include "CompositorD3D11Shaders.h"
+#include "ShaderDefinitionsD3D11.h"
+
+namespace mozilla {
+namespace layers {
+
+using namespace gfx;
+
+DeviceAttachmentsD3D11::DeviceAttachmentsD3D11(ID3D11Device* device)
+ : mDevice(device),
+ mContinueInit(true),
+ mInitialized(false),
+ mDeviceReset(false) {}
+
+DeviceAttachmentsD3D11::~DeviceAttachmentsD3D11() {}
+
+/* static */
+RefPtr<DeviceAttachmentsD3D11> DeviceAttachmentsD3D11::Create(
+ ID3D11Device* aDevice) {
+ // We don't return null even if the attachments object even if it fails to
+ // initialize, so the compositor can grab the failure ID.
+ RefPtr<DeviceAttachmentsD3D11> attachments =
+ new DeviceAttachmentsD3D11(aDevice);
+ attachments->Initialize();
+ return attachments.forget();
+}
+
+bool DeviceAttachmentsD3D11::Initialize() {
+ D3D11_INPUT_ELEMENT_DESC layout[] = {
+ {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0,
+ D3D11_INPUT_PER_VERTEX_DATA, 0},
+ };
+
+ HRESULT hr;
+ hr = mDevice->CreateInputLayout(
+ layout, sizeof(layout) / sizeof(D3D11_INPUT_ELEMENT_DESC), LayerQuadVS,
+ sizeof(LayerQuadVS), getter_AddRefs(mInputLayout));
+
+ if (Failed(hr, "CreateInputLayout")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_INPUT_LAYOUT";
+ return false;
+ }
+
+ Vertex vertices[] = {{{0.0, 0.0}}, {{1.0, 0.0}}, {{0.0, 1.0}}, {{1.0, 1.0}}};
+ CD3D11_BUFFER_DESC bufferDesc(sizeof(vertices), D3D11_BIND_VERTEX_BUFFER);
+ D3D11_SUBRESOURCE_DATA data;
+ data.pSysMem = (void*)vertices;
+
+ hr = mDevice->CreateBuffer(&bufferDesc, &data, getter_AddRefs(mVertexBuffer));
+ if (Failed(hr, "create vertex buffer")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_VERTEX_BUFFER";
+ return false;
+ }
+ if (!CreateShaders()) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_CREATE_SHADERS";
+ return false;
+ }
+
+ CD3D11_BUFFER_DESC cBufferDesc(sizeof(VertexShaderConstants),
+ D3D11_BIND_CONSTANT_BUFFER,
+ D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
+
+ hr = mDevice->CreateBuffer(&cBufferDesc, nullptr,
+ getter_AddRefs(mVSConstantBuffer));
+ if (Failed(hr, "create vs buffer")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_VS_BUFFER";
+ return false;
+ }
+
+ cBufferDesc.ByteWidth = sizeof(PixelShaderConstants);
+ hr = mDevice->CreateBuffer(&cBufferDesc, nullptr,
+ getter_AddRefs(mPSConstantBuffer));
+ if (Failed(hr, "create ps buffer")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_PS_BUFFER";
+ return false;
+ }
+
+ CD3D11_RASTERIZER_DESC rastDesc(D3D11_DEFAULT);
+ rastDesc.CullMode = D3D11_CULL_NONE;
+ rastDesc.ScissorEnable = TRUE;
+
+ hr = mDevice->CreateRasterizerState(&rastDesc,
+ getter_AddRefs(mRasterizerState));
+ if (Failed(hr, "create rasterizer")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_RASTERIZER";
+ return false;
+ }
+
+ CD3D11_SAMPLER_DESC samplerDesc(D3D11_DEFAULT);
+ hr = mDevice->CreateSamplerState(&samplerDesc,
+ getter_AddRefs(mLinearSamplerState));
+ if (Failed(hr, "create linear sampler")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_LINEAR_SAMPLER";
+ return false;
+ }
+
+ samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
+ hr = mDevice->CreateSamplerState(&samplerDesc,
+ getter_AddRefs(mPointSamplerState));
+ if (Failed(hr, "create point sampler")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_POINT_SAMPLER";
+ return false;
+ }
+
+ CD3D11_BLEND_DESC blendDesc(D3D11_DEFAULT);
+ D3D11_RENDER_TARGET_BLEND_DESC rtBlendPremul = {TRUE,
+ D3D11_BLEND_ONE,
+ D3D11_BLEND_INV_SRC_ALPHA,
+ D3D11_BLEND_OP_ADD,
+ D3D11_BLEND_ONE,
+ D3D11_BLEND_INV_SRC_ALPHA,
+ D3D11_BLEND_OP_ADD,
+ D3D11_COLOR_WRITE_ENABLE_ALL};
+ blendDesc.RenderTarget[0] = rtBlendPremul;
+ hr = mDevice->CreateBlendState(&blendDesc, getter_AddRefs(mPremulBlendState));
+ if (Failed(hr, "create pm blender")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_PM_BLENDER";
+ return false;
+ }
+
+ D3D11_RENDER_TARGET_BLEND_DESC rtCopyPremul = {TRUE,
+ D3D11_BLEND_ONE,
+ D3D11_BLEND_ZERO,
+ D3D11_BLEND_OP_ADD,
+ D3D11_BLEND_ONE,
+ D3D11_BLEND_ZERO,
+ D3D11_BLEND_OP_ADD,
+ D3D11_COLOR_WRITE_ENABLE_ALL};
+ blendDesc.RenderTarget[0] = rtCopyPremul;
+ hr = mDevice->CreateBlendState(&blendDesc, getter_AddRefs(mPremulCopyState));
+ if (Failed(hr, "create pm copy blender")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_PM_COPY_BLENDER";
+ return false;
+ }
+
+ D3D11_RENDER_TARGET_BLEND_DESC rtBlendNonPremul = {
+ TRUE,
+ D3D11_BLEND_SRC_ALPHA,
+ D3D11_BLEND_INV_SRC_ALPHA,
+ D3D11_BLEND_OP_ADD,
+ D3D11_BLEND_ONE,
+ D3D11_BLEND_INV_SRC_ALPHA,
+ D3D11_BLEND_OP_ADD,
+ D3D11_COLOR_WRITE_ENABLE_ALL};
+ blendDesc.RenderTarget[0] = rtBlendNonPremul;
+ hr = mDevice->CreateBlendState(&blendDesc,
+ getter_AddRefs(mNonPremulBlendState));
+ if (Failed(hr, "create npm blender")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_NPM_BLENDER";
+ return false;
+ }
+
+ D3D11_RENDER_TARGET_BLEND_DESC rtBlendDisabled = {
+ FALSE,
+ D3D11_BLEND_SRC_ALPHA,
+ D3D11_BLEND_INV_SRC_ALPHA,
+ D3D11_BLEND_OP_ADD,
+ D3D11_BLEND_ONE,
+ D3D11_BLEND_INV_SRC_ALPHA,
+ D3D11_BLEND_OP_ADD,
+ D3D11_COLOR_WRITE_ENABLE_ALL};
+ blendDesc.RenderTarget[0] = rtBlendDisabled;
+ hr = mDevice->CreateBlendState(&blendDesc,
+ getter_AddRefs(mDisabledBlendState));
+ if (Failed(hr, "create null blender")) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_NULL_BLENDER";
+ return false;
+ }
+
+ if (!InitSyncObject()) {
+ mInitFailureId = "FEATURE_FAILURE_D3D11_OBJ_SYNC";
+ return false;
+ }
+
+ mInitialized = true;
+ return true;
+}
+
+bool DeviceAttachmentsD3D11::InitSyncObject() {
+ // Sync object is not supported on WARP.
+ if (DeviceManagerDx::Get()->IsWARP()) {
+ return true;
+ }
+
+ MOZ_ASSERT(!mSyncObject);
+ MOZ_ASSERT(mDevice);
+
+ mSyncObject = SyncObjectHost::CreateSyncObjectHost(mDevice);
+ MOZ_ASSERT(mSyncObject);
+
+ return mSyncObject->Init();
+}
+
+bool DeviceAttachmentsD3D11::CreateShaders() {
+ InitVertexShader(sLayerQuadVS, mVSQuadShader);
+
+ InitPixelShader(sSolidColorShader, mSolidColorShader);
+ InitPixelShader(sRGBShader, mRGBShader);
+ InitPixelShader(sRGBAShader, mRGBAShader);
+ InitPixelShader(sYCbCrShader, mYCbCrShader);
+ InitPixelShader(sNV12Shader, mNV12Shader);
+ return mContinueInit;
+}
+
+void DeviceAttachmentsD3D11::InitVertexShader(const ShaderBytes& aShader,
+ ID3D11VertexShader** aOut) {
+ if (!mContinueInit) {
+ return;
+ }
+ if (Failed(mDevice->CreateVertexShader(aShader.mData, aShader.mLength,
+ nullptr, aOut),
+ "create vs")) {
+ mContinueInit = false;
+ }
+}
+
+void DeviceAttachmentsD3D11::InitPixelShader(const ShaderBytes& aShader,
+ ID3D11PixelShader** aOut) {
+ if (!mContinueInit) {
+ return;
+ }
+ if (Failed(mDevice->CreatePixelShader(aShader.mData, aShader.mLength, nullptr,
+ aOut),
+ "create ps")) {
+ mContinueInit = false;
+ }
+}
+
+bool DeviceAttachmentsD3D11::Failed(HRESULT hr, const char* aContext) {
+ if (SUCCEEDED(hr)) {
+ return false;
+ }
+
+ gfxCriticalNote << "[D3D11] " << aContext << " failed: " << hexa(hr);
+ return true;
+}
+
+} // namespace layers
+} // namespace mozilla
diff --git a/gfx/layers/d3d11/DeviceAttachmentsD3D11.h b/gfx/layers/d3d11/DeviceAttachmentsD3D11.h
new file mode 100644
index 0000000000..4837dc76f1
--- /dev/null
+++ b/gfx/layers/d3d11/DeviceAttachmentsD3D11.h
@@ -0,0 +1,96 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_gfx_layers_d3d11_DeviceAttachmentsD3D11_h
+#define mozilla_gfx_layers_d3d11_DeviceAttachmentsD3D11_h
+
+#include "mozilla/EnumeratedArray.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/layers/CompositorTypes.h"
+#include "mozilla/layers/SyncObject.h"
+#include <d3d11.h>
+#include <dxgi1_2.h>
+
+namespace mozilla {
+namespace layers {
+
+struct ShaderBytes;
+
+class DeviceAttachmentsD3D11 final {
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DeviceAttachmentsD3D11);
+
+ public:
+ static RefPtr<DeviceAttachmentsD3D11> Create(ID3D11Device* aDevice);
+
+ bool IsValid() const { return mInitialized; }
+ const nsCString& GetFailureId() const {
+ MOZ_ASSERT(!IsValid());
+ return mInitFailureId;
+ }
+
+ RefPtr<ID3D11InputLayout> mInputLayout;
+
+ RefPtr<ID3D11Buffer> mVertexBuffer;
+
+ RefPtr<ID3D11VertexShader> mVSQuadShader;
+
+ RefPtr<ID3D11PixelShader> mSolidColorShader;
+ RefPtr<ID3D11PixelShader> mRGBAShader;
+ RefPtr<ID3D11PixelShader> mRGBShader;
+ RefPtr<ID3D11PixelShader> mYCbCrShader;
+ RefPtr<ID3D11PixelShader> mNV12Shader;
+ RefPtr<ID3D11Buffer> mPSConstantBuffer;
+ RefPtr<ID3D11Buffer> mVSConstantBuffer;
+ RefPtr<ID3D11RasterizerState> mRasterizerState;
+ RefPtr<ID3D11SamplerState> mLinearSamplerState;
+ RefPtr<ID3D11SamplerState> mPointSamplerState;
+
+ RefPtr<ID3D11BlendState> mPremulBlendState;
+ RefPtr<ID3D11BlendState> mPremulCopyState;
+ RefPtr<ID3D11BlendState> mNonPremulBlendState;
+ RefPtr<ID3D11BlendState> mDisabledBlendState;
+
+ RefPtr<SyncObjectHost> mSyncObject;
+
+ void SetDeviceReset() { mDeviceReset = true; }
+ bool IsDeviceReset() const { return mDeviceReset; }
+
+ private:
+ explicit DeviceAttachmentsD3D11(ID3D11Device* device);
+ ~DeviceAttachmentsD3D11();
+
+ bool Initialize();
+ bool CreateShaders();
+ bool InitSyncObject();
+
+ void InitVertexShader(const ShaderBytes& aShader,
+ RefPtr<ID3D11VertexShader>& aDest) {
+ InitVertexShader(aShader, getter_AddRefs(aDest));
+ }
+ void InitPixelShader(const ShaderBytes& aShader,
+ RefPtr<ID3D11PixelShader>& aDest) {
+ InitPixelShader(aShader, getter_AddRefs(aDest));
+ }
+
+ void InitVertexShader(const ShaderBytes& aShader, ID3D11VertexShader** aOut);
+ void InitPixelShader(const ShaderBytes& aShader, ID3D11PixelShader** aOut);
+
+ bool Failed(HRESULT hr, const char* aContext);
+
+ private:
+ // Only used during initialization.
+ RefPtr<ID3D11Device> mDevice;
+ bool mContinueInit;
+ bool mInitialized;
+ bool mDeviceReset;
+ nsCString mInitFailureId;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // mozilla_gfx_layers_d3d11_DeviceAttachmentsD3D11_h
diff --git a/gfx/layers/d3d11/HelpersD3D11.h b/gfx/layers/d3d11/HelpersD3D11.h
new file mode 100644
index 0000000000..ef40acd0a0
--- /dev/null
+++ b/gfx/layers/d3d11/HelpersD3D11.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_gfx_layers_d3d11_HelpersD3D11_h
+#define mozilla_gfx_layers_d3d11_HelpersD3D11_h
+
+#include <d3d11.h>
+#include <array>
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+
+namespace mozilla {
+namespace layers {
+
+template <typename T>
+static inline bool WaitForGPUQuery(ID3D11Device* aDevice,
+ ID3D11DeviceContext* aContext,
+ ID3D11Query* aQuery, T* aOut) {
+ TimeStamp start = TimeStamp::Now();
+ while (aContext->GetData(aQuery, aOut, sizeof(*aOut), 0) != S_OK) {
+ if (aDevice->GetDeviceRemovedReason() != S_OK) {
+ return false;
+ }
+ if (TimeStamp::Now() - start > TimeDuration::FromSeconds(2)) {
+ return false;
+ }
+ Sleep(0);
+ }
+ return true;
+}
+
+static inline bool WaitForFrameGPUQuery(ID3D11Device* aDevice,
+ ID3D11DeviceContext* aContext,
+ ID3D11Query* aQuery, BOOL* aOut) {
+ TimeStamp start = TimeStamp::Now();
+ bool success = true;
+ while (aContext->GetData(aQuery, aOut, sizeof(*aOut), 0) != S_OK) {
+ if (aDevice->GetDeviceRemovedReason() != S_OK) {
+ return false;
+ }
+ if (TimeStamp::Now() - start > TimeDuration::FromSeconds(2)) {
+ success = false;
+ break;
+ }
+ Sleep(0);
+ }
+ Telemetry::AccumulateTimeDelta(Telemetry::GPU_WAIT_TIME_MS, start);
+ return success;
+}
+
+inline void ClearResource(ID3D11Device* const device, ID3D11Resource* const res,
+ const std::array<float, 4>& vals) {
+ RefPtr<ID3D11RenderTargetView> rtv;
+ (void)device->CreateRenderTargetView(res, nullptr, getter_AddRefs(rtv));
+
+ RefPtr<ID3D11DeviceContext> context;
+ device->GetImmediateContext(getter_AddRefs(context));
+ context->ClearRenderTargetView(rtv, vals.data());
+}
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // mozilla_gfx_layers_d3d11_HelpersD3D11_h
diff --git a/gfx/layers/d3d11/ShaderDefinitionsD3D11.h b/gfx/layers/d3d11/ShaderDefinitionsD3D11.h
new file mode 100644
index 0000000000..1e15cf7987
--- /dev/null
+++ b/gfx/layers/d3d11/ShaderDefinitionsD3D11.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_gfx_layers_d3d11_ShaderDefinitionsD3D11_h
+#define mozilla_gfx_layers_d3d11_ShaderDefinitionsD3D11_h
+
+#include "mozilla/gfx/Rect.h"
+
+namespace mozilla {
+namespace layers {
+
+struct VertexShaderConstants {
+ float layerTransform[4][4];
+ float projection[4][4];
+ float renderTargetOffset[4];
+ gfx::Rect textureCoords;
+ gfx::Rect layerQuad;
+ float maskTransform[4][4];
+ float backdropTransform[4][4];
+};
+
+struct PixelShaderConstants {
+ float layerColor[4];
+ float layerOpacity[4];
+ int blendConfig[4];
+ float vCoefficient[4];
+ float yuvColorMatrix[3][4];
+};
+
+struct Vertex {
+ float position[2];
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // mozilla_gfx_layers_d3d11_ShaderDefinitionsD3D11_h
diff --git a/gfx/layers/d3d11/TextureD3D11.cpp b/gfx/layers/d3d11/TextureD3D11.cpp
new file mode 100644
index 0000000000..a7bcc02b8f
--- /dev/null
+++ b/gfx/layers/d3d11/TextureD3D11.cpp
@@ -0,0 +1,1962 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "TextureD3D11.h"
+
+#include "CompositorD3D11.h"
+#include "Effects.h"
+#include "MainThreadUtils.h"
+#include "gfx2DGlue.h"
+#include "gfxContext.h"
+#include "gfxWindowsPlatform.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/gfx/DataSurfaceHelpers.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/D3D11TextureIMFSampleImage.h"
+#include "mozilla/layers/HelpersD3D11.h"
+#include "mozilla/webrender/RenderD3D11TextureHost.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace layers {
+
+static const GUID sD3D11TextureUsage = {
+ 0xd89275b0,
+ 0x6c7d,
+ 0x4038,
+ {0xb5, 0xfa, 0x4d, 0x87, 0x16, 0xd5, 0xcc, 0x4e}};
+
+/* This class gets its lifetime tied to a D3D texture
+ * and increments memory usage on construction and decrements
+ * on destruction */
+class TextureMemoryMeasurer final : public IUnknown {
+ public:
+ explicit TextureMemoryMeasurer(size_t aMemoryUsed) {
+ mMemoryUsed = aMemoryUsed;
+ gfxWindowsPlatform::sD3D11SharedTextures += mMemoryUsed;
+ mRefCnt = 0;
+ }
+ STDMETHODIMP_(ULONG) AddRef() {
+ mRefCnt++;
+ return mRefCnt;
+ }
+ STDMETHODIMP QueryInterface(REFIID riid, void** ppvObject) {
+ IUnknown* punk = nullptr;
+ if (riid == IID_IUnknown) {
+ punk = this;
+ }
+ *ppvObject = punk;
+ if (punk) {
+ punk->AddRef();
+ return S_OK;
+ } else {
+ return E_NOINTERFACE;
+ }
+ }
+
+ STDMETHODIMP_(ULONG) Release() {
+ int refCnt = --mRefCnt;
+ if (refCnt == 0) {
+ gfxWindowsPlatform::sD3D11SharedTextures -= mMemoryUsed;
+ delete this;
+ }
+ return refCnt;
+ }
+
+ private:
+ int mRefCnt;
+ int mMemoryUsed;
+
+ ~TextureMemoryMeasurer() = default;
+};
+
+static DXGI_FORMAT SurfaceFormatToDXGIFormat(gfx::SurfaceFormat aFormat) {
+ switch (aFormat) {
+ case SurfaceFormat::B8G8R8A8:
+ return DXGI_FORMAT_B8G8R8A8_UNORM;
+ case SurfaceFormat::B8G8R8X8:
+ return DXGI_FORMAT_B8G8R8A8_UNORM;
+ case SurfaceFormat::R8G8B8A8:
+ return DXGI_FORMAT_R8G8B8A8_UNORM;
+ case SurfaceFormat::R8G8B8X8:
+ return DXGI_FORMAT_R8G8B8A8_UNORM;
+ case SurfaceFormat::A8:
+ return DXGI_FORMAT_R8_UNORM;
+ case SurfaceFormat::A16:
+ return DXGI_FORMAT_R16_UNORM;
+ default:
+ MOZ_ASSERT(false, "unsupported format");
+ return DXGI_FORMAT_UNKNOWN;
+ }
+}
+
+void ReportTextureMemoryUsage(ID3D11Texture2D* aTexture, size_t aBytes) {
+ aTexture->SetPrivateDataInterface(sD3D11TextureUsage,
+ new TextureMemoryMeasurer(aBytes));
+}
+
+static uint32_t GetRequiredTilesD3D11(uint32_t aSize, uint32_t aMaxSize) {
+ uint32_t requiredTiles = aSize / aMaxSize;
+ if (aSize % aMaxSize) {
+ requiredTiles++;
+ }
+ return requiredTiles;
+}
+
+static IntRect GetTileRectD3D11(uint32_t aID, IntSize aSize,
+ uint32_t aMaxSize) {
+ uint32_t horizontalTiles = GetRequiredTilesD3D11(aSize.width, aMaxSize);
+ uint32_t verticalTiles = GetRequiredTilesD3D11(aSize.height, aMaxSize);
+
+ uint32_t verticalTile = aID / horizontalTiles;
+ uint32_t horizontalTile = aID % horizontalTiles;
+
+ return IntRect(
+ horizontalTile * aMaxSize, verticalTile * aMaxSize,
+ horizontalTile < (horizontalTiles - 1) ? aMaxSize
+ : aSize.width % aMaxSize,
+ verticalTile < (verticalTiles - 1) ? aMaxSize : aSize.height % aMaxSize);
+}
+
+AutoTextureLock::AutoTextureLock(IDXGIKeyedMutex* aMutex, HRESULT& aResult,
+ uint32_t aTimeout) {
+ mMutex = aMutex;
+ if (mMutex) {
+ mResult = mMutex->AcquireSync(0, aTimeout);
+ aResult = mResult;
+ } else {
+ aResult = E_INVALIDARG;
+ }
+}
+
+AutoTextureLock::~AutoTextureLock() {
+ if (mMutex && !FAILED(mResult) && mResult != WAIT_TIMEOUT &&
+ mResult != WAIT_ABANDONED) {
+ mMutex->ReleaseSync(0);
+ }
+}
+
+ID3D11ShaderResourceView* TextureSourceD3D11::GetShaderResourceView() {
+ MOZ_ASSERT(mTexture == GetD3D11Texture(),
+ "You need to override GetShaderResourceView if you're overriding "
+ "GetD3D11Texture!");
+
+ if (!mSRV && mTexture) {
+ RefPtr<ID3D11Device> device;
+ mTexture->GetDevice(getter_AddRefs(device));
+
+ // see comment in CompositingRenderTargetD3D11 constructor
+ CD3D11_SHADER_RESOURCE_VIEW_DESC srvDesc(D3D11_SRV_DIMENSION_TEXTURE2D,
+ mFormatOverride);
+ D3D11_SHADER_RESOURCE_VIEW_DESC* desc =
+ mFormatOverride == DXGI_FORMAT_UNKNOWN ? nullptr : &srvDesc;
+
+ HRESULT hr =
+ device->CreateShaderResourceView(mTexture, desc, getter_AddRefs(mSRV));
+ if (FAILED(hr)) {
+ gfxCriticalNote << "[D3D11] TextureSourceD3D11:GetShaderResourceView "
+ "CreateSRV failure "
+ << gfx::hexa(hr);
+ return nullptr;
+ }
+ }
+ return mSRV;
+}
+
+DataTextureSourceD3D11::DataTextureSourceD3D11(ID3D11Device* aDevice,
+ SurfaceFormat aFormat,
+ TextureFlags aFlags)
+ : mDevice(aDevice),
+ mFormat(aFormat),
+ mFlags(aFlags),
+ mCurrentTile(0),
+ mIsTiled(false),
+ mIterating(false),
+ mAllowTextureUploads(true) {}
+
+DataTextureSourceD3D11::DataTextureSourceD3D11(ID3D11Device* aDevice,
+ SurfaceFormat aFormat,
+ ID3D11Texture2D* aTexture)
+ : mDevice(aDevice),
+ mFormat(aFormat),
+ mFlags(TextureFlags::NO_FLAGS),
+ mCurrentTile(0),
+ mIsTiled(false),
+ mIterating(false),
+ mAllowTextureUploads(false) {
+ mTexture = aTexture;
+ D3D11_TEXTURE2D_DESC desc;
+ aTexture->GetDesc(&desc);
+
+ mSize = IntSize(desc.Width, desc.Height);
+}
+
+DataTextureSourceD3D11::DataTextureSourceD3D11(gfx::SurfaceFormat aFormat,
+ TextureSourceProvider* aProvider,
+ ID3D11Texture2D* aTexture)
+ : DataTextureSourceD3D11(aProvider->GetD3D11Device(), aFormat, aTexture) {}
+
+DataTextureSourceD3D11::DataTextureSourceD3D11(gfx::SurfaceFormat aFormat,
+ TextureSourceProvider* aProvider,
+ TextureFlags aFlags)
+ : DataTextureSourceD3D11(aProvider->GetD3D11Device(), aFormat, aFlags) {}
+
+DataTextureSourceD3D11::~DataTextureSourceD3D11() {}
+
+enum class SerializeWithMoz2D : bool { No, Yes };
+
+template <typename T> // ID3D10Texture2D or ID3D11Texture2D
+static bool LockD3DTexture(
+ T* aTexture, SerializeWithMoz2D aSerialize = SerializeWithMoz2D::No) {
+ MOZ_ASSERT(aTexture);
+ RefPtr<IDXGIKeyedMutex> mutex;
+ aTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mutex));
+ // Textures created by the DXVA decoders don't have a mutex for
+ // synchronization
+ if (mutex) {
+ HRESULT hr;
+ if (aSerialize == SerializeWithMoz2D::Yes) {
+ AutoSerializeWithMoz2D serializeWithMoz2D(BackendType::DIRECT2D1_1);
+ hr = mutex->AcquireSync(0, 10000);
+ } else {
+ hr = mutex->AcquireSync(0, 10000);
+ }
+ if (hr == WAIT_TIMEOUT) {
+ RefPtr<ID3D11Device> device;
+ aTexture->GetDevice(getter_AddRefs(device));
+ if (!device) {
+ gfxCriticalNote << "GFX: D3D11 lock mutex timeout - no device returned";
+ } else if (device->GetDeviceRemovedReason() != S_OK) {
+ gfxCriticalNote << "GFX: D3D11 lock mutex timeout - device removed";
+ } else {
+ gfxDevCrash(LogReason::D3DLockTimeout)
+ << "D3D lock mutex timeout - device not removed";
+ }
+ } else if (hr == WAIT_ABANDONED) {
+ gfxCriticalNote << "GFX: D3D11 lock mutex abandoned";
+ }
+
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to lock the texture");
+ return false;
+ }
+ }
+ return true;
+}
+
+template <typename T>
+static bool HasKeyedMutex(T* aTexture) {
+ MOZ_ASSERT(aTexture);
+ RefPtr<IDXGIKeyedMutex> mutex;
+ aTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mutex));
+ return !!mutex;
+}
+
+template <typename T> // ID3D10Texture2D or ID3D11Texture2D
+static void UnlockD3DTexture(
+ T* aTexture, SerializeWithMoz2D aSerialize = SerializeWithMoz2D::No) {
+ MOZ_ASSERT(aTexture);
+ RefPtr<IDXGIKeyedMutex> mutex;
+ aTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mutex));
+ if (mutex) {
+ HRESULT hr;
+ if (aSerialize == SerializeWithMoz2D::Yes) {
+ AutoSerializeWithMoz2D serializeWithMoz2D(BackendType::DIRECT2D1_1);
+ hr = mutex->ReleaseSync(0);
+ } else {
+ hr = mutex->ReleaseSync(0);
+ }
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to unlock the texture");
+ }
+ }
+}
+
+D3D11TextureData::D3D11TextureData(ID3D11Texture2D* aTexture,
+ uint32_t aArrayIndex, gfx::IntSize aSize,
+ gfx::SurfaceFormat aFormat,
+ TextureAllocationFlags aFlags)
+ : mSize(aSize),
+ mFormat(aFormat),
+ mNeedsClear(aFlags & ALLOC_CLEAR_BUFFER),
+ mHasSynchronization(HasKeyedMutex(aTexture)),
+ mTexture(aTexture),
+ mArrayIndex(aArrayIndex),
+ mAllocationFlags(aFlags) {
+ MOZ_ASSERT(aTexture);
+}
+
+static void DestroyDrawTarget(RefPtr<DrawTarget>& aDT,
+ RefPtr<ID3D11Texture2D>& aTexture) {
+ // An Azure DrawTarget needs to be locked when it gets nullptr'ed as this is
+ // when it calls EndDraw. This EndDraw should not execute anything so it
+ // shouldn't -really- need the lock but the debug layer chokes on this.
+ LockD3DTexture(aTexture.get(), SerializeWithMoz2D::Yes);
+ aDT = nullptr;
+
+ // Do the serialization here, so we can hold it while destroying the texture.
+ AutoSerializeWithMoz2D serializeWithMoz2D(BackendType::DIRECT2D1_1);
+ UnlockD3DTexture(aTexture.get(), SerializeWithMoz2D::No);
+ aTexture = nullptr;
+}
+
+D3D11TextureData::~D3D11TextureData() {
+ if (mDrawTarget) {
+ DestroyDrawTarget(mDrawTarget, mTexture);
+ }
+
+ if (mGpuProcessTextureId.isSome()) {
+ auto* textureMap = GpuProcessD3D11TextureMap::Get();
+ if (textureMap) {
+ textureMap->Unregister(mGpuProcessTextureId.ref());
+ } else {
+ gfxCriticalNoteOnce << "GpuProcessD3D11TextureMap does not exist";
+ }
+ }
+}
+
+bool D3D11TextureData::Lock(OpenMode aMode) {
+ if (!LockD3DTexture(mTexture.get(), SerializeWithMoz2D::Yes)) {
+ return false;
+ }
+
+ if (NS_IsMainThread()) {
+ if (!PrepareDrawTargetInLock(aMode)) {
+ Unlock();
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool D3D11TextureData::PrepareDrawTargetInLock(OpenMode aMode) {
+ // Make sure that successful write-lock means we will have a DrawTarget to
+ // write into.
+ if (!mDrawTarget && (aMode & OpenMode::OPEN_WRITE || mNeedsClear)) {
+ mDrawTarget = BorrowDrawTarget();
+ if (!mDrawTarget) {
+ return false;
+ }
+ }
+
+ // Reset transform
+ mDrawTarget->SetTransform(Matrix());
+
+ if (mNeedsClear) {
+ mDrawTarget->ClearRect(Rect(0, 0, mSize.width, mSize.height));
+ mNeedsClear = false;
+ }
+
+ return true;
+}
+
+void D3D11TextureData::Unlock() {
+ UnlockD3DTexture(mTexture.get(), SerializeWithMoz2D::Yes);
+}
+
+void D3D11TextureData::FillInfo(TextureData::Info& aInfo) const {
+ aInfo.size = mSize;
+ aInfo.format = mFormat;
+ aInfo.supportsMoz2D = true;
+ aInfo.hasSynchronization = mHasSynchronization;
+}
+
+void D3D11TextureData::SyncWithObject(RefPtr<SyncObjectClient> aSyncObject) {
+ if (!aSyncObject || mHasSynchronization) {
+ // When we have per texture synchronization we sync using the keyed mutex.
+ return;
+ }
+
+ MOZ_ASSERT(aSyncObject->GetSyncType() == SyncObjectClient::SyncType::D3D11);
+ SyncObjectD3D11Client* sync =
+ static_cast<SyncObjectD3D11Client*>(aSyncObject.get());
+ sync->RegisterTexture(mTexture);
+}
+
+bool D3D11TextureData::SerializeSpecific(
+ SurfaceDescriptorD3D10* const aOutDesc) {
+ RefPtr<IDXGIResource> resource;
+ GetDXGIResource((IDXGIResource**)getter_AddRefs(resource));
+ if (!resource) {
+ return false;
+ }
+ HANDLE sharedHandle = 0;
+ if (mGpuProcessTextureId.isNothing()) {
+ HRESULT hr = resource->GetSharedHandle(&sharedHandle);
+ if (FAILED(hr)) {
+ LOGD3D11("Error getting shared handle for texture.");
+ return false;
+ }
+ }
+ *aOutDesc = SurfaceDescriptorD3D10((WindowsHandle)sharedHandle,
+ mGpuProcessTextureId, mArrayIndex, mFormat,
+ mSize, mColorSpace, mColorRange);
+ return true;
+}
+
+bool D3D11TextureData::Serialize(SurfaceDescriptor& aOutDescriptor) {
+ SurfaceDescriptorD3D10 desc;
+ if (!SerializeSpecific(&desc)) return false;
+
+ aOutDescriptor = std::move(desc);
+ return true;
+}
+
+void D3D11TextureData::GetSubDescriptor(
+ RemoteDecoderVideoSubDescriptor* const aOutDesc) {
+ SurfaceDescriptorD3D10 ret;
+ if (!SerializeSpecific(&ret)) return;
+
+ *aOutDesc = std::move(ret);
+}
+
+/* static */
+already_AddRefed<TextureClient> D3D11TextureData::CreateTextureClient(
+ ID3D11Texture2D* aTexture, uint32_t aIndex, gfx::IntSize aSize,
+ gfx::SurfaceFormat aFormat, gfx::ColorSpace2 aColorSpace,
+ gfx::ColorRange aColorRange, KnowsCompositor* aKnowsCompositor,
+ RefPtr<IMFSampleUsageInfo> aUsageInfo) {
+ D3D11TextureData* data = new D3D11TextureData(
+ aTexture, aIndex, aSize, aFormat,
+ TextureAllocationFlags::ALLOC_MANUAL_SYNCHRONIZATION);
+ data->mColorSpace = aColorSpace;
+ data->SetColorRange(aColorRange);
+
+ RefPtr<TextureClient> textureClient = MakeAndAddRef<TextureClient>(
+ data, TextureFlags::NO_FLAGS, aKnowsCompositor->GetTextureForwarder());
+ const auto textureId = GpuProcessD3D11TextureMap::GetNextTextureId();
+ data->SetGpuProcessTextureId(textureId);
+
+ // Register ID3D11Texture2D to GpuProcessD3D11TextureMap
+ auto* textureMap = GpuProcessD3D11TextureMap::Get();
+ if (textureMap) {
+ textureMap->Register(textureId, aTexture, aIndex, aSize, aUsageInfo);
+ } else {
+ gfxCriticalNoteOnce << "GpuProcessD3D11TextureMap does not exist";
+ }
+
+ return textureClient.forget();
+}
+
+D3D11TextureData* D3D11TextureData::Create(IntSize aSize, SurfaceFormat aFormat,
+ TextureAllocationFlags aFlags,
+ ID3D11Device* aDevice) {
+ return Create(aSize, aFormat, nullptr, aFlags, aDevice);
+}
+
+D3D11TextureData* D3D11TextureData::Create(SourceSurface* aSurface,
+ TextureAllocationFlags aFlags,
+ ID3D11Device* aDevice) {
+ return Create(aSurface->GetSize(), aSurface->GetFormat(), aSurface, aFlags,
+ aDevice);
+}
+
+D3D11TextureData* D3D11TextureData::Create(IntSize aSize, SurfaceFormat aFormat,
+ SourceSurface* aSurface,
+ TextureAllocationFlags aFlags,
+ ID3D11Device* aDevice) {
+ if (aFormat == SurfaceFormat::A8) {
+ // Currently we don't support A8 surfaces. Fallback.
+ return nullptr;
+ }
+
+ // Just grab any device. We never use the immediate context, so the devices
+ // are fine to use from any thread.
+ RefPtr<ID3D11Device> device = aDevice;
+ if (!device) {
+ device = DeviceManagerDx::Get()->GetContentDevice();
+ if (!device) {
+ return nullptr;
+ }
+ }
+
+ CD3D11_TEXTURE2D_DESC newDesc(
+ DXGI_FORMAT_B8G8R8A8_UNORM, aSize.width, aSize.height, 1, 1,
+ D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+
+ if (aFormat == SurfaceFormat::NV12) {
+ newDesc.Format = DXGI_FORMAT_NV12;
+ } else if (aFormat == SurfaceFormat::P010) {
+ newDesc.Format = DXGI_FORMAT_P010;
+ } else if (aFormat == SurfaceFormat::P016) {
+ newDesc.Format = DXGI_FORMAT_P016;
+ }
+
+ newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
+ if (!NS_IsMainThread()) {
+ // On the main thread we use the syncobject to handle synchronization.
+ if (!(aFlags & ALLOC_MANUAL_SYNCHRONIZATION)) {
+ newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
+ }
+ }
+
+ if (aSurface && newDesc.MiscFlags == D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX &&
+ !DeviceManagerDx::Get()->CanInitializeKeyedMutexTextures()) {
+ return nullptr;
+ }
+
+ D3D11_SUBRESOURCE_DATA uploadData;
+ D3D11_SUBRESOURCE_DATA* uploadDataPtr = nullptr;
+ RefPtr<DataSourceSurface> srcSurf;
+ DataSourceSurface::MappedSurface sourceMap;
+
+ if (aSurface) {
+ srcSurf = aSurface->GetDataSurface();
+
+ if (!srcSurf) {
+ gfxCriticalError()
+ << "Failed to GetDataSurface in D3D11TextureData::Create";
+ return nullptr;
+ }
+
+ if (!srcSurf->Map(DataSourceSurface::READ, &sourceMap)) {
+ gfxCriticalError()
+ << "Failed to map source surface for D3D11TextureData::Create";
+ return nullptr;
+ }
+ }
+
+ if (srcSurf && !DeviceManagerDx::Get()->HasCrashyInitData()) {
+ uploadData.pSysMem = sourceMap.mData;
+ uploadData.SysMemPitch = sourceMap.mStride;
+ uploadData.SysMemSlicePitch = 0; // unused
+
+ uploadDataPtr = &uploadData;
+ }
+
+ // See bug 1397040
+ RefPtr<ID3D10Multithread> mt;
+ device->QueryInterface((ID3D10Multithread**)getter_AddRefs(mt));
+
+ RefPtr<ID3D11Texture2D> texture11;
+
+ {
+ AutoSerializeWithMoz2D serializeWithMoz2D(BackendType::DIRECT2D1_1);
+ D3D11MTAutoEnter lock(mt.forget());
+
+ HRESULT hr = device->CreateTexture2D(&newDesc, uploadDataPtr,
+ getter_AddRefs(texture11));
+
+ if (FAILED(hr) || !texture11) {
+ gfxCriticalNote << "[D3D11] 2 CreateTexture2D failure Size: " << aSize
+ << "texture11: " << texture11
+ << " Code: " << gfx::hexa(hr);
+ return nullptr;
+ }
+
+ if (srcSurf && DeviceManagerDx::Get()->HasCrashyInitData()) {
+ D3D11_BOX box;
+ box.front = box.top = box.left = 0;
+ box.back = 1;
+ box.right = aSize.width;
+ box.bottom = aSize.height;
+ RefPtr<ID3D11DeviceContext> ctx;
+ device->GetImmediateContext(getter_AddRefs(ctx));
+ ctx->UpdateSubresource(texture11, 0, &box, sourceMap.mData,
+ sourceMap.mStride, 0);
+ }
+ }
+
+ if (srcSurf) {
+ srcSurf->Unmap();
+ }
+
+ // If we created the texture with a keyed mutex, then we expect all operations
+ // on it to be synchronized using it. If we did an initial upload using
+ // aSurface then bizarely this isn't covered, so we insert a manual
+ // lock/unlock pair to force this.
+ if (aSurface && newDesc.MiscFlags == D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) {
+ if (!LockD3DTexture(texture11.get(), SerializeWithMoz2D::Yes)) {
+ return nullptr;
+ }
+ UnlockD3DTexture(texture11.get(), SerializeWithMoz2D::Yes);
+ }
+ texture11->SetPrivateDataInterface(
+ sD3D11TextureUsage,
+ new TextureMemoryMeasurer(newDesc.Width * newDesc.Height * 4));
+ return new D3D11TextureData(texture11, 0, aSize, aFormat, aFlags);
+}
+
+void D3D11TextureData::Deallocate(LayersIPCChannel* aAllocator) {
+ mDrawTarget = nullptr;
+ mTexture = nullptr;
+}
+
+TextureData* D3D11TextureData::CreateSimilar(
+ LayersIPCChannel* aAllocator, LayersBackend aLayersBackend,
+ TextureFlags aFlags, TextureAllocationFlags aAllocFlags) const {
+ return D3D11TextureData::Create(mSize, mFormat, aAllocFlags);
+}
+
+void D3D11TextureData::GetDXGIResource(IDXGIResource** aOutResource) {
+ mTexture->QueryInterface(aOutResource);
+}
+
+TextureFlags D3D11TextureData::GetTextureFlags() const {
+ // With WebRender, resource open happens asynchronously on RenderThread.
+ // During opening the resource on host side, TextureClient needs to be alive.
+ // With WAIT_HOST_USAGE_END, keep TextureClient alive during host side usage.
+ return TextureFlags::WAIT_HOST_USAGE_END;
+}
+
+DXGIYCbCrTextureData* DXGIYCbCrTextureData::Create(
+ IDirect3DTexture9* aTextureY, IDirect3DTexture9* aTextureCb,
+ IDirect3DTexture9* aTextureCr, HANDLE aHandleY, HANDLE aHandleCb,
+ HANDLE aHandleCr, const gfx::IntSize& aSize, const gfx::IntSize& aSizeY,
+ const gfx::IntSize& aSizeCbCr, gfx::ColorDepth aColorDepth,
+ YUVColorSpace aYUVColorSpace, gfx::ColorRange aColorRange) {
+ if (!aHandleY || !aHandleCb || !aHandleCr || !aTextureY || !aTextureCb ||
+ !aTextureCr) {
+ return nullptr;
+ }
+
+ DXGIYCbCrTextureData* texture = new DXGIYCbCrTextureData();
+ texture->mHandles[0] = aHandleY;
+ texture->mHandles[1] = aHandleCb;
+ texture->mHandles[2] = aHandleCr;
+ texture->mD3D9Textures[0] = aTextureY;
+ texture->mD3D9Textures[1] = aTextureCb;
+ texture->mD3D9Textures[2] = aTextureCr;
+ texture->mSize = aSize;
+ texture->mSizeY = aSizeY;
+ texture->mSizeCbCr = aSizeCbCr;
+ texture->mColorDepth = aColorDepth;
+ texture->mYUVColorSpace = aYUVColorSpace;
+ texture->mColorRange = aColorRange;
+
+ return texture;
+}
+
+DXGIYCbCrTextureData* DXGIYCbCrTextureData::Create(
+ ID3D11Texture2D* aTextureY, ID3D11Texture2D* aTextureCb,
+ ID3D11Texture2D* aTextureCr, const gfx::IntSize& aSize,
+ const gfx::IntSize& aSizeY, const gfx::IntSize& aSizeCbCr,
+ gfx::ColorDepth aColorDepth, YUVColorSpace aYUVColorSpace,
+ gfx::ColorRange aColorRange) {
+ if (!aTextureY || !aTextureCb || !aTextureCr) {
+ return nullptr;
+ }
+
+ aTextureY->SetPrivateDataInterface(
+ sD3D11TextureUsage,
+ new TextureMemoryMeasurer(aSizeY.width * aSizeY.height));
+ aTextureCb->SetPrivateDataInterface(
+ sD3D11TextureUsage,
+ new TextureMemoryMeasurer(aSizeCbCr.width * aSizeCbCr.height));
+ aTextureCr->SetPrivateDataInterface(
+ sD3D11TextureUsage,
+ new TextureMemoryMeasurer(aSizeCbCr.width * aSizeCbCr.height));
+
+ RefPtr<IDXGIResource> resource;
+
+ aTextureY->QueryInterface((IDXGIResource**)getter_AddRefs(resource));
+
+ HANDLE handleY;
+ HRESULT hr = resource->GetSharedHandle(&handleY);
+ if (FAILED(hr)) {
+ return nullptr;
+ }
+
+ aTextureCb->QueryInterface((IDXGIResource**)getter_AddRefs(resource));
+
+ HANDLE handleCb;
+ hr = resource->GetSharedHandle(&handleCb);
+ if (FAILED(hr)) {
+ return nullptr;
+ }
+
+ aTextureCr->QueryInterface((IDXGIResource**)getter_AddRefs(resource));
+ HANDLE handleCr;
+ hr = resource->GetSharedHandle(&handleCr);
+ if (FAILED(hr)) {
+ return nullptr;
+ }
+
+ DXGIYCbCrTextureData* texture = new DXGIYCbCrTextureData();
+ texture->mHandles[0] = handleY;
+ texture->mHandles[1] = handleCb;
+ texture->mHandles[2] = handleCr;
+ texture->mD3D11Textures[0] = aTextureY;
+ texture->mD3D11Textures[1] = aTextureCb;
+ texture->mD3D11Textures[2] = aTextureCr;
+ texture->mSize = aSize;
+ texture->mSizeY = aSizeY;
+ texture->mSizeCbCr = aSizeCbCr;
+ texture->mColorDepth = aColorDepth;
+ texture->mYUVColorSpace = aYUVColorSpace;
+ texture->mColorRange = aColorRange;
+
+ return texture;
+}
+
+void DXGIYCbCrTextureData::FillInfo(TextureData::Info& aInfo) const {
+ aInfo.size = mSize;
+ aInfo.format = gfx::SurfaceFormat::YUV;
+ aInfo.supportsMoz2D = false;
+ aInfo.hasSynchronization = false;
+}
+
+void DXGIYCbCrTextureData::SerializeSpecific(
+ SurfaceDescriptorDXGIYCbCr* const aOutDesc) {
+ *aOutDesc = SurfaceDescriptorDXGIYCbCr(
+ (WindowsHandle)mHandles[0], (WindowsHandle)mHandles[1],
+ (WindowsHandle)mHandles[2], mSize, mSizeY, mSizeCbCr, mColorDepth,
+ mYUVColorSpace, mColorRange);
+}
+
+bool DXGIYCbCrTextureData::Serialize(SurfaceDescriptor& aOutDescriptor) {
+ SurfaceDescriptorDXGIYCbCr desc;
+ SerializeSpecific(&desc);
+
+ aOutDescriptor = std::move(desc);
+ return true;
+}
+
+void DXGIYCbCrTextureData::GetSubDescriptor(
+ RemoteDecoderVideoSubDescriptor* const aOutDesc) {
+ SurfaceDescriptorDXGIYCbCr desc;
+ SerializeSpecific(&desc);
+
+ *aOutDesc = std::move(desc);
+}
+
+void DXGIYCbCrTextureData::Deallocate(LayersIPCChannel*) {
+ mD3D9Textures[0] = nullptr;
+ mD3D9Textures[1] = nullptr;
+ mD3D9Textures[2] = nullptr;
+ mD3D11Textures[0] = nullptr;
+ mD3D11Textures[1] = nullptr;
+ mD3D11Textures[2] = nullptr;
+}
+
+TextureFlags DXGIYCbCrTextureData::GetTextureFlags() const {
+ // With WebRender, resource open happens asynchronously on RenderThread.
+ // During opening the resource on host side, TextureClient needs to be alive.
+ // With WAIT_HOST_USAGE_END, keep TextureClient alive during host side usage.
+ return TextureFlags::WAIT_HOST_USAGE_END;
+}
+
+already_AddRefed<TextureHost> CreateTextureHostD3D11(
+ const SurfaceDescriptor& aDesc, ISurfaceAllocator* aDeallocator,
+ LayersBackend aBackend, TextureFlags aFlags) {
+ RefPtr<TextureHost> result;
+ switch (aDesc.type()) {
+ case SurfaceDescriptor::TSurfaceDescriptorD3D10: {
+ result =
+ new DXGITextureHostD3D11(aFlags, aDesc.get_SurfaceDescriptorD3D10());
+ break;
+ }
+ case SurfaceDescriptor::TSurfaceDescriptorDXGIYCbCr: {
+ result = new DXGIYCbCrTextureHostD3D11(
+ aFlags, aDesc.get_SurfaceDescriptorDXGIYCbCr());
+ break;
+ }
+ default: {
+ MOZ_ASSERT_UNREACHABLE("Unsupported SurfaceDescriptor type");
+ }
+ }
+ return result.forget();
+}
+
+already_AddRefed<DrawTarget> D3D11TextureData::BorrowDrawTarget() {
+ MOZ_ASSERT(NS_IsMainThread() || NS_IsInCanvasThreadOrWorker());
+
+ if (!mDrawTarget && mTexture) {
+ // This may return a null DrawTarget
+ mDrawTarget = Factory::CreateDrawTargetForD3D11Texture(mTexture, mFormat);
+ if (!mDrawTarget) {
+ gfxCriticalNote << "Could not borrow DrawTarget (D3D11) " << (int)mFormat;
+ }
+ }
+
+ RefPtr<DrawTarget> result = mDrawTarget;
+ return result.forget();
+}
+
+bool D3D11TextureData::UpdateFromSurface(gfx::SourceSurface* aSurface) {
+ // Supporting texture updates after creation requires an ID3D11DeviceContext
+ // and those aren't threadsafe. We'd need to either lock, or have a device for
+ // whatever thread this runs on and we're trying to avoid extra devices (bug
+ // 1284672).
+ MOZ_ASSERT(false,
+ "UpdateFromSurface not supported for D3D11! Use CreateFromSurface "
+ "instead");
+ return false;
+}
+
+DXGITextureHostD3D11::DXGITextureHostD3D11(
+ TextureFlags aFlags, const SurfaceDescriptorD3D10& aDescriptor)
+ : TextureHost(TextureHostType::DXGI, aFlags),
+ mGpuProcessTextureId(aDescriptor.gpuProcessTextureId()),
+ mArrayIndex(aDescriptor.arrayIndex()),
+ mSize(aDescriptor.size()),
+ mHandle(aDescriptor.handle()),
+ mFormat(aDescriptor.format()),
+ mColorSpace(aDescriptor.colorSpace()),
+ mColorRange(aDescriptor.colorRange()),
+ mIsLocked(false) {}
+
+bool DXGITextureHostD3D11::EnsureTexture() {
+ if (mGpuProcessTextureId.isSome()) {
+ return false;
+ }
+
+ RefPtr<ID3D11Device> device;
+ if (mTexture) {
+ mTexture->GetDevice(getter_AddRefs(device));
+ if (device == DeviceManagerDx::Get()->GetCompositorDevice()) {
+ NS_WARNING("Incompatible texture.");
+ return true;
+ }
+ mTexture = nullptr;
+ }
+
+ device = GetDevice();
+ if (!device || device != DeviceManagerDx::Get()->GetCompositorDevice()) {
+ NS_WARNING("No device or incompatible device.");
+ return false;
+ }
+
+ HRESULT hr = device->OpenSharedResource(
+ (HANDLE)mHandle, __uuidof(ID3D11Texture2D),
+ (void**)(ID3D11Texture2D**)getter_AddRefs(mTexture));
+ if (FAILED(hr)) {
+ MOZ_ASSERT(false, "Failed to open shared texture");
+ return false;
+ }
+
+ D3D11_TEXTURE2D_DESC desc;
+ mTexture->GetDesc(&desc);
+ mSize = IntSize(desc.Width, desc.Height);
+ return true;
+}
+
+RefPtr<ID3D11Device> DXGITextureHostD3D11::GetDevice() {
+ if (mFlags & TextureFlags::INVALID_COMPOSITOR) {
+ return nullptr;
+ }
+
+ return mDevice;
+}
+
+bool DXGITextureHostD3D11::LockWithoutCompositor() {
+ if (!mDevice) {
+ mDevice = DeviceManagerDx::Get()->GetCompositorDevice();
+ }
+ return LockInternal();
+}
+
+void DXGITextureHostD3D11::UnlockWithoutCompositor() { UnlockInternal(); }
+
+bool DXGITextureHostD3D11::LockInternal() {
+ if (!GetDevice()) {
+ NS_WARNING("trying to lock a TextureHost without a D3D device");
+ return false;
+ }
+
+ if (!EnsureTextureSource()) {
+ return false;
+ }
+
+ mIsLocked = LockD3DTexture(mTextureSource->GetD3D11Texture());
+
+ return mIsLocked;
+}
+
+already_AddRefed<gfx::DataSourceSurface> DXGITextureHostD3D11::GetAsSurface() {
+ switch (GetFormat()) {
+ case gfx::SurfaceFormat::R8G8B8X8:
+ case gfx::SurfaceFormat::R8G8B8A8:
+ case gfx::SurfaceFormat::B8G8R8A8:
+ case gfx::SurfaceFormat::B8G8R8X8:
+ break;
+ default: {
+ MOZ_ASSERT_UNREACHABLE("DXGITextureHostD3D11: unsupported format!");
+ return nullptr;
+ }
+ }
+
+ AutoLockTextureHostWithoutCompositor autoLock(this);
+ if (autoLock.Failed()) {
+ NS_WARNING("Failed to lock the D3DTexture");
+ return nullptr;
+ }
+
+ RefPtr<ID3D11Device> device;
+ mTexture->GetDevice(getter_AddRefs(device));
+
+ D3D11_TEXTURE2D_DESC textureDesc = {0};
+ mTexture->GetDesc(&textureDesc);
+
+ RefPtr<ID3D11DeviceContext> context;
+ device->GetImmediateContext(getter_AddRefs(context));
+
+ textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+ textureDesc.Usage = D3D11_USAGE_STAGING;
+ textureDesc.BindFlags = 0;
+ textureDesc.MiscFlags = 0;
+ textureDesc.MipLevels = 1;
+ RefPtr<ID3D11Texture2D> cpuTexture;
+ HRESULT hr = device->CreateTexture2D(&textureDesc, nullptr,
+ getter_AddRefs(cpuTexture));
+ if (FAILED(hr)) {
+ return nullptr;
+ }
+
+ context->CopyResource(cpuTexture, mTexture);
+
+ D3D11_MAPPED_SUBRESOURCE mappedSubresource;
+ hr = context->Map(cpuTexture, 0, D3D11_MAP_READ, 0, &mappedSubresource);
+ if (FAILED(hr)) {
+ return nullptr;
+ }
+
+ RefPtr<DataSourceSurface> surf = gfx::CreateDataSourceSurfaceFromData(
+ IntSize(textureDesc.Width, textureDesc.Height), GetFormat(),
+ (uint8_t*)mappedSubresource.pData, mappedSubresource.RowPitch);
+ context->Unmap(cpuTexture, 0);
+ return surf.forget();
+}
+
+bool DXGITextureHostD3D11::EnsureTextureSource() {
+ if (mTextureSource) {
+ return true;
+ }
+
+ if (!EnsureTexture()) {
+ DeviceManagerDx::Get()->ForceDeviceReset(
+ ForcedDeviceResetReason::OPENSHAREDHANDLE);
+ return false;
+ }
+
+ mTextureSource = new DataTextureSourceD3D11(mDevice, mFormat, mTexture);
+ return true;
+}
+
+void DXGITextureHostD3D11::UnlockInternal() {
+ UnlockD3DTexture(mTextureSource->GetD3D11Texture());
+}
+
+void DXGITextureHostD3D11::CreateRenderTexture(
+ const wr::ExternalImageId& aExternalImageId) {
+ RefPtr<wr::RenderTextureHost> texture =
+ new wr::RenderDXGITextureHost(mHandle, mGpuProcessTextureId, mArrayIndex,
+ mFormat, mColorSpace, mColorRange, mSize);
+ wr::RenderThread::Get()->RegisterExternalImage(aExternalImageId,
+ texture.forget());
+}
+
+uint32_t DXGITextureHostD3D11::NumSubTextures() {
+ switch (GetFormat()) {
+ case gfx::SurfaceFormat::R8G8B8X8:
+ case gfx::SurfaceFormat::R8G8B8A8:
+ case gfx::SurfaceFormat::B8G8R8A8:
+ case gfx::SurfaceFormat::B8G8R8X8: {
+ return 1;
+ }
+ case gfx::SurfaceFormat::NV12:
+ case gfx::SurfaceFormat::P010:
+ case gfx::SurfaceFormat::P016: {
+ return 2;
+ }
+ default: {
+ MOZ_ASSERT_UNREACHABLE("unexpected format");
+ return 1;
+ }
+ }
+}
+
+void DXGITextureHostD3D11::PushResourceUpdates(
+ wr::TransactionBuilder& aResources, ResourceUpdateOp aOp,
+ const Range<wr::ImageKey>& aImageKeys, const wr::ExternalImageId& aExtID) {
+ if (!gfx::gfxVars::UseWebRenderANGLE()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called without ANGLE");
+ return;
+ }
+
+ MOZ_ASSERT(mHandle || mGpuProcessTextureId.isSome());
+ auto method = aOp == TextureHost::ADD_IMAGE
+ ? &wr::TransactionBuilder::AddExternalImage
+ : &wr::TransactionBuilder::UpdateExternalImage;
+ switch (mFormat) {
+ case gfx::SurfaceFormat::R8G8B8X8:
+ case gfx::SurfaceFormat::R8G8B8A8:
+ case gfx::SurfaceFormat::B8G8R8A8:
+ case gfx::SurfaceFormat::B8G8R8X8: {
+ MOZ_ASSERT(aImageKeys.length() == 1);
+
+ wr::ImageDescriptor descriptor(mSize, GetFormat());
+ // Prefer TextureExternal unless the backend requires TextureRect.
+ TextureHost::NativeTexturePolicy policy =
+ TextureHost::BackendNativeTexturePolicy(aResources.GetBackendType(),
+ mSize);
+ auto imageType = policy == TextureHost::NativeTexturePolicy::REQUIRE
+ ? wr::ExternalImageType::TextureHandle(
+ wr::ImageBufferKind::TextureRect)
+ : wr::ExternalImageType::TextureHandle(
+ wr::ImageBufferKind::TextureExternal);
+ (aResources.*method)(aImageKeys[0], descriptor, aExtID, imageType, 0);
+ break;
+ }
+ case gfx::SurfaceFormat::P010:
+ case gfx::SurfaceFormat::P016:
+ case gfx::SurfaceFormat::NV12: {
+ MOZ_ASSERT(aImageKeys.length() == 2);
+ MOZ_ASSERT(mSize.width % 2 == 0);
+ MOZ_ASSERT(mSize.height % 2 == 0);
+
+ wr::ImageDescriptor descriptor0(mSize, mFormat == gfx::SurfaceFormat::NV12
+ ? gfx::SurfaceFormat::A8
+ : gfx::SurfaceFormat::A16);
+ wr::ImageDescriptor descriptor1(mSize / 2,
+ mFormat == gfx::SurfaceFormat::NV12
+ ? gfx::SurfaceFormat::R8G8
+ : gfx::SurfaceFormat::R16G16);
+ // Prefer TextureExternal unless the backend requires TextureRect.
+ TextureHost::NativeTexturePolicy policy =
+ TextureHost::BackendNativeTexturePolicy(aResources.GetBackendType(),
+ mSize);
+ auto imageType = policy == TextureHost::NativeTexturePolicy::REQUIRE
+ ? wr::ExternalImageType::TextureHandle(
+ wr::ImageBufferKind::TextureRect)
+ : wr::ExternalImageType::TextureHandle(
+ wr::ImageBufferKind::TextureExternal);
+ (aResources.*method)(aImageKeys[0], descriptor0, aExtID, imageType, 0);
+ (aResources.*method)(aImageKeys[1], descriptor1, aExtID, imageType, 1);
+ break;
+ }
+ default: {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+ }
+ }
+}
+
+void DXGITextureHostD3D11::PushDisplayItems(
+ wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
+ const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
+ const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
+ bool preferCompositorSurface =
+ aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE);
+ if (!gfx::gfxVars::UseWebRenderANGLE()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called without ANGLE");
+ return;
+ }
+
+ switch (GetFormat()) {
+ case gfx::SurfaceFormat::R8G8B8X8:
+ case gfx::SurfaceFormat::R8G8B8A8:
+ case gfx::SurfaceFormat::B8G8R8A8:
+ case gfx::SurfaceFormat::B8G8R8X8: {
+ MOZ_ASSERT(aImageKeys.length() == 1);
+ aBuilder.PushImage(
+ aBounds, aClip, true, false, aFilter, aImageKeys[0],
+ !(mFlags & TextureFlags::NON_PREMULTIPLIED),
+ wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f}, preferCompositorSurface,
+ SupportsExternalCompositing(aBuilder.GetBackendType()));
+ break;
+ }
+ case gfx::SurfaceFormat::P010:
+ case gfx::SurfaceFormat::P016:
+ case gfx::SurfaceFormat::NV12: {
+ // DXGI_FORMAT_P010 stores its 10 bit value in the most significant bits
+ // of each 16 bit word with the unused lower bits cleared to zero so that
+ // it may be handled as if it was DXGI_FORMAT_P016. This is approximately
+ // perceptually correct. However, due to rounding error, the precise
+ // quantized value after sampling may be off by 1.
+ MOZ_ASSERT(aImageKeys.length() == 2);
+ aBuilder.PushNV12Image(
+ aBounds, aClip, true, aImageKeys[0], aImageKeys[1],
+ GetFormat() == gfx::SurfaceFormat::NV12 ? wr::ColorDepth::Color8
+ : wr::ColorDepth::Color16,
+ wr::ToWrYuvColorSpace(ToYUVColorSpace(mColorSpace)),
+ wr::ToWrColorRange(mColorRange), aFilter, preferCompositorSurface,
+ SupportsExternalCompositing(aBuilder.GetBackendType()));
+ break;
+ }
+ default: {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+ }
+ }
+}
+
+bool DXGITextureHostD3D11::SupportsExternalCompositing(
+ WebRenderBackend aBackend) {
+ if (aBackend == WebRenderBackend::SOFTWARE) {
+ return true;
+ }
+ // XXX Add P010 and P016 support.
+ if (GetFormat() == gfx::SurfaceFormat::NV12 &&
+ gfx::gfxVars::UseWebRenderDCompVideoOverlayWin()) {
+ return true;
+ }
+ return false;
+}
+
+DXGIYCbCrTextureHostD3D11::DXGIYCbCrTextureHostD3D11(
+ TextureFlags aFlags, const SurfaceDescriptorDXGIYCbCr& aDescriptor)
+ : TextureHost(TextureHostType::DXGIYCbCr, aFlags),
+ mSize(aDescriptor.size()),
+ mSizeY(aDescriptor.sizeY()),
+ mSizeCbCr(aDescriptor.sizeCbCr()),
+ mIsLocked(false),
+ mColorDepth(aDescriptor.colorDepth()),
+ mYUVColorSpace(aDescriptor.yUVColorSpace()),
+ mColorRange(aDescriptor.colorRange()) {
+ mHandles[0] = aDescriptor.handleY();
+ mHandles[1] = aDescriptor.handleCb();
+ mHandles[2] = aDescriptor.handleCr();
+}
+
+bool DXGIYCbCrTextureHostD3D11::EnsureTexture() {
+ RefPtr<ID3D11Device> device;
+ if (mTextures[0]) {
+ mTextures[0]->GetDevice(getter_AddRefs(device));
+ if (device == DeviceManagerDx::Get()->GetCompositorDevice()) {
+ NS_WARNING("Incompatible texture.");
+ return true;
+ }
+ mTextures[0] = nullptr;
+ mTextures[1] = nullptr;
+ mTextures[2] = nullptr;
+ }
+
+ if (!GetDevice() ||
+ GetDevice() != DeviceManagerDx::Get()->GetCompositorDevice()) {
+ NS_WARNING("No device or incompatible device.");
+ return false;
+ }
+
+ device = GetDevice();
+ RefPtr<ID3D11Texture2D> textures[3];
+
+ HRESULT hr = device->OpenSharedResource(
+ (HANDLE)mHandles[0], __uuidof(ID3D11Texture2D),
+ (void**)(ID3D11Texture2D**)getter_AddRefs(textures[0]));
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to open shared texture for Y Plane");
+ return false;
+ }
+
+ hr = device->OpenSharedResource(
+ (HANDLE)mHandles[1], __uuidof(ID3D11Texture2D),
+ (void**)(ID3D11Texture2D**)getter_AddRefs(textures[1]));
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to open shared texture for Cb Plane");
+ return false;
+ }
+
+ hr = device->OpenSharedResource(
+ (HANDLE)mHandles[2], __uuidof(ID3D11Texture2D),
+ (void**)(ID3D11Texture2D**)getter_AddRefs(textures[2]));
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to open shared texture for Cr Plane");
+ return false;
+ }
+
+ mTextures[0] = textures[0].forget();
+ mTextures[1] = textures[1].forget();
+ mTextures[2] = textures[2].forget();
+
+ return true;
+}
+
+RefPtr<ID3D11Device> DXGIYCbCrTextureHostD3D11::GetDevice() { return nullptr; }
+
+bool DXGIYCbCrTextureHostD3D11::EnsureTextureSource() { return false; }
+
+void DXGIYCbCrTextureHostD3D11::CreateRenderTexture(
+ const wr::ExternalImageId& aExternalImageId) {
+ RefPtr<wr::RenderTextureHost> texture = new wr::RenderDXGIYCbCrTextureHost(
+ mHandles, mYUVColorSpace, mColorDepth, mColorRange, mSizeY, mSizeCbCr);
+
+ wr::RenderThread::Get()->RegisterExternalImage(aExternalImageId,
+ texture.forget());
+}
+
+uint32_t DXGIYCbCrTextureHostD3D11::NumSubTextures() {
+ // ycbcr use 3 sub textures.
+ return 3;
+}
+
+void DXGIYCbCrTextureHostD3D11::PushResourceUpdates(
+ wr::TransactionBuilder& aResources, ResourceUpdateOp aOp,
+ const Range<wr::ImageKey>& aImageKeys, const wr::ExternalImageId& aExtID) {
+ if (!gfx::gfxVars::UseWebRenderANGLE()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called without ANGLE");
+ return;
+ }
+
+ MOZ_ASSERT(mHandles[0] && mHandles[1] && mHandles[2]);
+ MOZ_ASSERT(aImageKeys.length() == 3);
+ // Assume the chroma planes are rounded up if the luma plane is odd sized.
+ MOZ_ASSERT((mSizeCbCr.width == mSizeY.width ||
+ mSizeCbCr.width == (mSizeY.width + 1) >> 1) &&
+ (mSizeCbCr.height == mSizeY.height ||
+ mSizeCbCr.height == (mSizeY.height + 1) >> 1));
+
+ auto method = aOp == TextureHost::ADD_IMAGE
+ ? &wr::TransactionBuilder::AddExternalImage
+ : &wr::TransactionBuilder::UpdateExternalImage;
+
+ // Prefer TextureExternal unless the backend requires TextureRect.
+ // Use a size that is the maximum of the Y and CbCr sizes.
+ IntSize textureSize = std::max(mSizeY, mSizeCbCr);
+ TextureHost::NativeTexturePolicy policy =
+ TextureHost::BackendNativeTexturePolicy(aResources.GetBackendType(),
+ textureSize);
+ auto imageType = policy == TextureHost::NativeTexturePolicy::REQUIRE
+ ? wr::ExternalImageType::TextureHandle(
+ wr::ImageBufferKind::TextureRect)
+ : wr::ExternalImageType::TextureHandle(
+ wr::ImageBufferKind::TextureExternal);
+
+ // y
+ wr::ImageDescriptor descriptor0(mSizeY, gfx::SurfaceFormat::A8);
+ // cb and cr
+ wr::ImageDescriptor descriptor1(mSizeCbCr, gfx::SurfaceFormat::A8);
+ (aResources.*method)(aImageKeys[0], descriptor0, aExtID, imageType, 0);
+ (aResources.*method)(aImageKeys[1], descriptor1, aExtID, imageType, 1);
+ (aResources.*method)(aImageKeys[2], descriptor1, aExtID, imageType, 2);
+}
+
+void DXGIYCbCrTextureHostD3D11::PushDisplayItems(
+ wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
+ const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
+ const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
+ if (!gfx::gfxVars::UseWebRenderANGLE()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called without ANGLE");
+ return;
+ }
+
+ MOZ_ASSERT(aImageKeys.length() == 3);
+
+ aBuilder.PushYCbCrPlanarImage(
+ aBounds, aClip, true, aImageKeys[0], aImageKeys[1], aImageKeys[2],
+ wr::ToWrColorDepth(mColorDepth), wr::ToWrYuvColorSpace(mYUVColorSpace),
+ wr::ToWrColorRange(mColorRange), aFilter,
+ aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE),
+ SupportsExternalCompositing(aBuilder.GetBackendType()));
+}
+
+bool DXGIYCbCrTextureHostD3D11::SupportsExternalCompositing(
+ WebRenderBackend aBackend) {
+ return aBackend == WebRenderBackend::SOFTWARE;
+}
+
+bool DataTextureSourceD3D11::Update(DataSourceSurface* aSurface,
+ nsIntRegion* aDestRegion,
+ IntPoint* aSrcOffset,
+ IntPoint* aDstOffset) {
+ // Incremental update with a source offset is only used on Mac so it is not
+ // clear that we ever will need to support it for D3D.
+ MOZ_ASSERT(!aSrcOffset);
+ MOZ_RELEASE_ASSERT(!aDstOffset);
+ MOZ_ASSERT(aSurface);
+
+ MOZ_ASSERT(mAllowTextureUploads);
+ if (!mAllowTextureUploads) {
+ return false;
+ }
+
+ HRESULT hr;
+
+ if (!mDevice) {
+ return false;
+ }
+
+ uint32_t bpp = BytesPerPixel(aSurface->GetFormat());
+ DXGI_FORMAT dxgiFormat = SurfaceFormatToDXGIFormat(aSurface->GetFormat());
+
+ mSize = aSurface->GetSize();
+ mFormat = aSurface->GetFormat();
+
+ CD3D11_TEXTURE2D_DESC desc(dxgiFormat, mSize.width, mSize.height, 1, 1);
+
+ int32_t maxSize = GetMaxTextureSizeFromDevice(mDevice);
+ if ((mSize.width <= maxSize && mSize.height <= maxSize) ||
+ (mFlags & TextureFlags::DISALLOW_BIGIMAGE)) {
+ if (mTexture) {
+ D3D11_TEXTURE2D_DESC currentDesc;
+ mTexture->GetDesc(&currentDesc);
+
+ // Make sure there's no size mismatch, if there is, recreate.
+ if (static_cast<int32_t>(currentDesc.Width) != mSize.width ||
+ static_cast<int32_t>(currentDesc.Height) != mSize.height ||
+ currentDesc.Format != dxgiFormat) {
+ mTexture = nullptr;
+ // Make sure we upload the whole surface.
+ aDestRegion = nullptr;
+ }
+ }
+
+ nsIntRegion* regionToUpdate = aDestRegion;
+ if (!mTexture) {
+ hr = mDevice->CreateTexture2D(&desc, nullptr, getter_AddRefs(mTexture));
+ mIsTiled = false;
+ if (FAILED(hr) || !mTexture) {
+ Reset();
+ return false;
+ }
+
+ if (mFlags & TextureFlags::COMPONENT_ALPHA) {
+ regionToUpdate = nullptr;
+ }
+ }
+
+ DataSourceSurface::MappedSurface map;
+ if (!aSurface->Map(DataSourceSurface::MapType::READ, &map)) {
+ gfxCriticalError() << "Failed to map surface.";
+ Reset();
+ return false;
+ }
+
+ RefPtr<ID3D11DeviceContext> context;
+ mDevice->GetImmediateContext(getter_AddRefs(context));
+
+ if (regionToUpdate) {
+ for (auto iter = regionToUpdate->RectIter(); !iter.Done(); iter.Next()) {
+ const IntRect& rect = iter.Get();
+ D3D11_BOX box;
+ box.front = 0;
+ box.back = 1;
+ box.left = rect.X();
+ box.top = rect.Y();
+ box.right = rect.XMost();
+ box.bottom = rect.YMost();
+
+ void* data = map.mData + map.mStride * rect.Y() +
+ BytesPerPixel(aSurface->GetFormat()) * rect.X();
+
+ context->UpdateSubresource(mTexture, 0, &box, data, map.mStride,
+ map.mStride * rect.Height());
+ }
+ } else {
+ context->UpdateSubresource(mTexture, 0, nullptr, map.mData, map.mStride,
+ map.mStride * mSize.height);
+ }
+
+ aSurface->Unmap();
+ } else {
+ mIsTiled = true;
+ uint32_t tileCount = GetRequiredTilesD3D11(mSize.width, maxSize) *
+ GetRequiredTilesD3D11(mSize.height, maxSize);
+
+ mTileTextures.resize(tileCount);
+ mTileSRVs.resize(tileCount);
+ mTexture = nullptr;
+
+ DataSourceSurface::ScopedMap map(aSurface, DataSourceSurface::READ);
+ if (!map.IsMapped()) {
+ gfxCriticalError() << "Failed to map surface.";
+ Reset();
+ return false;
+ }
+
+ for (uint32_t i = 0; i < tileCount; i++) {
+ IntRect tileRect = GetTileRect(i);
+
+ desc.Width = tileRect.Width();
+ desc.Height = tileRect.Height();
+ desc.Usage = D3D11_USAGE_IMMUTABLE;
+
+ D3D11_SUBRESOURCE_DATA initData;
+ initData.pSysMem =
+ map.GetData() + tileRect.Y() * map.GetStride() + tileRect.X() * bpp;
+ initData.SysMemPitch = map.GetStride();
+
+ hr = mDevice->CreateTexture2D(&desc, &initData,
+ getter_AddRefs(mTileTextures[i]));
+ if (FAILED(hr) || !mTileTextures[i]) {
+ Reset();
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+ID3D11Texture2D* DataTextureSourceD3D11::GetD3D11Texture() const {
+ return mIterating ? mTileTextures[mCurrentTile] : mTexture;
+}
+
+RefPtr<TextureSource> DataTextureSourceD3D11::ExtractCurrentTile() {
+ MOZ_ASSERT(mIterating);
+ return new DataTextureSourceD3D11(mDevice, mFormat,
+ mTileTextures[mCurrentTile]);
+}
+
+ID3D11ShaderResourceView* DataTextureSourceD3D11::GetShaderResourceView() {
+ if (mIterating) {
+ if (!mTileSRVs[mCurrentTile]) {
+ if (!mTileTextures[mCurrentTile]) {
+ return nullptr;
+ }
+
+ RefPtr<ID3D11Device> device;
+ mTileTextures[mCurrentTile]->GetDevice(getter_AddRefs(device));
+ HRESULT hr = device->CreateShaderResourceView(
+ mTileTextures[mCurrentTile], nullptr,
+ getter_AddRefs(mTileSRVs[mCurrentTile]));
+ if (FAILED(hr)) {
+ gfxCriticalNote
+ << "[D3D11] DataTextureSourceD3D11:GetShaderResourceView CreateSRV "
+ "failure "
+ << gfx::hexa(hr);
+ return nullptr;
+ }
+ }
+ return mTileSRVs[mCurrentTile];
+ }
+
+ return TextureSourceD3D11::GetShaderResourceView();
+}
+
+void DataTextureSourceD3D11::Reset() {
+ mTexture = nullptr;
+ mTileSRVs.resize(0);
+ mTileTextures.resize(0);
+ mIsTiled = false;
+ mSize.width = 0;
+ mSize.height = 0;
+}
+
+IntRect DataTextureSourceD3D11::GetTileRect(uint32_t aIndex) const {
+ return GetTileRectD3D11(aIndex, mSize, GetMaxTextureSizeFromDevice(mDevice));
+}
+
+IntRect DataTextureSourceD3D11::GetTileRect() {
+ IntRect rect = GetTileRect(mCurrentTile);
+ return IntRect(rect.X(), rect.Y(), rect.Width(), rect.Height());
+}
+
+CompositingRenderTargetD3D11::CompositingRenderTargetD3D11(
+ ID3D11Texture2D* aTexture, const gfx::IntPoint& aOrigin,
+ DXGI_FORMAT aFormatOverride)
+ : CompositingRenderTarget(aOrigin) {
+ MOZ_ASSERT(aTexture);
+
+ mTexture = aTexture;
+
+ RefPtr<ID3D11Device> device;
+ mTexture->GetDevice(getter_AddRefs(device));
+
+ mFormatOverride = aFormatOverride;
+
+ // If we happen to have a typeless underlying DXGI surface, we need to be
+ // explicit about the format here. (Such a surface could come from an external
+ // source, such as the Oculus compositor)
+ CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(D3D11_RTV_DIMENSION_TEXTURE2D,
+ mFormatOverride);
+ D3D11_RENDER_TARGET_VIEW_DESC* desc =
+ aFormatOverride == DXGI_FORMAT_UNKNOWN ? nullptr : &rtvDesc;
+
+ HRESULT hr =
+ device->CreateRenderTargetView(mTexture, desc, getter_AddRefs(mRTView));
+
+ if (FAILED(hr)) {
+ LOGD3D11("Failed to create RenderTargetView.");
+ }
+}
+
+void CompositingRenderTargetD3D11::BindRenderTarget(
+ ID3D11DeviceContext* aContext) {
+ if (mClearOnBind) {
+ FLOAT clear[] = {0, 0, 0, 0};
+ aContext->ClearRenderTargetView(mRTView, clear);
+ mClearOnBind = false;
+ }
+ ID3D11RenderTargetView* view = mRTView;
+ aContext->OMSetRenderTargets(1, &view, nullptr);
+}
+
+IntSize CompositingRenderTargetD3D11::GetSize() const {
+ return TextureSourceD3D11::GetSize();
+}
+
+static inline bool ShouldDevCrashOnSyncInitFailure() {
+ // Compositor shutdown does not wait for video decoding to finish, so it is
+ // possible for the compositor to destroy the SyncObject before video has a
+ // chance to initialize it.
+ if (!NS_IsMainThread()) {
+ return false;
+ }
+
+ // Note: CompositorIsInGPUProcess is a main-thread-only function.
+ return !CompositorBridgeChild::CompositorIsInGPUProcess() &&
+ !DeviceManagerDx::Get()->HasDeviceReset();
+}
+
+SyncObjectD3D11Host::SyncObjectD3D11Host(ID3D11Device* aDevice)
+ : mSyncHandle(0), mDevice(aDevice) {
+ MOZ_ASSERT(aDevice);
+}
+
+bool SyncObjectD3D11Host::Init() {
+ CD3D11_TEXTURE2D_DESC desc(
+ DXGI_FORMAT_B8G8R8A8_UNORM, 1, 1, 1, 1,
+ D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET);
+ desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
+
+ RefPtr<ID3D11Texture2D> texture;
+ HRESULT hr =
+ mDevice->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture));
+ if (FAILED(hr) || !texture) {
+ gfxWarning() << "Could not create a sync texture: " << gfx::hexa(hr);
+ return false;
+ }
+
+ hr = texture->QueryInterface((IDXGIResource**)getter_AddRefs(mSyncTexture));
+ if (FAILED(hr) || !mSyncTexture) {
+ gfxWarning() << "Could not QI sync texture: " << gfx::hexa(hr);
+ return false;
+ }
+
+ hr = mSyncTexture->QueryInterface(
+ (IDXGIKeyedMutex**)getter_AddRefs(mKeyedMutex));
+ if (FAILED(hr) || !mKeyedMutex) {
+ gfxWarning() << "Could not QI keyed-mutex: " << gfx::hexa(hr);
+ return false;
+ }
+
+ hr = mSyncTexture->GetSharedHandle(&mSyncHandle);
+ if (FAILED(hr) || !mSyncHandle) {
+ NS_DispatchToMainThread(NS_NewRunnableFunction(
+ "layers::SyncObjectD3D11Renderer::Init",
+ []() -> void { Accumulate(Telemetry::D3D11_SYNC_HANDLE_FAILURE, 1); }));
+ gfxWarning() << "Could not get sync texture shared handle: "
+ << gfx::hexa(hr);
+ return false;
+ }
+
+ return true;
+}
+
+SyncHandle SyncObjectD3D11Host::GetSyncHandle() { return mSyncHandle; }
+
+bool SyncObjectD3D11Host::Synchronize(bool aFallible) {
+ HRESULT hr;
+ AutoTextureLock lock(mKeyedMutex, hr, 10000);
+
+ if (hr == WAIT_TIMEOUT) {
+ hr = mDevice->GetDeviceRemovedReason();
+ if (hr != S_OK) {
+ // Since the timeout is related to the driver-removed. Return false for
+ // error handling.
+ gfxCriticalNote << "GFX: D3D11 timeout with device-removed:"
+ << gfx::hexa(hr);
+ } else if (aFallible) {
+ gfxCriticalNote << "GFX: D3D11 timeout on the D3D11 sync lock.";
+ } else {
+ // There is no driver-removed event. Crash with this timeout.
+ MOZ_CRASH("GFX: D3D11 normal status timeout");
+ }
+
+ return false;
+ }
+ if (hr == WAIT_ABANDONED) {
+ gfxCriticalNote << "GFX: AL_D3D11 abandoned sync";
+ }
+
+ return true;
+}
+
+SyncObjectD3D11Client::SyncObjectD3D11Client(SyncHandle aSyncHandle,
+ ID3D11Device* aDevice)
+ : mSyncLock("SyncObjectD3D11"), mSyncHandle(aSyncHandle), mDevice(aDevice) {
+ MOZ_ASSERT(aDevice);
+}
+
+SyncObjectD3D11Client::SyncObjectD3D11Client(SyncHandle aSyncHandle)
+ : mSyncLock("SyncObjectD3D11"), mSyncHandle(aSyncHandle) {}
+
+bool SyncObjectD3D11Client::Init(ID3D11Device* aDevice, bool aFallible) {
+ if (mKeyedMutex) {
+ return true;
+ }
+
+ HRESULT hr = aDevice->OpenSharedResource(
+ mSyncHandle, __uuidof(ID3D11Texture2D),
+ (void**)(ID3D11Texture2D**)getter_AddRefs(mSyncTexture));
+ if (FAILED(hr) || !mSyncTexture) {
+ gfxCriticalNote << "Failed to OpenSharedResource for SyncObjectD3D11: "
+ << hexa(hr);
+ if (!aFallible && ShouldDevCrashOnSyncInitFailure()) {
+ gfxDevCrash(LogReason::D3D11FinalizeFrame)
+ << "Without device reset: " << hexa(hr);
+ }
+ return false;
+ }
+
+ hr = mSyncTexture->QueryInterface(__uuidof(IDXGIKeyedMutex),
+ getter_AddRefs(mKeyedMutex));
+ if (FAILED(hr) || !mKeyedMutex) {
+ // Leave both the critical error and MOZ_CRASH for now; the critical error
+ // lets us "save" the hr value. We will probably eventually replace this
+ // with gfxDevCrash.
+ if (!aFallible) {
+ gfxCriticalError() << "Failed to get KeyedMutex (2): " << hexa(hr);
+ MOZ_CRASH("GFX: Cannot get D3D11 KeyedMutex");
+ } else {
+ gfxCriticalNote << "Failed to get KeyedMutex (3): " << hexa(hr);
+ }
+ return false;
+ }
+
+ return true;
+}
+
+void SyncObjectD3D11Client::RegisterTexture(ID3D11Texture2D* aTexture) {
+ mSyncedTextures.push_back(aTexture);
+}
+
+bool SyncObjectD3D11Client::IsSyncObjectValid() {
+ MOZ_ASSERT(mDevice);
+ return true;
+}
+
+// We have only 1 sync object. As a thing that somehow works,
+// we copy each of the textures that need to be synced with the compositor
+// into our sync object and only use a lock for this sync object.
+// This way, we don't have to sync every texture we send to the compositor.
+// We only have to do this once per transaction.
+bool SyncObjectD3D11Client::Synchronize(bool aFallible) {
+ MOZ_ASSERT(mDevice);
+ // Since this can be called from either the Paint or Main thread.
+ // We don't want this to race since we initialize the sync texture here
+ // too.
+ MutexAutoLock syncLock(mSyncLock);
+
+ if (!mSyncedTextures.size()) {
+ return true;
+ }
+ if (!Init(mDevice, aFallible)) {
+ return false;
+ }
+
+ return SynchronizeInternal(mDevice, aFallible);
+}
+
+bool SyncObjectD3D11Client::SynchronizeInternal(ID3D11Device* aDevice,
+ bool aFallible) {
+ mSyncLock.AssertCurrentThreadOwns();
+
+ HRESULT hr;
+ AutoTextureLock lock(mKeyedMutex, hr, 20000);
+
+ if (hr == WAIT_TIMEOUT) {
+ if (DeviceManagerDx::Get()->HasDeviceReset()) {
+ gfxWarning() << "AcquireSync timed out because of device reset.";
+ return false;
+ }
+ if (aFallible) {
+ gfxWarning() << "Timeout on the D3D11 sync lock.";
+ } else {
+ gfxDevCrash(LogReason::D3D11SyncLock)
+ << "Timeout on the D3D11 sync lock.";
+ }
+ return false;
+ }
+
+ D3D11_BOX box;
+ box.front = box.top = box.left = 0;
+ box.back = box.bottom = box.right = 1;
+
+ RefPtr<ID3D11DeviceContext> ctx;
+ aDevice->GetImmediateContext(getter_AddRefs(ctx));
+
+ for (auto iter = mSyncedTextures.begin(); iter != mSyncedTextures.end();
+ iter++) {
+ ctx->CopySubresourceRegion(mSyncTexture, 0, 0, 0, 0, *iter, 0, &box);
+ }
+
+ mSyncedTextures.clear();
+
+ return true;
+}
+
+uint32_t GetMaxTextureSizeFromDevice(ID3D11Device* aDevice) {
+ return GetMaxTextureSizeForFeatureLevel(aDevice->GetFeatureLevel());
+}
+
+AutoLockD3D11Texture::AutoLockD3D11Texture(ID3D11Texture2D* aTexture) {
+ aTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mMutex));
+ if (!mMutex) {
+ return;
+ }
+ HRESULT hr = mMutex->AcquireSync(0, 10000);
+ if (hr == WAIT_TIMEOUT) {
+ MOZ_CRASH("GFX: IMFYCbCrImage timeout");
+ }
+
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to lock the texture");
+ }
+}
+
+AutoLockD3D11Texture::~AutoLockD3D11Texture() {
+ if (!mMutex) {
+ return;
+ }
+ HRESULT hr = mMutex->ReleaseSync(0);
+ if (FAILED(hr)) {
+ NS_WARNING("Failed to unlock the texture");
+ }
+}
+
+SyncObjectD3D11ClientContentDevice::SyncObjectD3D11ClientContentDevice(
+ SyncHandle aSyncHandle)
+ : SyncObjectD3D11Client(aSyncHandle) {}
+
+bool SyncObjectD3D11ClientContentDevice::Synchronize(bool aFallible) {
+ // Since this can be called from either the Paint or Main thread.
+ // We don't want this to race since we initialize the sync texture here
+ // too.
+ MutexAutoLock syncLock(mSyncLock);
+
+ MOZ_ASSERT(mContentDevice);
+
+ if (!mSyncedTextures.size()) {
+ return true;
+ }
+
+ if (!Init(mContentDevice, aFallible)) {
+ return false;
+ }
+
+ RefPtr<ID3D11Device> dev;
+ mSyncTexture->GetDevice(getter_AddRefs(dev));
+
+ if (dev == DeviceManagerDx::Get()->GetContentDevice()) {
+ if (DeviceManagerDx::Get()->HasDeviceReset()) {
+ return false;
+ }
+ }
+
+ if (dev != mContentDevice) {
+ gfxWarning() << "Attempt to sync texture from invalid device.";
+ return false;
+ }
+
+ return SyncObjectD3D11Client::SynchronizeInternal(dev, aFallible);
+}
+
+bool SyncObjectD3D11ClientContentDevice::IsSyncObjectValid() {
+ RefPtr<ID3D11Device> dev;
+ // There is a case that devices are not initialized yet with WebRender.
+ if (gfxPlatform::GetPlatform()->DevicesInitialized()) {
+ dev = DeviceManagerDx::Get()->GetContentDevice();
+ }
+
+ // Update mDevice if the ContentDevice initialization is detected.
+ if (!mContentDevice && dev && NS_IsMainThread()) {
+ mContentDevice = dev;
+ }
+
+ if (!dev || (NS_IsMainThread() && dev != mContentDevice)) {
+ return false;
+ }
+ return true;
+}
+
+void SyncObjectD3D11ClientContentDevice::EnsureInitialized() {
+ if (mContentDevice) {
+ return;
+ }
+
+ if (XRE_IsGPUProcess() || !gfxPlatform::GetPlatform()->DevicesInitialized()) {
+ return;
+ }
+
+ mContentDevice = DeviceManagerDx::Get()->GetContentDevice();
+}
+
+StaticAutoPtr<GpuProcessD3D11TextureMap> GpuProcessD3D11TextureMap::sInstance;
+
+/* static */
+void GpuProcessD3D11TextureMap::Init() {
+ MOZ_ASSERT(XRE_IsGPUProcess());
+ sInstance = new GpuProcessD3D11TextureMap();
+}
+
+/* static */
+void GpuProcessD3D11TextureMap::Shutdown() {
+ MOZ_ASSERT(XRE_IsGPUProcess());
+ sInstance = nullptr;
+}
+
+/* static */
+GpuProcessTextureId GpuProcessD3D11TextureMap::GetNextTextureId() {
+ MOZ_ASSERT(XRE_IsGPUProcess());
+ return GpuProcessTextureId::GetNext();
+}
+
+GpuProcessD3D11TextureMap::GpuProcessD3D11TextureMap()
+ : mD3D11TexturesById("D3D11TextureMap::mD3D11TexturesById") {}
+
+GpuProcessD3D11TextureMap::~GpuProcessD3D11TextureMap() {}
+
+void GpuProcessD3D11TextureMap::Register(
+ GpuProcessTextureId aTextureId, ID3D11Texture2D* aTexture,
+ uint32_t aArrayIndex, const gfx::IntSize& aSize,
+ RefPtr<IMFSampleUsageInfo> aUsageInfo) {
+ MOZ_RELEASE_ASSERT(aTexture);
+ MOZ_RELEASE_ASSERT(aUsageInfo);
+
+ auto textures = mD3D11TexturesById.Lock();
+
+ auto it = textures->find(aTextureId);
+ if (it != textures->end()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+ return;
+ }
+ textures->emplace(aTextureId,
+ TextureHolder(aTexture, aArrayIndex, aSize, aUsageInfo));
+}
+
+void GpuProcessD3D11TextureMap::Unregister(GpuProcessTextureId aTextureId) {
+ auto textures = mD3D11TexturesById.Lock();
+
+ auto it = textures->find(aTextureId);
+ if (it == textures->end()) {
+ return;
+ }
+ textures->erase(it);
+}
+
+RefPtr<ID3D11Texture2D> GpuProcessD3D11TextureMap::GetTexture(
+ GpuProcessTextureId aTextureId) {
+ auto textures = mD3D11TexturesById.Lock();
+
+ auto it = textures->find(aTextureId);
+ if (it == textures->end()) {
+ return nullptr;
+ }
+
+ return it->second.mTexture;
+}
+
+Maybe<HANDLE> GpuProcessD3D11TextureMap::GetSharedHandleOfCopiedTexture(
+ GpuProcessTextureId aTextureId) {
+ TextureHolder holder;
+ {
+ auto textures = mD3D11TexturesById.Lock();
+
+ auto it = textures->find(aTextureId);
+ if (it == textures->end()) {
+ return Nothing();
+ }
+
+ if (it->second.mCopiedTextureSharedHandle.isSome()) {
+ return it->second.mCopiedTextureSharedHandle;
+ }
+
+ holder = it->second;
+ }
+
+ RefPtr<ID3D11Device> device;
+ holder.mTexture->GetDevice(getter_AddRefs(device));
+ if (!device) {
+ return Nothing();
+ }
+
+ RefPtr<ID3D11DeviceContext> context;
+ device->GetImmediateContext(getter_AddRefs(context));
+ if (!context) {
+ return Nothing();
+ }
+
+ CD3D11_TEXTURE2D_DESC newDesc(
+ DXGI_FORMAT_NV12, holder.mSize.width, holder.mSize.height, 1, 1,
+ D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE);
+ newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
+
+ RefPtr<ID3D11Texture2D> copiedTexture;
+ HRESULT hr =
+ device->CreateTexture2D(&newDesc, nullptr, getter_AddRefs(copiedTexture));
+ if (FAILED(hr)) {
+ return Nothing();
+ }
+
+ D3D11_TEXTURE2D_DESC inDesc;
+ holder.mTexture->GetDesc(&inDesc);
+
+ D3D11_TEXTURE2D_DESC outDesc;
+ copiedTexture->GetDesc(&outDesc);
+
+ UINT height = std::min(inDesc.Height, outDesc.Height);
+ UINT width = std::min(inDesc.Width, outDesc.Width);
+ D3D11_BOX srcBox = {0, 0, 0, width, height, 1};
+
+ context->CopySubresourceRegion(copiedTexture, 0, 0, 0, 0, holder.mTexture,
+ holder.mArrayIndex, &srcBox);
+
+ RefPtr<IDXGIResource> resource;
+ copiedTexture->QueryInterface((IDXGIResource**)getter_AddRefs(resource));
+ if (!resource) {
+ return Nothing();
+ }
+
+ HANDLE sharedHandle;
+ hr = resource->GetSharedHandle(&sharedHandle);
+ if (FAILED(hr)) {
+ return Nothing();
+ }
+
+ RefPtr<ID3D11Query> query;
+ CD3D11_QUERY_DESC desc(D3D11_QUERY_EVENT);
+ hr = device->CreateQuery(&desc, getter_AddRefs(query));
+ if (FAILED(hr) || !query) {
+ gfxWarning() << "Could not create D3D11_QUERY_EVENT: " << gfx::hexa(hr);
+ return Nothing();
+ }
+
+ context->End(query);
+
+ BOOL result;
+ bool ret = WaitForFrameGPUQuery(device, context, query, &result);
+ if (!ret) {
+ gfxCriticalNoteOnce << "WaitForFrameGPUQuery() failed";
+ }
+
+ {
+ auto textures = mD3D11TexturesById.Lock();
+
+ auto it = textures->find(aTextureId);
+ if (it == textures->end()) {
+ MOZ_ASSERT_UNREACHABLE("unexpected to be called");
+ return Nothing();
+ }
+
+ // Disable no video copy for future decoded video frames. Since
+ // GetSharedHandleOfCopiedTexture() is slow.
+ it->second.mIMFSampleUsageInfo->DisableZeroCopyNV12Texture();
+
+ it->second.mCopiedTexture = copiedTexture;
+ it->second.mCopiedTextureSharedHandle = Some(sharedHandle);
+ }
+
+ return Some(sharedHandle);
+}
+
+GpuProcessD3D11TextureMap::TextureHolder::TextureHolder(
+ ID3D11Texture2D* aTexture, uint32_t aArrayIndex, const gfx::IntSize& aSize,
+ RefPtr<IMFSampleUsageInfo> aUsageInfo)
+ : mTexture(aTexture),
+ mArrayIndex(aArrayIndex),
+ mSize(aSize),
+ mIMFSampleUsageInfo(aUsageInfo) {}
+
+} // namespace layers
+} // namespace mozilla
diff --git a/gfx/layers/d3d11/TextureD3D11.h b/gfx/layers/d3d11/TextureD3D11.h
new file mode 100644
index 0000000000..2d43835d5b
--- /dev/null
+++ b/gfx/layers/d3d11/TextureD3D11.h
@@ -0,0 +1,649 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_TEXTURED3D11_H
+#define MOZILLA_GFX_TEXTURED3D11_H
+
+#include <d3d11.h>
+
+#include <vector>
+
+#include "d3d9.h"
+#include "gfxWindowsPlatform.h"
+#include "mozilla/DataMutex.h"
+#include "mozilla/GfxMessageUtils.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/layers/Compositor.h"
+#include "mozilla/layers/SyncObject.h"
+#include "mozilla/layers/TextureClient.h"
+#include "mozilla/layers/TextureHost.h"
+
+namespace mozilla {
+namespace gl {
+class GLBlitHelper;
+}
+
+namespace layers {
+
+already_AddRefed<TextureHost> CreateTextureHostD3D11(
+ const SurfaceDescriptor& aDesc, ISurfaceAllocator* aDeallocator,
+ LayersBackend aBackend, TextureFlags aFlags);
+
+class MOZ_RAII AutoTextureLock final {
+ public:
+ AutoTextureLock(IDXGIKeyedMutex* aMutex, HRESULT& aResult,
+ uint32_t aTimeout = 0);
+ ~AutoTextureLock();
+
+ private:
+ RefPtr<IDXGIKeyedMutex> mMutex;
+ HRESULT mResult;
+};
+
+class CompositorD3D11;
+class IMFSampleUsageInfo;
+
+class D3D11TextureData final : public TextureData {
+ public:
+ // If aDevice is null, use one provided by gfxWindowsPlatform.
+ static D3D11TextureData* Create(gfx::IntSize aSize,
+ gfx::SurfaceFormat aFormat,
+ TextureAllocationFlags aAllocFlags,
+ ID3D11Device* aDevice = nullptr);
+ static D3D11TextureData* Create(gfx::SourceSurface* aSurface,
+ TextureAllocationFlags aAllocFlags,
+ ID3D11Device* aDevice = nullptr);
+
+ static already_AddRefed<TextureClient> CreateTextureClient(
+ ID3D11Texture2D* aTexture, uint32_t aIndex, gfx::IntSize aSize,
+ gfx::SurfaceFormat aFormat, gfx::ColorSpace2 aColorSpace,
+ gfx::ColorRange aColorRange, KnowsCompositor* aKnowsCompositor,
+ RefPtr<IMFSampleUsageInfo> aUsageInfo);
+
+ virtual ~D3D11TextureData();
+
+ bool UpdateFromSurface(gfx::SourceSurface* aSurface) override;
+
+ bool Lock(OpenMode aMode) override;
+
+ void Unlock() override;
+
+ already_AddRefed<gfx::DrawTarget> BorrowDrawTarget() override;
+
+ TextureData* CreateSimilar(LayersIPCChannel* aAllocator,
+ LayersBackend aLayersBackend, TextureFlags aFlags,
+ TextureAllocationFlags aAllocFlags) const override;
+
+ void SyncWithObject(RefPtr<SyncObjectClient> aSyncObject) override;
+
+ ID3D11Texture2D* GetD3D11Texture() const { return mTexture; }
+
+ void Deallocate(LayersIPCChannel* aAllocator) override;
+
+ D3D11TextureData* AsD3D11TextureData() override { return this; }
+
+ TextureAllocationFlags GetTextureAllocationFlags() const {
+ return mAllocationFlags;
+ }
+
+ void FillInfo(TextureData::Info& aInfo) const override;
+
+ bool Serialize(SurfaceDescriptor& aOutDescrptor) override;
+ void GetSubDescriptor(RemoteDecoderVideoSubDescriptor* aOutDesc) override;
+
+ gfx::ColorRange GetColorRange() const { return mColorRange; }
+ void SetColorRange(gfx::ColorRange aColorRange) { mColorRange = aColorRange; }
+
+ gfx::IntSize GetSize() const { return mSize; }
+ gfx::SurfaceFormat GetSurfaceFormat() const { return mFormat; }
+
+ TextureFlags GetTextureFlags() const override;
+
+ void SetGpuProcessTextureId(GpuProcessTextureId aTextureId) {
+ mGpuProcessTextureId = Some(aTextureId);
+ }
+
+ Maybe<GpuProcessTextureId> GetGpuProcessTextureId() {
+ return mGpuProcessTextureId;
+ }
+
+ private:
+ D3D11TextureData(ID3D11Texture2D* aTexture, uint32_t aArrayIndex,
+ gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
+ TextureAllocationFlags aFlags);
+
+ void GetDXGIResource(IDXGIResource** aOutResource);
+
+ bool PrepareDrawTargetInLock(OpenMode aMode);
+
+ friend class gl::GLBlitHelper;
+ bool SerializeSpecific(SurfaceDescriptorD3D10* aOutDesc);
+
+ static D3D11TextureData* Create(gfx::IntSize aSize,
+ gfx::SurfaceFormat aFormat,
+ gfx::SourceSurface* aSurface,
+ TextureAllocationFlags aAllocFlags,
+ ID3D11Device* aDevice = nullptr);
+
+ // Hold on to the DrawTarget because it is expensive to create one each
+ // ::Lock.
+ RefPtr<gfx::DrawTarget> mDrawTarget;
+ const gfx::IntSize mSize;
+ const gfx::SurfaceFormat mFormat;
+
+ public:
+ gfx::ColorSpace2 mColorSpace = gfx::ColorSpace2::SRGB;
+
+ private:
+ gfx::ColorRange mColorRange = gfx::ColorRange::LIMITED;
+ bool mNeedsClear = false;
+ const bool mHasSynchronization;
+
+ RefPtr<ID3D11Texture2D> mTexture;
+ Maybe<GpuProcessTextureId> mGpuProcessTextureId;
+ uint32_t mArrayIndex = 0;
+ const TextureAllocationFlags mAllocationFlags;
+};
+
+class DXGIYCbCrTextureData : public TextureData {
+ friend class gl::GLBlitHelper;
+
+ public:
+ static DXGIYCbCrTextureData* Create(
+ IDirect3DTexture9* aTextureY, IDirect3DTexture9* aTextureCb,
+ IDirect3DTexture9* aTextureCr, HANDLE aHandleY, HANDLE aHandleCb,
+ HANDLE aHandleCr, const gfx::IntSize& aSize, const gfx::IntSize& aSizeY,
+ const gfx::IntSize& aSizeCbCr, gfx::ColorDepth aColorDepth,
+ gfx::YUVColorSpace aYUVColorSpace, gfx::ColorRange aColorRange);
+
+ static DXGIYCbCrTextureData* Create(
+ ID3D11Texture2D* aTextureCb, ID3D11Texture2D* aTextureY,
+ ID3D11Texture2D* aTextureCr, const gfx::IntSize& aSize,
+ const gfx::IntSize& aSizeY, const gfx::IntSize& aSizeCbCr,
+ gfx::ColorDepth aColorDepth, gfx::YUVColorSpace aYUVColorSpace,
+ gfx::ColorRange aColorRange);
+
+ bool Lock(OpenMode) override { return true; }
+
+ void Unlock() override {}
+
+ void FillInfo(TextureData::Info& aInfo) const override;
+
+ void SerializeSpecific(SurfaceDescriptorDXGIYCbCr* aOutDesc);
+ bool Serialize(SurfaceDescriptor& aOutDescriptor) override;
+ void GetSubDescriptor(RemoteDecoderVideoSubDescriptor* aOutDesc) override;
+
+ already_AddRefed<gfx::DrawTarget> BorrowDrawTarget() override {
+ return nullptr;
+ }
+
+ void Deallocate(LayersIPCChannel* aAllocator) override;
+
+ bool UpdateFromSurface(gfx::SourceSurface*) override { return false; }
+
+ TextureFlags GetTextureFlags() const override;
+
+ DXGIYCbCrTextureData* AsDXGIYCbCrTextureData() override { return this; }
+
+ gfx::IntSize GetYSize() const { return mSizeY; }
+
+ gfx::IntSize GetCbCrSize() const { return mSizeCbCr; }
+
+ gfx::ColorDepth GetColorDepth() const { return mColorDepth; }
+ gfx::YUVColorSpace GetYUVColorSpace() const { return mYUVColorSpace; }
+ gfx::ColorRange GetColorRange() const { return mColorRange; }
+
+ ID3D11Texture2D* GetD3D11Texture(size_t index) {
+ return mD3D11Textures[index];
+ }
+
+ protected:
+ RefPtr<ID3D11Texture2D> mD3D11Textures[3];
+ RefPtr<IDirect3DTexture9> mD3D9Textures[3];
+ HANDLE mHandles[3];
+ gfx::IntSize mSize;
+ gfx::IntSize mSizeY;
+ gfx::IntSize mSizeCbCr;
+ gfx::ColorDepth mColorDepth;
+ gfx::YUVColorSpace mYUVColorSpace;
+ gfx::ColorRange mColorRange;
+};
+
+/**
+ * TextureSource that provides with the necessary APIs to be composited by a
+ * CompositorD3D11.
+ */
+class TextureSourceD3D11 {
+ public:
+ TextureSourceD3D11() : mFormatOverride(DXGI_FORMAT_UNKNOWN) {}
+ virtual ~TextureSourceD3D11() = default;
+
+ virtual ID3D11Texture2D* GetD3D11Texture() const { return mTexture; }
+ virtual ID3D11ShaderResourceView* GetShaderResourceView();
+
+ protected:
+ virtual gfx::IntSize GetSize() const { return mSize; }
+
+ gfx::IntSize mSize;
+ RefPtr<ID3D11Texture2D> mTexture;
+ RefPtr<ID3D11ShaderResourceView> mSRV;
+ DXGI_FORMAT mFormatOverride;
+};
+
+/**
+ * A TextureSource that implements the DataTextureSource interface.
+ * it can be used without a TextureHost and is able to upload texture data
+ * from a gfx::DataSourceSurface.
+ */
+class DataTextureSourceD3D11 : public DataTextureSource,
+ public TextureSourceD3D11,
+ public BigImageIterator {
+ public:
+ /// Constructor allowing the texture to perform texture uploads.
+ ///
+ /// The texture can be used as an actual DataTextureSource.
+ DataTextureSourceD3D11(ID3D11Device* aDevice, gfx::SurfaceFormat aFormat,
+ TextureFlags aFlags);
+
+ /// Constructor for textures created around DXGI shared handles, disallowing
+ /// texture uploads.
+ ///
+ /// The texture CANNOT be used as a DataTextureSource.
+ DataTextureSourceD3D11(ID3D11Device* aDevice, gfx::SurfaceFormat aFormat,
+ ID3D11Texture2D* aTexture);
+
+ DataTextureSourceD3D11(gfx::SurfaceFormat aFormat,
+ TextureSourceProvider* aProvider,
+ ID3D11Texture2D* aTexture);
+ DataTextureSourceD3D11(gfx::SurfaceFormat aFormat,
+ TextureSourceProvider* aProvider, TextureFlags aFlags);
+
+ virtual ~DataTextureSourceD3D11();
+
+ const char* Name() const override { return "DataTextureSourceD3D11"; }
+
+ // DataTextureSource
+
+ bool Update(gfx::DataSourceSurface* aSurface,
+ nsIntRegion* aDestRegion = nullptr,
+ gfx::IntPoint* aSrcOffset = nullptr,
+ gfx::IntPoint* aDstOffset = nullptr) override;
+
+ // TextureSource
+
+ TextureSourceD3D11* AsSourceD3D11() override { return this; }
+
+ ID3D11Texture2D* GetD3D11Texture() const override;
+
+ ID3D11ShaderResourceView* GetShaderResourceView() override;
+
+ // Returns nullptr if this texture was created by a DXGI TextureHost.
+ DataTextureSource* AsDataTextureSource() override {
+ return mAllowTextureUploads ? this : nullptr;
+ }
+
+ void DeallocateDeviceData() override { mTexture = nullptr; }
+
+ gfx::IntSize GetSize() const override { return mSize; }
+
+ gfx::SurfaceFormat GetFormat() const override { return mFormat; }
+
+ // BigImageIterator
+
+ BigImageIterator* AsBigImageIterator() override {
+ return mIsTiled ? this : nullptr;
+ }
+
+ size_t GetTileCount() override { return mTileTextures.size(); }
+
+ bool NextTile() override { return (++mCurrentTile < mTileTextures.size()); }
+
+ gfx::IntRect GetTileRect() override;
+
+ void EndBigImageIteration() override { mIterating = false; }
+
+ void BeginBigImageIteration() override {
+ mIterating = true;
+ mCurrentTile = 0;
+ }
+
+ RefPtr<TextureSource> ExtractCurrentTile() override;
+
+ void Reset();
+
+ protected:
+ gfx::IntRect GetTileRect(uint32_t aIndex) const;
+
+ std::vector<RefPtr<ID3D11Texture2D>> mTileTextures;
+ std::vector<RefPtr<ID3D11ShaderResourceView>> mTileSRVs;
+ RefPtr<ID3D11Device> mDevice;
+ gfx::SurfaceFormat mFormat;
+ TextureFlags mFlags;
+ uint32_t mCurrentTile;
+ bool mIsTiled;
+ bool mIterating;
+ // Sadly, the code was originally organized so that this class is used both in
+ // the cases where we want to perform texture uploads through the
+ // DataTextureSource interface, and the cases where we wrap the texture around
+ // an existing DXGI handle in which case we should not use it as a
+ // DataTextureSource. This member differentiates the two scenarios. When it is
+ // false the texture "pretends" to not be a DataTextureSource.
+ bool mAllowTextureUploads;
+};
+
+/**
+ * A TextureHost for shared D3D11 textures.
+ */
+class DXGITextureHostD3D11 : public TextureHost {
+ public:
+ DXGITextureHostD3D11(TextureFlags aFlags,
+ const SurfaceDescriptorD3D10& aDescriptor);
+
+ void DeallocateDeviceData() override {}
+
+ gfx::SurfaceFormat GetFormat() const override { return mFormat; }
+
+ bool LockWithoutCompositor() override;
+ void UnlockWithoutCompositor() override;
+
+ gfx::IntSize GetSize() const override { return mSize; }
+ gfx::ColorRange GetColorRange() const override { return mColorRange; }
+
+ already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
+
+ void CreateRenderTexture(
+ const wr::ExternalImageId& aExternalImageId) override;
+
+ uint32_t NumSubTextures() override;
+
+ void PushResourceUpdates(wr::TransactionBuilder& aResources,
+ ResourceUpdateOp aOp,
+ const Range<wr::ImageKey>& aImageKeys,
+ const wr::ExternalImageId& aExtID) override;
+
+ void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
+ const wr::LayoutRect& aBounds,
+ const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
+ const Range<wr::ImageKey>& aImageKeys,
+ PushDisplayItemFlagSet aFlags) override;
+
+ bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
+
+ protected:
+ bool LockInternal();
+ void UnlockInternal();
+
+ bool EnsureTextureSource();
+
+ RefPtr<ID3D11Device> GetDevice();
+
+ bool EnsureTexture();
+
+ RefPtr<ID3D11Device> mDevice;
+ RefPtr<ID3D11Texture2D> mTexture;
+ Maybe<GpuProcessTextureId> mGpuProcessTextureId;
+ uint32_t mArrayIndex = 0;
+ RefPtr<DataTextureSourceD3D11> mTextureSource;
+ gfx::IntSize mSize;
+ WindowsHandle mHandle;
+ gfx::SurfaceFormat mFormat;
+
+ public:
+ const gfx::ColorSpace2 mColorSpace;
+
+ protected:
+ const gfx::ColorRange mColorRange;
+ bool mIsLocked;
+};
+
+class DXGIYCbCrTextureHostD3D11 : public TextureHost {
+ public:
+ DXGIYCbCrTextureHostD3D11(TextureFlags aFlags,
+ const SurfaceDescriptorDXGIYCbCr& aDescriptor);
+
+ void DeallocateDeviceData() override {}
+
+ gfx::SurfaceFormat GetFormat() const override {
+ return gfx::SurfaceFormat::YUV;
+ }
+
+ gfx::ColorDepth GetColorDepth() const override { return mColorDepth; }
+ gfx::YUVColorSpace GetYUVColorSpace() const override {
+ return mYUVColorSpace;
+ }
+ gfx::ColorRange GetColorRange() const override { return mColorRange; }
+
+ gfx::IntSize GetSize() const override { return mSize; }
+
+ already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override {
+ return nullptr;
+ }
+
+ void CreateRenderTexture(
+ const wr::ExternalImageId& aExternalImageId) override;
+
+ uint32_t NumSubTextures() override;
+
+ void PushResourceUpdates(wr::TransactionBuilder& aResources,
+ ResourceUpdateOp aOp,
+ const Range<wr::ImageKey>& aImageKeys,
+ const wr::ExternalImageId& aExtID) override;
+
+ void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
+ const wr::LayoutRect& aBounds,
+ const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
+ const Range<wr::ImageKey>& aImageKeys,
+ PushDisplayItemFlagSet aFlags) override;
+
+ bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
+
+ private:
+ bool EnsureTextureSource();
+
+ protected:
+ RefPtr<ID3D11Device> GetDevice();
+
+ bool EnsureTexture();
+
+ RefPtr<ID3D11Texture2D> mTextures[3];
+ RefPtr<DataTextureSourceD3D11> mTextureSources[3];
+
+ gfx::IntSize mSize;
+ gfx::IntSize mSizeY;
+ gfx::IntSize mSizeCbCr;
+ WindowsHandle mHandles[3];
+ bool mIsLocked;
+ gfx::ColorDepth mColorDepth;
+ gfx::YUVColorSpace mYUVColorSpace;
+ gfx::ColorRange mColorRange;
+};
+
+class CompositingRenderTargetD3D11 : public CompositingRenderTarget,
+ public TextureSourceD3D11 {
+ public:
+ CompositingRenderTargetD3D11(
+ ID3D11Texture2D* aTexture, const gfx::IntPoint& aOrigin,
+ DXGI_FORMAT aFormatOverride = DXGI_FORMAT_UNKNOWN);
+
+ const char* Name() const override { return "CompositingRenderTargetD3D11"; }
+
+ TextureSourceD3D11* AsSourceD3D11() override { return this; }
+
+ void BindRenderTarget(ID3D11DeviceContext* aContext);
+
+ gfx::IntSize GetSize() const override;
+
+ void SetSize(const gfx::IntSize& aSize) { mSize = aSize; }
+
+ private:
+ friend class CompositorD3D11;
+ RefPtr<ID3D11RenderTargetView> mRTView;
+};
+
+class SyncObjectD3D11Host : public SyncObjectHost {
+ public:
+ explicit SyncObjectD3D11Host(ID3D11Device* aDevice);
+
+ bool Init() override;
+
+ SyncHandle GetSyncHandle() override;
+
+ bool Synchronize(bool aFallible) override;
+
+ IDXGIKeyedMutex* GetKeyedMutex() { return mKeyedMutex.get(); };
+
+ private:
+ virtual ~SyncObjectD3D11Host() = default;
+
+ SyncHandle mSyncHandle;
+ RefPtr<ID3D11Device> mDevice;
+ RefPtr<IDXGIResource> mSyncTexture;
+ RefPtr<IDXGIKeyedMutex> mKeyedMutex;
+};
+
+class SyncObjectD3D11Client : public SyncObjectClient {
+ public:
+ SyncObjectD3D11Client(SyncHandle aSyncHandle, ID3D11Device* aDevice);
+
+ bool Synchronize(bool aFallible) override;
+
+ bool IsSyncObjectValid() override;
+
+ void EnsureInitialized() override {}
+
+ SyncType GetSyncType() override { return SyncType::D3D11; }
+
+ void RegisterTexture(ID3D11Texture2D* aTexture);
+
+ protected:
+ explicit SyncObjectD3D11Client(SyncHandle aSyncHandle);
+ bool Init(ID3D11Device* aDevice, bool aFallible);
+ bool SynchronizeInternal(ID3D11Device* aDevice, bool aFallible);
+ Mutex mSyncLock MOZ_UNANNOTATED;
+ RefPtr<ID3D11Texture2D> mSyncTexture;
+ std::vector<ID3D11Texture2D*> mSyncedTextures;
+
+ private:
+ const SyncHandle mSyncHandle;
+ RefPtr<IDXGIKeyedMutex> mKeyedMutex;
+ const RefPtr<ID3D11Device> mDevice;
+};
+
+class SyncObjectD3D11ClientContentDevice : public SyncObjectD3D11Client {
+ public:
+ explicit SyncObjectD3D11ClientContentDevice(SyncHandle aSyncHandle);
+
+ bool Synchronize(bool aFallible) override;
+
+ bool IsSyncObjectValid() override;
+
+ void EnsureInitialized() override;
+
+ private:
+ RefPtr<ID3D11Device> mContentDevice;
+};
+
+inline uint32_t GetMaxTextureSizeForFeatureLevel(
+ D3D_FEATURE_LEVEL aFeatureLevel) {
+ int32_t maxTextureSize;
+ switch (aFeatureLevel) {
+ case D3D_FEATURE_LEVEL_11_1:
+ case D3D_FEATURE_LEVEL_11_0:
+ maxTextureSize = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
+ break;
+ case D3D_FEATURE_LEVEL_10_1:
+ case D3D_FEATURE_LEVEL_10_0:
+ maxTextureSize = D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION;
+ break;
+ case D3D_FEATURE_LEVEL_9_3:
+ maxTextureSize = D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION;
+ break;
+ default:
+ maxTextureSize = D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION;
+ }
+ return maxTextureSize;
+}
+
+uint32_t GetMaxTextureSizeFromDevice(ID3D11Device* aDevice);
+void ReportTextureMemoryUsage(ID3D11Texture2D* aTexture, size_t aBytes);
+
+class AutoLockD3D11Texture {
+ public:
+ explicit AutoLockD3D11Texture(ID3D11Texture2D* aTexture);
+ ~AutoLockD3D11Texture();
+
+ private:
+ RefPtr<IDXGIKeyedMutex> mMutex;
+};
+
+class D3D11MTAutoEnter {
+ public:
+ explicit D3D11MTAutoEnter(already_AddRefed<ID3D10Multithread> aMT)
+ : mMT(aMT) {
+ if (mMT) {
+ mMT->Enter();
+ }
+ }
+ ~D3D11MTAutoEnter() {
+ if (mMT) {
+ mMT->Leave();
+ }
+ }
+
+ private:
+ RefPtr<ID3D10Multithread> mMT;
+};
+
+/**
+ * A class to manage ID3D11Texture2Ds that is shared without using shared handle
+ * in GPU process. On some GPUs, ID3D11Texture2Ds of hardware decoded video
+ * frames with zero video frame copy could not use shared handle.
+ */
+class GpuProcessD3D11TextureMap {
+ public:
+ static void Init();
+ static void Shutdown();
+ static GpuProcessD3D11TextureMap* Get() { return sInstance; }
+ static GpuProcessTextureId GetNextTextureId();
+
+ GpuProcessD3D11TextureMap();
+ ~GpuProcessD3D11TextureMap();
+
+ void Register(GpuProcessTextureId aTextureId, ID3D11Texture2D* aTexture,
+ uint32_t aArrayIndex, const gfx::IntSize& aSize,
+ RefPtr<IMFSampleUsageInfo> aUsageInfo);
+ void Unregister(GpuProcessTextureId aTextureId);
+
+ RefPtr<ID3D11Texture2D> GetTexture(GpuProcessTextureId aTextureId);
+ Maybe<HANDLE> GetSharedHandleOfCopiedTexture(GpuProcessTextureId aTextureId);
+
+ private:
+ struct TextureHolder {
+ TextureHolder(ID3D11Texture2D* aTexture, uint32_t aArrayIndex,
+ const gfx::IntSize& aSize,
+ RefPtr<IMFSampleUsageInfo> aUsageInfo);
+ TextureHolder() = default;
+
+ RefPtr<ID3D11Texture2D> mTexture;
+ uint32_t mArrayIndex = 0;
+ gfx::IntSize mSize;
+ RefPtr<IMFSampleUsageInfo> mIMFSampleUsageInfo;
+ RefPtr<ID3D11Texture2D> mCopiedTexture;
+ Maybe<HANDLE> mCopiedTextureSharedHandle;
+ };
+
+ DataMutex<std::unordered_map<GpuProcessTextureId, TextureHolder,
+ GpuProcessTextureId::HashFn>>
+ mD3D11TexturesById;
+
+ static StaticAutoPtr<GpuProcessD3D11TextureMap> sInstance;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif /* MOZILLA_GFX_TEXTURED3D11_H */
diff --git a/gfx/layers/d3d11/genshaders.py b/gfx/layers/d3d11/genshaders.py
new file mode 100644
index 0000000000..b9701978d5
--- /dev/null
+++ b/gfx/layers/d3d11/genshaders.py
@@ -0,0 +1,176 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+import argparse
+import codecs
+import locale
+import os
+import re
+import subprocess
+import sys
+import tempfile
+
+import buildconfig
+import yaml
+
+
+def shell_main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument("-o", "--output", type=str, required=True, help="Output file")
+ parser.add_argument("manifest", type=str, help="Manifest source file")
+ args = parser.parse_args()
+
+ with open(args.output, "w") as out_file:
+ process_manifest(out_file, args.manifest)
+
+
+def main(output_fp, input_filename):
+ return process_manifest(output_fp, input_filename)
+
+
+HEADER = """// AUTOGENERATED - DO NOT EDIT
+namespace mozilla {
+namespace layers {
+
+struct ShaderBytes { const void* mData; size_t mLength; };
+"""
+FOOTER = """
+} // namespace layers
+} // namespace mozilla"""
+
+
+def process_manifest(output_fp, manifest_filename):
+ with codecs.open(manifest_filename, "r", "UTF-8") as in_fp:
+ manifest = yaml.safe_load(in_fp)
+ shader_folder, _ = os.path.split(manifest_filename)
+
+ output_fp.write(HEADER)
+
+ deps = set()
+ for block in manifest:
+ if "type" not in block:
+ raise Exception("Expected 'type' key with shader mode")
+ if "file" not in block:
+ raise Exception("Expected 'file' key with shader file")
+ if "shaders" not in block:
+ raise Exception("Expected 'shaders' key with shader name list")
+
+ shader_file = os.path.join(shader_folder, block["file"])
+ deps.add(shader_file)
+
+ shader_model = block["type"]
+ for shader_name in block["shaders"]:
+ new_deps = run_fxc(
+ shader_model=shader_model,
+ shader_file=shader_file,
+ shader_name=shader_name,
+ output_fp=output_fp,
+ )
+ deps |= new_deps
+
+ output_fp.write(FOOTER)
+ return deps
+
+
+def run_fxc(shader_model, shader_file, shader_name, output_fp):
+ fxc_location = buildconfig.substs["FXC"]
+
+ argv = [
+ fxc_location,
+ "-nologo",
+ "-T{0}".format(shader_model),
+ os.path.relpath(shader_file),
+ "-E{0}".format(shader_name),
+ "-Vn{0}".format(shader_name),
+ "-Vi",
+ ]
+ if "WINNT" not in buildconfig.substs["HOST_OS_ARCH"]:
+ argv.insert(0, buildconfig.substs["WINE"])
+ if shader_model.startswith("vs_"):
+ argv += ["-DVERTEX_SHADER"]
+ elif shader_model.startswith("ps_"):
+ argv += ["-DPIXEL_SHADER"]
+
+ deps = None
+ with ScopedTempFilename() as temp_filename:
+ argv += ["-Fh{0}".format(os.path.relpath(temp_filename))]
+
+ sys.stdout.write("{0}\n".format(" ".join(argv)))
+ sys.stdout.flush()
+ proc_stdout = subprocess.check_output(argv)
+ proc_stdout = decode_console_text(sys.stdout, proc_stdout)
+ deps = find_dependencies(proc_stdout)
+ assert "fxc2" in fxc_location or len(deps) > 0
+
+ with open(temp_filename, "r") as temp_fp:
+ output_fp.write(temp_fp.read())
+
+ output_fp.write("ShaderBytes s{0} = {{ {0}, sizeof({0}) }};\n".format(shader_name))
+ return deps
+
+
+def find_dependencies(fxc_output):
+ # Dependencies look like this:
+ # Resolved to [<path>]
+ #
+ # Microsoft likes to change output strings based on the user's language, so
+ # instead of pattern matching on that string, we take everything in between
+ # brackets. We filter out potentially bogus strings later.
+ deps = set()
+ for line in fxc_output.split("\n"):
+ m = re.search(r"\[([^\]]+)\]", line)
+ if m is None:
+ continue
+ dep_path = m.group(1)
+ dep_path = os.path.normpath(dep_path)
+ # When run via Wine, FXC's output contains Windows paths on the Z drive.
+ # We want to normalize them back to unix paths for the build system.
+ if "WINNT" not in buildconfig.substs[
+ "HOST_OS_ARCH"
+ ] and dep_path.lower().startswith("z:"):
+ dep_path = dep_path[2:].replace("\\", "/")
+ if os.path.isfile(dep_path):
+ deps.add(dep_path)
+ return deps
+
+
+# Python reads the raw bytes from stdout, so we need to try our best to
+# capture that as a valid Python string.
+
+
+def decode_console_text(pipe, text):
+ try:
+ if pipe.encoding:
+ return text.decode(pipe.encoding, "replace")
+ except Exception:
+ pass
+ try:
+ return text.decode(locale.getpreferredencoding(), "replace")
+ except Exception:
+ return text.decode("utf8", "replace")
+
+
+# Allocate a temporary file name and delete it when done. We need an extra
+# wrapper for this since TemporaryNamedFile holds the file open.
+
+
+class ScopedTempFilename(object):
+ def __init__(self):
+ self.name = None
+
+ def __enter__(self):
+ with tempfile.NamedTemporaryFile(dir=os.getcwd(), delete=False) as tmp:
+ self.name = tmp.name
+ return self.name
+
+ def __exit__(self, type, value, traceback):
+ if not self.name:
+ return
+ try:
+ os.unlink(self.name)
+ except Exception:
+ pass
+
+
+if __name__ == "__main__":
+ shell_main()
diff --git a/gfx/layers/d3d11/shaders.manifest b/gfx/layers/d3d11/shaders.manifest
new file mode 100644
index 0000000000..d8836d2740
--- /dev/null
+++ b/gfx/layers/d3d11/shaders.manifest
@@ -0,0 +1,13 @@
+- type: vs_4_0_level_9_3
+ file: CompositorD3D11.hlsl
+ shaders:
+ - LayerQuadVS
+
+- type: ps_4_0_level_9_3
+ file: CompositorD3D11.hlsl
+ shaders:
+ - SolidColorShader
+ - RGBShader
+ - RGBAShader
+ - YCbCrShader
+ - NV12Shader
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-02 08:09:56 +0000