mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Back out bug 830347.

This commit is contained in:
Kyle Huey 2013-05-08 12:04:11 -07:00
Родитель 689f180c53
Коммит de21211adf
24 изменённых файлов: 91 добавлений и 6658 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
gfx/layers/LayersTypes.h
Просмотреть файл

@ -37,7 +37,6 @@ enum LayersBackend {
LAYERS_OPENGL,
LAYERS_D3D9,
LAYERS_D3D10,
LAYERS_D3D11,
LAYERS_CLIENT,
LAYERS_LAST
};

3
gfx/layers/Makefile.in
Просмотреть файл

@ -14,7 +14,6 @@ VPATH = \
$(srcdir)/opengl \
$(srcdir)/d3d9 \
$(srcdir)/d3d10 \
$(srcdir)/d3d11 \
$(srcdir)/ipc \
$(NULL)
@ -98,13 +97,11 @@ ifdef MOZ_ENABLE_D3D10_LAYER
CPPSRCS += \
CanvasLayerD3D10.cpp \
ColorLayerD3D10.cpp \
CompositorD3D11.cpp \
ContainerLayerD3D10.cpp \
ImageLayerD3D10.cpp \
LayerManagerD3D10.cpp \
ReadbackManagerD3D10.cpp \
ShadowLayerUtilsD3D10.cpp \
TextureD3D11.cpp \
ThebesLayerD3D10.cpp \
$(NULL)
endif

17
gfx/layers/client/CompositableClient.cpp
Просмотреть файл

@ -8,10 +8,6 @@
#include "mozilla/layers/TextureClientOGL.h"
#include "mozilla/layers/LayerTransactionChild.h"
#include "mozilla/layers/CompositableForwarder.h"
#ifdef XP_WIN
#include "mozilla/layers/TextureD3D11.h"
#include "gfxWindowsPlatform.h"
#endif
namespace mozilla {
namespace layers {
@ -100,20 +96,17 @@ CompositableClient::CreateTextureClient(TextureClientType aTextureClientType)
}
break;
case TEXTURE_YCBCR:
if (parentBackend == LAYERS_OPENGL || parentBackend == LAYERS_D3D11) {
if (parentBackend == LAYERS_OPENGL) {
result = new TextureClientShmemYCbCr(GetForwarder(), GetTextureInfo());
}
break;
case TEXTURE_CONTENT:
#ifdef XP_WIN
if (parentBackend == LAYERS_D3D11 && gfxWindowsPlatform::GetPlatform()->GetD2DDevice()) {
result = new TextureClientD3D11(GetForwarder(), GetTextureInfo());
break;
}
#endif
// fall through to TEXTURE_SHMEM
case TEXTURE_SHMEM:
result = new TextureClientShmem(GetForwarder(), GetTextureInfo());
if (parentBackend == LAYERS_OPENGL ||
parentBackend == LAYERS_BASIC) {
result = new TextureClientShmem(GetForwarder(), GetTextureInfo());
}
break;
default:
MOZ_ASSERT(false, "Unhandled texture client type");

21
gfx/layers/client/ContentClient.cpp
Просмотреть файл

@ -10,9 +10,6 @@
#include "gfxUtils.h"
#include "gfxPlatform.h"
#include "mozilla/layers/LayerManagerComposite.h"
#ifdef XP_WIN
#include "gfxWindowsPlatform.h"
#endif
namespace mozilla {
@ -24,23 +21,11 @@ namespace layers {
ContentClient::CreateContentClient(CompositableForwarder* aForwarder)
{
if (aForwarder->GetCompositorBackendType() != LAYERS_OPENGL &&
aForwarder->GetCompositorBackendType() != LAYERS_D3D11 &&
aForwarder->GetCompositorBackendType() != LAYERS_BASIC) {
return nullptr;
return nullptr;
}
bool useDoubleBuffering = false;
#ifdef XP_WIN
if (aForwarder->GetCompositorBackendType() == LAYERS_D3D11) {
useDoubleBuffering = !!gfxWindowsPlatform::GetPlatform()->GetD2DDevice();
} else
#endif
{
useDoubleBuffering = LayerManagerComposite::SupportsDirectTexturing();
}
if (useDoubleBuffering || PR_GetEnv("MOZ_FORCE_DOUBLE_BUFFERING")) {
if (LayerManagerComposite::SupportsDirectTexturing() ||
PR_GetEnv("MOZ_FORCE_DOUBLE_BUFFERING")) {
return new ContentClientDoubleBuffered(aForwarder);
}
return new ContentClientSingleBuffered(aForwarder);

32
gfx/layers/client/ImageClient.cpp
Просмотреть файл

@ -28,13 +28,19 @@ ImageClient::CreateImageClient(CompositableType aCompositableHostType,
RefPtr<ImageClient> result = nullptr;
switch (aCompositableHostType) {
case BUFFER_IMAGE_SINGLE:
result = new ImageClientSingle(aForwarder, aFlags, BUFFER_IMAGE_SINGLE);
if (ImageClientSingle::SupportsBackend(aForwarder->GetCompositorBackendType())) {
result = new ImageClientSingle(aForwarder, aFlags, BUFFER_IMAGE_SINGLE);
}
break;
case BUFFER_IMAGE_BUFFERED:
result = new ImageClientSingle(aForwarder, aFlags, BUFFER_IMAGE_BUFFERED);
if (ImageClientSingle::SupportsBackend(aForwarder->GetCompositorBackendType())) {
result = new ImageClientSingle(aForwarder, aFlags, BUFFER_IMAGE_BUFFERED);
}
break;
case BUFFER_BRIDGE:
result = new ImageClientBridge(aForwarder, aFlags);
if (ImageClientBridge::SupportsBackend(aForwarder->GetCompositorBackendType())) {
result = new ImageClientBridge(aForwarder, aFlags);
}
break;
case BUFFER_UNKNOWN:
result = nullptr;
@ -218,6 +224,26 @@ ImageClientSingle::Updated()
mForwarder->UpdateTexture(this, 1, mTextureClient->GetDescriptor());
}
bool
ImageClientSingle::SupportsBackend(LayersBackend aBackend)
{
if (aBackend == LAYERS_OPENGL ||
aBackend == LAYERS_BASIC) {
return true;
}
return false;
}
bool
ImageClientBridge::SupportsBackend(LayersBackend aBackend)
{
if (aBackend == LAYERS_OPENGL ||
aBackend == LAYERS_BASIC) {
return true;
}
return false;
}
ImageClientBridge::ImageClientBridge(CompositableForwarder* aFwd,
TextureFlags aFlags)
: ImageClient(aFwd, BUFFER_BRIDGE)

4
gfx/layers/client/ImageClient.h
Просмотреть файл

@ -102,6 +102,8 @@ public:
return mTextureInfo;
}
static bool SupportsBackend(LayersBackend aBackend);
private:
RefPtr<TextureClient> mTextureClient;
TextureInfo mTextureInfo;
@ -131,6 +133,8 @@ public:
return TextureInfo(mType);
}
static bool SupportsBackend(LayersBackend aBackend);
protected:
uint64_t mAsyncContainerID;
ShadowableLayer* mLayer;

12
gfx/layers/composite/TextureHost.cpp
Просмотреть файл

@ -28,12 +28,6 @@ TemporaryRef<TextureHost> CreateTextureHostD3D9(SurfaceDescriptorType aDescripto
return nullptr;
}
#ifdef XP_WIN
TemporaryRef<TextureHost> CreateTextureHostD3D11(SurfaceDescriptorType aDescriptorType,
uint32_t aTextureHostFlags,
uint32_t aTextureFlags);
#endif
/* static */ TemporaryRef<TextureHost>
TextureHost::CreateTextureHost(SurfaceDescriptorType aDescriptorType,
uint32_t aTextureHostFlags,
@ -48,12 +42,6 @@ TextureHost::CreateTextureHost(SurfaceDescriptorType aDescriptorType,
return CreateTextureHostD3D9(aDescriptorType,
aTextureHostFlags,
aTextureFlags);
#ifdef XP_WIN
case LAYERS_D3D11:
return CreateTextureHostD3D11(aDescriptorType,
aTextureHostFlags,
aTextureFlags);
#endif
case LAYERS_BASIC:
return CreateBasicTextureHost(aDescriptorType,
aTextureHostFlags,

6
gfx/layers/composite/TextureHost.h
Просмотреть файл

@ -25,7 +25,6 @@ class Compositor;
class SurfaceDescriptor;
class ISurfaceAllocator;
class TextureSourceOGL;
class TextureSourceD3D11;
class TextureSourceBasic;
class TextureParent;
@ -79,11 +78,6 @@ public:
*/
virtual TextureSourceOGL* AsSourceOGL() { return nullptr; }
/**
* Cast to an TextureSource for the D3D11 backend.
*/
virtual TextureSourceD3D11* AsSourceD3D11() { return nullptr; }
virtual TextureSourceBasic* AsSourceBasic() { return nullptr; }
/**

782
gfx/layers/d3d11/CompositorD3D11.cpp
Просмотреть файл

@ -1,782 +0,0 @@
/* -*- 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 "CompositorD3D11.h"
#include "TextureD3D11.h"
#include "CompositorD3D11Shaders.h"
#include "gfxWindowsPlatform.h"
#include "nsIWidget.h"
#include "mozilla/layers/ImageHost.h"
#include "mozilla/layers/ContentHost.h"
#include "mozilla/layers/Effects.h"
#include "nsWindowsHelpers.h"
#ifdef MOZ_METRO
#include <DXGI1_2.h>
#endif
namespace mozilla {
using namespace gfx;
namespace layers {
struct Vertex
{
float position[2];
};
// {1E4D7BEB-D8EC-4A0B-BF0A-63E6DE129425}
static const GUID sDeviceAttachmentsD3D11 =
{ 0x1e4d7beb, 0xd8ec, 0x4a0b, { 0xbf, 0xa, 0x63, 0xe6, 0xde, 0x12, 0x94, 0x25 } };
// {88041664-C835-4AA8-ACB8-7EC832357ED8}
static const GUID sLayerManagerCount =
{ 0x88041664, 0xc835, 0x4aa8, { 0xac, 0xb8, 0x7e, 0xc8, 0x32, 0x35, 0x7e, 0xd8 } };
const FLOAT sBlendFactor[] = { 0, 0, 0, 0 };
struct DeviceAttachmentsD3D11
{
RefPtr<ID3D11InputLayout> mInputLayout;
RefPtr<ID3D11Buffer> mVertexBuffer;
RefPtr<ID3D11VertexShader> mVSQuadShader[3];
RefPtr<ID3D11PixelShader> mSolidColorShader[2];
RefPtr<ID3D11PixelShader> mRGBAShader[3];
RefPtr<ID3D11PixelShader> mRGBShader[2];
RefPtr<ID3D11PixelShader> mYCbCrShader[2];
RefPtr<ID3D11Buffer> mPSConstantBuffer;
RefPtr<ID3D11Buffer> mVSConstantBuffer;
RefPtr<ID3D11RasterizerState> mRasterizerState;
RefPtr<ID3D11SamplerState> mLinearSamplerState;
RefPtr<ID3D11SamplerState> mPointSamplerState;
RefPtr<ID3D11BlendState> mPremulBlendState;
RefPtr<ID3D11BlendState> mNonPremulBlendState;
};
CompositorD3D11::CompositorD3D11(nsIWidget *aWidget)
: mWidget(aWidget)
, mAttachments(nullptr)
{
sBackend = LAYERS_D3D11;
}
CompositorD3D11::~CompositorD3D11()
{
if (mDevice) {
int referenceCount = 0;
UINT size = sizeof(referenceCount);
HRESULT hr = mDevice->GetPrivateData(sLayerManagerCount, &size, &referenceCount);
NS_ASSERTION(SUCCEEDED(hr), "Reference count not found on device.");
referenceCount--;
mDevice->SetPrivateData(sLayerManagerCount, sizeof(referenceCount), &referenceCount);
if (!referenceCount) {
DeviceAttachmentsD3D11 *attachments;
size = sizeof(attachments);
mDevice->GetPrivateData(sDeviceAttachmentsD3D11, &size, &attachments);
// No LayerManagers left for this device. Clear out interfaces stored which
// hold a reference to the device.
mDevice->SetPrivateData(sDeviceAttachmentsD3D11, 0, NULL);
delete attachments;
}
}
}
bool
CompositorD3D11::Initialize()
{
HRESULT hr;
mDevice = gfxWindowsPlatform::GetPlatform()->GetD3D11Device();
if (!mDevice) {
return false;
}
mDevice->GetImmediateContext(byRef(mContext));
if (!mContext) {
return false;
}
memset(&mVSConstants, 0, sizeof(VertexShaderConstants));
int referenceCount = 0;
UINT size = sizeof(referenceCount);
// If this isn't there yet it'll fail, count will remain 0, which is correct.
mDevice->GetPrivateData(sLayerManagerCount, &size, &referenceCount);
referenceCount++;
mDevice->SetPrivateData(sLayerManagerCount, sizeof(referenceCount), &referenceCount);
size = sizeof(DeviceAttachmentsD3D11*);
if (FAILED(mDevice->GetPrivateData(sDeviceAttachmentsD3D11, &size, &mAttachments))) {
mAttachments = new DeviceAttachmentsD3D11;
mDevice->SetPrivateData(sDeviceAttachmentsD3D11, sizeof(mAttachments), &mAttachments);
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = mDevice->CreateInputLayout(layout,
sizeof(layout) / sizeof(D3D11_INPUT_ELEMENT_DESC),
LayerQuadVS,
sizeof(LayerQuadVS),
byRef(mAttachments->mInputLayout));
if (FAILED(hr)) {
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, byRef(mAttachments->mVertexBuffer));
if (FAILED(hr)) {
return false;
}
if (!CreateShaders()) {
return false;
}
CD3D11_BUFFER_DESC cBufferDesc(sizeof(VertexShaderConstants), D3D11_BIND_CONSTANT_BUFFER,
D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
hr = mDevice->CreateBuffer(&cBufferDesc, nullptr, byRef(mAttachments->mVSConstantBuffer));
if (FAILED(hr)) {
return false;
}
cBufferDesc.ByteWidth = sizeof(PixelShaderConstants);
hr = mDevice->CreateBuffer(&cBufferDesc, nullptr, byRef(mAttachments->mPSConstantBuffer));
if (FAILED(hr)) {
return false;
}
CD3D11_RASTERIZER_DESC rastDesc(D3D11_DEFAULT);
rastDesc.CullMode = D3D11_CULL_NONE;
rastDesc.ScissorEnable = TRUE;
hr = mDevice->CreateRasterizerState(&rastDesc, byRef(mAttachments->mRasterizerState));
if (FAILED(hr)) {
return false;
}
CD3D11_SAMPLER_DESC samplerDesc(D3D11_DEFAULT);
samplerDesc.AddressU = samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
hr = mDevice->CreateSamplerState(&samplerDesc, byRef(mAttachments->mLinearSamplerState));
if (FAILED(hr)) {
return false;
}
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
hr = mDevice->CreateSamplerState(&samplerDesc, byRef(mAttachments->mPointSamplerState));
if (FAILED(hr)) {
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, byRef(mAttachments->mPremulBlendState));
if (FAILED(hr)) {
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, byRef(mAttachments->mNonPremulBlendState));
if (FAILED(hr)) {
return false;
}
}
nsRefPtr<IDXGIDevice> dxgiDevice;
nsRefPtr<IDXGIAdapter> dxgiAdapter;
mDevice->QueryInterface(dxgiDevice.StartAssignment());
dxgiDevice->GetAdapter(getter_AddRefs(dxgiAdapter));
#ifdef MOZ_METRO
if (IsRunningInWindowsMetro()) {
nsRefPtr<IDXGIFactory2> dxgiFactory;
dxgiAdapter->GetParent(IID_PPV_ARGS(dxgiFactory.StartAssignment()));
nsIntRect rect;
mWidget->GetClientBounds(rect);
DXGI_SWAP_CHAIN_DESC1 swapDesc = { 0 };
// Automatically detect the width and the height from the winrt CoreWindow
swapDesc.Width = rect.width;
swapDesc.Height = rect.height;
// This is the most common swapchain format
swapDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
swapDesc.Stereo = false;
// Don't use multi-sampling
swapDesc.SampleDesc.Count = 1;
swapDesc.SampleDesc.Quality = 0;
swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Use double buffering to enable flip
swapDesc.BufferCount = 2;
swapDesc.Scaling = DXGI_SCALING_STRETCH;
// All Metro style apps must use this SwapEffect
swapDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
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.
*/
nsRefPtr<IDXGISwapChain1> swapChain1;
hr = dxgiFactory->CreateSwapChainForCoreWindow(
dxgiDevice, (IUnknown *)mWidget->GetNativeData(NS_NATIVE_ICOREWINDOW),
&swapDesc, nullptr, getter_AddRefs(swapChain1));
if (FAILED(hr)) {
return false;
}
mSwapChain = swapChain1;
} else
#endif
{
nsRefPtr<IDXGIFactory> dxgiFactory;
dxgiAdapter->GetParent(IID_PPV_ARGS(dxgiFactory.StartAssignment()));
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 = (HWND)mWidget->GetNativeData(NS_NATIVE_WINDOW);
swapDesc.Windowed = TRUE;
// We don't really need this flag, however it seems on some NVidia hardware
// smaller area windows do not present properly without this flag. This flag
// should have no negative consequences by itself. See bug 613790. This flag
// is broken on optimus devices. As a temporary solution we don't set it
// there, the only way of reliably detecting we're on optimus is looking for
// the DLL. See Bug 623807.
if (gfxWindowsPlatform::IsOptimus()) {
swapDesc.Flags = 0;
} else {
swapDesc.Flags = DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE;
}
/**
* 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, byRef(mSwapChain));
if (FAILED(hr)) {
return false;
}
// We need this because we don't want DXGI to respond to Alt+Enter.
dxgiFactory->MakeWindowAssociation(swapDesc.OutputWindow, DXGI_MWA_NO_WINDOW_CHANGES);
}
return true;
}
TextureFactoryIdentifier
CompositorD3D11::GetTextureFactoryIdentifier()
{
TextureFactoryIdentifier ident;
ident.mMaxTextureSize = GetMaxTextureSize();
ident.mParentBackend = LAYERS_D3D11;
return ident;
}
bool
CompositorD3D11::CanUseCanvasLayerForSize(const gfxIntSize &aSize)
{
int32_t maxTextureSize = GetMaxTextureSize();
if (aSize.width > maxTextureSize || aSize.height > maxTextureSize) {
return false;
}
return true;
}
int32_t
CompositorD3D11::GetMaxTextureSize() const
{
return GetMaxTextureSizeForFeatureLevel(mFeatureLevel);
}
TemporaryRef<CompositingRenderTarget>
CompositorD3D11::CreateRenderTarget(const gfx::IntRect &aRect,
SurfaceInitMode aInit)
{
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;
mDevice->CreateTexture2D(&desc, NULL, byRef(texture));
RefPtr<CompositingRenderTargetD3D11> rt = new CompositingRenderTargetD3D11(texture);
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;
}
// TODO[Bas] this method doesn't actually use aSource
TemporaryRef<CompositingRenderTarget>
CompositorD3D11::CreateRenderTargetFromSource(const gfx::IntRect &aRect,
const CompositingRenderTarget *aSource)
{
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;
mDevice->CreateTexture2D(&desc, NULL, byRef(texture));
RefPtr<CompositingRenderTargetD3D11> rt = new CompositingRenderTargetD3D11(texture);
rt->SetSize(IntSize(aRect.width, aRect.height));
return rt;
}
void
CompositorD3D11::SetRenderTarget(CompositingRenderTarget *aRenderTarget)
{
MOZ_ASSERT(aRenderTarget);
CompositingRenderTargetD3D11 *newRT =
static_cast<CompositingRenderTargetD3D11*>(aRenderTarget);
ID3D11RenderTargetView *view = newRT->mRTView;
mCurrentRT = newRT;
mContext->OMSetRenderTargets(1, &view, nullptr);
PrepareViewport(newRT->GetSize(), gfxMatrix());
}
void
CompositorD3D11::SetPSForEffect(Effect *aEffect, MaskMode aMaskMode)
{
switch (aEffect->mType) {
case EFFECT_SOLID_COLOR:
mContext->PSSetShader(mAttachments->mSolidColorShader[aMaskMode], nullptr, 0);
return;
case EFFECT_BGRA:
case EFFECT_RENDER_TARGET:
mContext->PSSetShader(mAttachments->mRGBAShader[aMaskMode], nullptr, 0);
return;
case EFFECT_BGRX:
mContext->PSSetShader(mAttachments->mRGBShader[aMaskMode], nullptr, 0);
return;
case EFFECT_YCBCR:
mContext->PSSetShader(mAttachments->mYCbCrShader[aMaskMode], nullptr, 0);
return;
}
}
void
CompositorD3D11::DrawQuad(const gfx::Rect &aRect, const gfx::Rect &aClipRect,
const EffectChain &aEffectChain,
gfx::Float aOpacity, const gfx::Matrix4x4 &aTransform,
const gfx::Point &aOffset)
{
MOZ_ASSERT(mCurrentRT, "No render target");
memcpy(&mVSConstants.layerTransform, &aTransform._11, 64);
mVSConstants.renderTargetOffset[0] = aOffset.x;
mVSConstants.renderTargetOffset[1] = aOffset.y;
mVSConstants.layerQuad = aRect;
mPSConstants.layerOpacity[0] = aOpacity;
bool isPremultiplied = true;
MaskMode maskMode = UNMASKED;
if (aEffectChain.mSecondaryEffects[EFFECT_MASK]) {
if (aTransform.Is2D()) {
maskMode = MASKED;
} else {
MOZ_ASSERT(aEffectChain.mPrimaryEffect->mType == EFFECT_BGRA);
maskMode = MASKED3D;
}
EffectMask *maskEffect = static_cast<EffectMask*>(aEffectChain.mSecondaryEffects[EFFECT_MASK].get());
TextureSourceD3D11 *source = maskEffect->mMaskTexture->AsSourceD3D11();
RefPtr<ID3D11ShaderResourceView> view;
mDevice->CreateShaderResourceView(source->GetD3D11Texture(), nullptr, byRef(view));
ID3D11ShaderResourceView *srView = view;
mContext->PSSetShaderResources(3, 1, &srView);
const gfx::Matrix4x4& maskTransform = maskEffect->mMaskTransform;
NS_ASSERTION(maskTransform.Is2D(), "How did we end up with a 3D transform here?!");
Rect bounds = Rect(Point(), Size(maskEffect->mSize));
mVSConstants.maskQuad = maskTransform.As2D().TransformBounds(bounds);
}
D3D11_RECT scissor;
scissor.left = aClipRect.x;
scissor.right = aClipRect.XMost();
scissor.top = aClipRect.y;
scissor.bottom = aClipRect.YMost();
mContext->RSSetScissorRects(1, &scissor);
mContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
mContext->VSSetShader(mAttachments->mVSQuadShader[maskMode], nullptr, 0);
SetPSForEffect(aEffectChain.mPrimaryEffect, maskMode);
switch (aEffectChain.mPrimaryEffect->mType) {
case EFFECT_SOLID_COLOR: {
Color color =
static_cast<EffectSolidColor*>(aEffectChain.mPrimaryEffect.get())->mColor;
mPSConstants.layerColor[0] = color.r * color.a * aOpacity;
mPSConstants.layerColor[1] = color.g * color.a * aOpacity;
mPSConstants.layerColor[2] = color.b * color.a * aOpacity;
mPSConstants.layerColor[3] = color.a * aOpacity;
}
break;
case EFFECT_BGRX:
case EFFECT_BGRA:
case EFFECT_RENDER_TARGET:
{
TexturedEffect *texturedEffect = static_cast<TexturedEffect*>(aEffectChain.mPrimaryEffect.get());
mVSConstants.textureCoords = texturedEffect->mTextureCoords;
TextureSourceD3D11 *source = texturedEffect->mTexture->AsSourceD3D11();
RefPtr<ID3D11ShaderResourceView> view;
mDevice->CreateShaderResourceView(source->GetD3D11Texture(), nullptr, byRef(view));
ID3D11ShaderResourceView *srView = view;
mContext->PSSetShaderResources(0, 1, &srView);
isPremultiplied = texturedEffect->mPremultiplied;
SetSamplerForFilter(texturedEffect->mFilter);
}
break;
case EFFECT_YCBCR: {
EffectYCbCr *ycbcrEffect = static_cast<EffectYCbCr*>(aEffectChain.mPrimaryEffect.get());
SetSamplerForFilter(FILTER_LINEAR);
mVSConstants.textureCoords = ycbcrEffect->mTextureCoords;
TextureSourceD3D11 *source = ycbcrEffect->mTexture->AsSourceD3D11();
TextureSourceD3D11::YCbCrTextures textures = source->GetYCbCrTextures();
RefPtr<ID3D11ShaderResourceView> views[3];
mDevice->CreateShaderResourceView(textures.mY, nullptr, byRef(views[0]));
mDevice->CreateShaderResourceView(textures.mCb, nullptr, byRef(views[1]));
mDevice->CreateShaderResourceView(textures.mCr, nullptr, byRef(views[2]));
ID3D11ShaderResourceView *srViews[3] = { views[0], views[1], views[2] };
mContext->PSSetShaderResources(0, 3, srViews);
}
break;
default:
return;
}
UpdateConstantBuffers();
if (!isPremultiplied) {
mContext->OMSetBlendState(mAttachments->mNonPremulBlendState, sBlendFactor, 0xFFFFFFFF);
}
mContext->Draw(4, 0);
if (!isPremultiplied) {
mContext->OMSetBlendState(mAttachments->mPremulBlendState, sBlendFactor, 0xFFFFFFFF);
}
}
void
CompositorD3D11::BeginFrame(const Rect *aClipRectIn,
const gfxMatrix& aTransform,
const Rect& aRenderBounds,
Rect *aClipRectOut,
Rect *aRenderBoundsOut)
{
VerifyBufferSize();
UpdateRenderTarget();
nsIntRect rect;
mWidget->GetClientBounds(rect);
if (rect.IsEmpty()) {
*aRenderBoundsOut = Rect();
return;
}
mDefaultRT->SetSize(IntSize(rect.width, rect.height));
mContext->IASetInputLayout(mAttachments->mInputLayout);
ID3D11Buffer *buffer = mAttachments->mVertexBuffer;
UINT size = sizeof(Vertex);
UINT offset = 0;
mContext->IASetVertexBuffers(0, 1, &buffer, &size, &offset);
SetRenderTarget(mDefaultRT);
if (aClipRectOut) {
*aClipRectOut = Rect(0, 0, rect.width, rect.height);
}
if (aRenderBoundsOut) {
*aRenderBoundsOut = Rect(0, 0, rect.width, rect.height);
}
FLOAT black[] = { 0, 0, 0, 0 };
mContext->ClearRenderTargetView(mDefaultRT->mRTView, black);
mContext->OMSetBlendState(mAttachments->mPremulBlendState, sBlendFactor, 0xFFFFFFFF);
mContext->RSSetState(mAttachments->mRasterizerState);
}
void
CompositorD3D11::EndFrame()
{
mContext->Flush();
mSwapChain->Present(0, 0);
if (mTarget) {
PaintToTarget();
}
mCurrentRT = nullptr;
}
void
CompositorD3D11::PrepareViewport(const gfx::IntSize& aSize,
const gfxMatrix &aWorldTransform)
{
D3D11_VIEWPORT viewport;
viewport.MaxDepth = 1.0f;
viewport.MinDepth = 0;
viewport.Width = aSize.width;
viewport.Height = aSize.height;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
mContext->RSSetViewports(1, &viewport);
gfxMatrix viewMatrix;
viewMatrix.Translate(-gfxPoint(1.0, -1.0));
viewMatrix.Scale(2.0f / float(aSize.width), 2.0f / float(aSize.height));
viewMatrix.Scale(1.0f, -1.0f);
viewMatrix = aWorldTransform * viewMatrix;
gfx3DMatrix projection = gfx3DMatrix::From2D(viewMatrix);
projection._33 = 0.0f;
memcpy(&mVSConstants.projection, &projection, sizeof(mVSConstants.projection));
}
const nsIntSize&
CompositorD3D11::GetWidgetSize()
{
nsIntRect rect;
mWidget->GetClientBounds(rect);
mSize = rect.Size();
return mSize;
}
void
CompositorD3D11::VerifyBufferSize()
{
nsIntRect rect;
mWidget->GetClientBounds(rect);
DXGI_SWAP_CHAIN_DESC swapDesc;
mSwapChain->GetDesc(&swapDesc);
if ((swapDesc.BufferDesc.Width == rect.width &&
swapDesc.BufferDesc.Height == rect.height) || rect.IsEmpty()) {
return;
}
mDefaultRT = nullptr;
if (gfxWindowsPlatform::IsOptimus()) {
mSwapChain->ResizeBuffers(1, rect.width, rect.height,
DXGI_FORMAT_B8G8R8A8_UNORM,
0);
} else if (IsRunningInWindowsMetro()) {
mSwapChain->ResizeBuffers(2, rect.width, rect.height,
DXGI_FORMAT_B8G8R8A8_UNORM,
0);
} else {
mSwapChain->ResizeBuffers(1, rect.width, rect.height,
DXGI_FORMAT_B8G8R8A8_UNORM,
DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE);
}
}
void
CompositorD3D11::UpdateRenderTarget()
{
if (mDefaultRT) {
return;
}
HRESULT hr;
nsRefPtr<ID3D11Texture2D> backBuf;
hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)backBuf.StartAssignment());
if (FAILED(hr)) {
return;
}
mDefaultRT = new CompositingRenderTargetD3D11(nullptr);
mDevice->CreateRenderTargetView(backBuf, NULL, byRef(mDefaultRT->mRTView));
}
bool
CompositorD3D11::CreateShaders()
{
HRESULT hr;
hr = mDevice->CreateVertexShader(LayerQuadVS, sizeof(LayerQuadVS), nullptr, byRef(mAttachments->mVSQuadShader[UNMASKED]));
if (FAILED(hr)) {
return false;
}
hr = mDevice->CreateVertexShader(LayerQuadMaskVS, sizeof(LayerQuadMaskVS), nullptr, byRef(mAttachments->mVSQuadShader[MASKED]));
if (FAILED(hr)) {
return false;
}
hr = mDevice->CreateVertexShader(LayerQuadMask3DVS, sizeof(LayerQuadMask3DVS), nullptr, byRef(mAttachments->mVSQuadShader[MASKED3D]));
if (FAILED(hr)) {
return false;
}
#define LOAD_PIXEL_SHADER(x) hr = mDevice->CreatePixelShader(x, sizeof(x), nullptr, byRef(mAttachments->m##x[UNMASKED])); \
if (FAILED(hr)) { \
return false; \
} \
hr = mDevice->CreatePixelShader(x##Mask, sizeof(x##Mask), nullptr, byRef(mAttachments->m##x[MASKED])); \
if (FAILED(hr)) { \
return false; \
}
LOAD_PIXEL_SHADER(SolidColorShader);
LOAD_PIXEL_SHADER(RGBShader);
LOAD_PIXEL_SHADER(RGBAShader);
LOAD_PIXEL_SHADER(YCbCrShader);
#undef LOAD_PIXEL_SHADER
hr = mDevice->CreatePixelShader(RGBAShaderMask3D, sizeof(RGBAShaderMask3D), nullptr, byRef(mAttachments->mRGBAShader[MASKED3D]));
if (FAILED(hr)) {
return false;
}
return true;
}
void
CompositorD3D11::UpdateConstantBuffers()
{
D3D11_MAPPED_SUBRESOURCE resource;
mContext->Map(mAttachments->mVSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &resource);
*(VertexShaderConstants*)resource.pData = mVSConstants;
mContext->Unmap(mAttachments->mVSConstantBuffer, 0);
mContext->Map(mAttachments->mPSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &resource);
*(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);
}
void
CompositorD3D11::SetSamplerForFilter(Filter aFilter)
{
ID3D11SamplerState *sampler;
switch (aFilter) {
case FILTER_LINEAR:
sampler = mAttachments->mLinearSamplerState;
break;
case FILTER_POINT:
sampler = mAttachments->mPointSamplerState;
break;
}
mContext->PSSetSamplers(0, 1, &sampler);
}
void
CompositorD3D11::PaintToTarget()
{
nsRefPtr<ID3D11Texture2D> backBuf;
mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)backBuf.StartAssignment());
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;
nsRefPtr<ID3D11Texture2D> readTexture;
HRESULT hr = mDevice->CreateTexture2D(&softDesc, NULL, getter_AddRefs(readTexture));
mContext->CopyResource(readTexture, backBuf);
D3D11_MAPPED_SUBRESOURCE map;
mContext->Map(readTexture, 0, D3D11_MAP_READ, 0, &map);
nsRefPtr<gfxImageSurface> tmpSurface =
new gfxImageSurface((unsigned char*)map.pData,
gfxIntSize(bbDesc.Width, bbDesc.Height),
map.RowPitch,
gfxASurface::ImageFormatARGB32);
mTarget->SetSource(tmpSurface);
mTarget->SetOperator(gfxContext::OPERATOR_OVER);
mTarget->Paint();
mContext->Unmap(readTexture, 0);
}
}
}

303
gfx/layers/d3d11/CompositorD3D11.fx
Просмотреть файл

@ -1,303 +0,0 @@
/* -*- 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/. */
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);
rect vMaskQuad : register(vs, c11);
float4 fLayerColor : register(ps, c0);
float fLayerOpacity : register(ps, c1);
sampler sSampler : register(ps, s0);
BlendState NoBlendDual
{
AlphaToCoverageEnable = FALSE;
BlendEnable[0] = FALSE;
BlendEnable[1] = FALSE;
RenderTargetWriteMask[0] = 0x0F; // All
RenderTargetWriteMask[1] = 0x0F; // All
};
BlendState ComponentAlphaBlend
{
AlphaToCoverageEnable = FALSE;
BlendEnable[0] = TRUE;
SrcBlend = One;
DestBlend = Inv_Src1_Color;
BlendOp = Add;
SrcBlendAlpha = One;
DestBlendAlpha = Inv_Src_Alpha;
BlendOpAlpha = Add;
RenderTargetWriteMask[0] = 0x0F; // All
};
Texture2D tRGB;
Texture2D tY;
Texture2D tCb;
Texture2D tCr;
Texture2D tRGBWhite;
// Always bind this to slot 3 since this is always available!
Texture2D tMask : register(ps, t3);
struct VS_INPUT {
float2 vPosition : POSITION;
};
struct VS_OUTPUT {
float4 vPosition : SV_Position;
float2 vTexCoords : TEXCOORD0;
};
struct VS_MASK_OUTPUT {
float4 vPosition : SV_Position;
float2 vTexCoords : TEXCOORD0;
float2 vMaskCoords : TEXCOORD1;
};
struct VS_MASK_3D_OUTPUT {
float4 vPosition : SV_Position;
float2 vTexCoords : TEXCOORD0;
float3 vMaskCoords : TEXCOORD1;
};
struct PS_OUTPUT {
float4 vSrc;
float4 vAlpha;
};
struct PS_DUAL_OUTPUT {
float4 vOutput1 : SV_Target0;
float4 vOutput2 : SV_Target1;
};
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
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;
}
VS_MASK_OUTPUT LayerQuadMaskVS(const VS_INPUT aVertex)
{
VS_MASK_OUTPUT outp;
float4 position = TransformedPosition(aVertex.vPosition);
outp.vPosition = VertexPosition(position);
// calculate the position on the mask texture
outp.vMaskCoords.x = (position.x - vMaskQuad.x) / vMaskQuad.z;
outp.vMaskCoords.y = (position.y - vMaskQuad.y) / vMaskQuad.w;
outp.vTexCoords = TexCoords(aVertex.vPosition.xy);
return outp;
}
VS_MASK_3D_OUTPUT LayerQuadMask3DVS(const VS_INPUT aVertex)
{
VS_MASK_3D_OUTPUT outp;
float4 position = TransformedPosition(aVertex.vPosition);
outp.vPosition = VertexPosition(position);
// calculate the position on the mask texture
position.xyz /= position.w;
outp.vMaskCoords.x = (position.x - vMaskQuad.x) / vMaskQuad.z;
outp.vMaskCoords.y = (position.y - vMaskQuad.y) / vMaskQuad.w;
// We use the w coord to do non-perspective correct interpolation:
// the quad might be transformed in 3D, in which case it will have some
// perspective. The graphics card will do perspective-correct interpolation
// of the texture, but our mask is already transformed and so we require
// linear interpolation. Therefore, we must correct the interpolation
// ourselves, we do this by multiplying all coords by w here, and dividing by
// w in the pixel shader (post-interpolation), we pass w in outp.vMaskCoords.z.
// See http://en.wikipedia.org/wiki/Texture_mapping#Perspective_correctness
outp.vMaskCoords.z = 1;
outp.vMaskCoords *= position.w;
outp.vTexCoords = TexCoords(aVertex.vPosition.xy);
return outp;
}
float4 RGBAShaderMask(const VS_MASK_OUTPUT aVertex) : SV_Target
{
float2 maskCoords = aVertex.vMaskCoords;
float mask = tMask.Sample(sSampler, maskCoords).a;
return tRGB.Sample(sSampler, aVertex.vTexCoords) * fLayerOpacity * mask;
}
float4 RGBAShaderMask3D(const VS_MASK_3D_OUTPUT aVertex) : SV_Target
{
float2 maskCoords = aVertex.vMaskCoords.xy / aVertex.vMaskCoords.z;
float mask = tMask.Sample(LayerTextureSamplerLinear, maskCoords).a;
return tRGB.Sample(sSampler, aVertex.vTexCoords) * fLayerOpacity * mask;
}
float4 RGBShaderMask(const VS_MASK_OUTPUT aVertex) : SV_Target
{
float4 result;
result = tRGB.Sample(sSampler, aVertex.vTexCoords) * fLayerOpacity;
result.a = fLayerOpacity;
float2 maskCoords = aVertex.vMaskCoords;
float mask = tMask.Sample(sSampler, maskCoords).a;
return result * mask;
}
float4 CalculateYCbCrColor(const float2 aTexCoords)
{
float4 yuv;
float4 color;
yuv.r = tCr.Sample(sSampler, aTexCoords).r - 0.5;
yuv.g = tY.Sample(sSampler, aTexCoords).r - 0.0625;
yuv.b = tCb.Sample(sSampler, aTexCoords).r - 0.5;
color.r = yuv.g * 1.164 + yuv.r * 1.596;
color.g = yuv.g * 1.164 - 0.813 * yuv.r - 0.391 * yuv.b;
color.b = yuv.g * 1.164 + yuv.b * 2.018;
color.a = 1.0f;
return color;
}
float4 YCbCrShaderMask(const VS_MASK_OUTPUT aVertex) : SV_Target
{
float2 maskCoords = aVertex.vMaskCoords;
float mask = tMask.Sample(sSampler, maskCoords).a;
return CalculateYCbCrColor(aVertex.vTexCoords) * fLayerOpacity * mask;
}
PS_OUTPUT ComponentAlphaShaderMask(const VS_MASK_OUTPUT aVertex) : SV_Target
{
PS_OUTPUT result;
result.vSrc = tRGB.Sample(sSampler, aVertex.vTexCoords);
result.vAlpha = 1.0 - tRGBWhite.Sample(sSampler, aVertex.vTexCoords) + result.vSrc;
result.vSrc.a = result.vAlpha.g;
float2 maskCoords = aVertex.vMaskCoords;
float mask = tMask.Sample(sSampler, maskCoords).a;
result.vSrc *= fLayerOpacity * mask;
result.vAlpha *= fLayerOpacity * mask;
return result;
}
float4 SolidColorShaderMask(const VS_MASK_OUTPUT aVertex) : SV_Target
{
float2 maskCoords = aVertex.vMaskCoords;
float mask = tMask.Sample(sSampler, maskCoords).a;
return fLayerColor * mask;
}
/*
* Un-masked versions
*************************************************************
*/
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;
}
PS_OUTPUT ComponentAlphaShader(const VS_OUTPUT aVertex) : SV_Target
{
PS_OUTPUT result;
result.vSrc = tRGB.Sample(sSampler, aVertex.vTexCoords);
result.vAlpha = 1.0 - tRGBWhite.Sample(sSampler, aVertex.vTexCoords) + result.vSrc;
result.vSrc.a = result.vAlpha.g;
result.vSrc *= fLayerOpacity;
result.vAlpha *= fLayerOpacity;
return result;
}
float4 SolidColorShader(const VS_OUTPUT aVertex) : SV_Target
{
return fLayerColor;
}
PS_DUAL_OUTPUT AlphaExtractionPrepareShader(const VS_OUTPUT aVertex)
{
PS_DUAL_OUTPUT result;
result.vOutput1 = float4(0, 0, 0, 1);
result.vOutput2 = float4(1, 1, 1, 1);
return result;
}

174
gfx/layers/d3d11/CompositorD3D11.h
Просмотреть файл

@ -1,174 +0,0 @@
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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/layers/Compositor.h"
#include "TextureD3D11.h"
#include <d3d11.h>
class nsWidget;
namespace mozilla {
namespace layers {
#define LOGD3D11(param)
struct VertexShaderConstants
{
float layerTransform[4][4];
float projection[4][4];
float renderTargetOffset[4];
gfx::Rect textureCoords;
gfx::Rect layerQuad;
gfx::Rect maskQuad;
};
struct PixelShaderConstants
{
float layerColor[4];
float layerOpacity[4];
};
struct DeviceAttachmentsD3D11;
class CompositorD3D11 : public Compositor
{
public:
CompositorD3D11(nsIWidget *aWidget);
~CompositorD3D11();
virtual bool Initialize();
virtual void Destroy() { }
virtual TextureFactoryIdentifier
GetTextureFactoryIdentifier() MOZ_OVERRIDE;
virtual bool CanUseCanvasLayerForSize(const gfxIntSize &aSize) MOZ_OVERRIDE;
virtual int32_t GetMaxTextureSize() const MOZ_FINAL;
virtual void SetTargetContext(gfxContext *aTarget) { mTarget = aTarget; }
virtual void MakeCurrent(MakeCurrentFlags aFlags = 0) { }
virtual TemporaryRef<CompositingRenderTarget>
CreateRenderTarget(const gfx::IntRect &aRect,
SurfaceInitMode aInit) MOZ_OVERRIDE;
virtual TemporaryRef<CompositingRenderTarget>
CreateRenderTargetFromSource(const gfx::IntRect &aRect,
const CompositingRenderTarget *aSource) MOZ_OVERRIDE;
virtual void SetRenderTarget(CompositingRenderTarget *aSurface) MOZ_OVERRIDE;
virtual CompositingRenderTarget* GetCurrentRenderTarget() MOZ_OVERRIDE
{
return mCurrentRT;
}
virtual void SetDestinationSurfaceSize(const gfx::IntSize& aSize) MOZ_OVERRIDE { }
/**
* Declare an offset to use when rendering layers. This will be ignored when
* rendering to a target instead of the screen.
*/
virtual void SetScreenRenderOffset(const gfx::Point& aOffset) MOZ_OVERRIDE {
if (aOffset.x || aOffset.y) {
NS_RUNTIMEABORT("SetScreenRenderOffset not supported by CompositorD3D11.");
}
// If the offset is 0, 0 that's okay.
}
virtual void DrawQuad(const gfx::Rect &aRect, const gfx::Rect &aClipRect,
const EffectChain &aEffectChain,
gfx::Float aOpacity, const gfx::Matrix4x4 &aTransform,
const gfx::Point &aOffset) MOZ_OVERRIDE;
/**
* Start a new frame. If aClipRectIn is null, sets *aClipRectOut to the screen dimensions.
*/
virtual void BeginFrame(const gfx::Rect *aClipRectIn,
const gfxMatrix& aTransform,
const gfx::Rect& aRenderBounds,
gfx::Rect *aClipRectOut = nullptr,
gfx::Rect *aRenderBoundsOut = nullptr) MOZ_OVERRIDE;
/**
* Flush the current frame to the screen.
*/
virtual void EndFrame() MOZ_OVERRIDE;
/**
* Post rendering stuff if the rendering is outside of this Compositor
* e.g., by Composer2D
*/
virtual void EndFrameForExternalComposition(const gfxMatrix& aTransform) MOZ_OVERRIDE { }
/**
* Tidy up if BeginFrame has been called, but EndFrame won't be
*/
virtual void AbortFrame() MOZ_OVERRIDE { }
/**
* Setup the viewport and projection matrix for rendering
* to a window of the given dimensions.
*/
virtual void PrepareViewport(const gfx::IntSize& aSize,
const gfxMatrix& aWorldTransform) MOZ_OVERRIDE;
virtual bool SupportsPartialTextureUpdate() MOZ_OVERRIDE { return true; }
#ifdef MOZ_DUMP_PAINTING
virtual const char* Name() const MOZ_OVERRIDE { return "Direct3D 11"; }
#endif
virtual void NotifyLayersTransaction() MOZ_OVERRIDE { }
virtual nsIWidget* GetWidget() const MOZ_OVERRIDE { return mWidget; }
virtual const nsIntSize& GetWidgetSize() MOZ_OVERRIDE;
ID3D11Device *GetDevice() { return mDevice; }
private:
enum MaskMode {
UNMASKED = 0,
MASKED = 1,
MASKED3D
};
void VerifyBufferSize();
void UpdateRenderTarget();
bool CreateShaders();
void UpdateConstantBuffers();
void SetSamplerForFilter(gfx::Filter aFilter);
void SetPSForEffect(Effect *aEffect, MaskMode aMaskMode);
void PaintToTarget();
RefPtr<ID3D11DeviceContext> mContext;
RefPtr<ID3D11Device> mDevice;
RefPtr<IDXGISwapChain> mSwapChain;
RefPtr<CompositingRenderTargetD3D11> mDefaultRT;
RefPtr<CompositingRenderTargetD3D11> mCurrentRT;
DeviceAttachmentsD3D11 *mAttachments;
nsRefPtr<gfxContext> mTarget;
nsIWidget *mWidget;
// XXX - Bas - wth?
nsIntSize mSize;
HWND mHwnd;
D3D_FEATURE_LEVEL mFeatureLevel;
VertexShaderConstants mVSConstants;
PixelShaderConstants mPSConstants;
};
}
}
#endif

4420
gfx/layers/d3d11/CompositorD3D11Shaders.h
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

487
gfx/layers/d3d11/TextureD3D11.cpp
Просмотреть файл

@ -1,487 +0,0 @@
/* -*- 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 "TextureD3D11.h"
#include "CompositorD3D11.h"
#include "gfxContext.h"
#include "gfxImageSurface.h"
#include "Effects.h"
#include "ipc/AutoOpenSurface.h"
#include "ShmemYCbCrImage.h"
#include "gfxWindowsPlatform.h"
#include "gfxD2DSurface.h"
namespace mozilla {
using namespace gfx;
namespace layers {
TemporaryRef<TextureHost>
CreateTextureHostD3D11(SurfaceDescriptorType aDescriptorType,
uint32_t aTextureHostFlags,
uint32_t aTextureFlags)
{
RefPtr<TextureHost> result;
if (aDescriptorType == SurfaceDescriptor::TYCbCrImage) {
result = new TextureHostYCbCrD3D11();
} else if (aDescriptorType == SurfaceDescriptor::TSurfaceDescriptorD3D10) {
result = new TextureHostDXGID3D11();
} else {
result = new TextureHostShmemD3D11();
}
result->SetFlags(aTextureFlags);
return result.forget();
}
CompositingRenderTargetD3D11::CompositingRenderTargetD3D11(ID3D11Texture2D *aTexture)
{
if (!aTexture) {
return;
}
mTextures[0] = aTexture;
RefPtr<ID3D11Device> device;
mTextures[0]->GetDevice(byRef(device));
HRESULT hr = device->CreateRenderTargetView(mTextures[0], NULL, byRef(mRTView));
if (FAILED(hr)) {
LOGD3D11("Failed to create RenderTargetView.");
}
}
IntSize
CompositingRenderTargetD3D11::GetSize() const
{
return TextureSourceD3D11::GetSize();
}
TextureClientD3D11::TextureClientD3D11(CompositableForwarder* aCompositableForwarder, const TextureInfo& aTextureInfo)
: TextureClient(aCompositableForwarder, aTextureInfo)
, mIsLocked(false)
{
mTextureInfo = aTextureInfo;
}
TextureClientD3D11::~TextureClientD3D11()
{
mDescriptor = SurfaceDescriptor();
ClearDT();
}
void
TextureClientD3D11::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType)
{
D3D10_TEXTURE2D_DESC desc;
if (mTexture) {
mTexture->GetDesc(&desc);
if (desc.Width == aSize.width || desc.Height == aSize.height) {
return;
}
mTexture = nullptr;
mSurface = nullptr;
ClearDT();
}
mSize = aSize;
ID3D10Device *device = gfxWindowsPlatform::GetPlatform()->GetD3D10Device();
CD3D10_TEXTURE2D_DESC newDesc(DXGI_FORMAT_B8G8R8A8_UNORM,
aSize.width, aSize.height, 1, 1,
D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE);
newDesc.MiscFlags = D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX;
HRESULT hr = device->CreateTexture2D(&newDesc, nullptr, byRef(mTexture));
if (FAILED(hr)) {
LOGD3D11("Error creating texture for client!");
return;
}
RefPtr<IDXGIResource> resource;
mTexture->QueryInterface((IDXGIResource**)byRef(resource));
HANDLE sharedHandle;
hr = resource->GetSharedHandle(&sharedHandle);
if (FAILED(hr)) {
LOGD3D11("Error getting shared handle for texture.");
}
mDescriptor = SurfaceDescriptorD3D10((WindowsHandle)sharedHandle, aType == gfxASurface::CONTENT_COLOR_ALPHA);
mContentType = aType;
}
gfxASurface*
TextureClientD3D11::LockSurface()
{
EnsureSurface();
LockTexture();
return mSurface.get();
}
DrawTarget*
TextureClientD3D11::LockDrawTarget()
{
EnsureDrawTarget();
LockTexture();
return mDrawTarget.get();
}
void
TextureClientD3D11::Unlock()
{
// TODO - Things seem to believe they can hold on to our surface... well...
// They shouldn't!!
ReleaseTexture();
}
void
TextureClientD3D11::SetDescriptor(const SurfaceDescriptor& aDescriptor)
{
if (aDescriptor.type() == SurfaceDescriptor::Tnull_t) {
EnsureAllocated(mSize, mContentType);
return;
}
mDescriptor = aDescriptor;
mSurface = nullptr;
ClearDT();
if (aDescriptor.type() == SurfaceDescriptor::T__None) {
return;
}
MOZ_ASSERT(aDescriptor.type() == SurfaceDescriptor::TSurfaceDescriptorD3D10);
ID3D10Device *device = gfxWindowsPlatform::GetPlatform()->GetD3D10Device();
device->OpenSharedResource((HANDLE)aDescriptor.get_SurfaceDescriptorD3D10().handle(),
__uuidof(ID3D10Texture2D),
(void**)(ID3D10Texture2D**)byRef(mTexture));
}
void
TextureClientD3D11::EnsureSurface()
{
if (mSurface) {
return;
}
LockTexture();
mSurface = new gfxD2DSurface(mTexture, mContentType);
ReleaseTexture();
}
void
TextureClientD3D11::EnsureDrawTarget()
{
if (mDrawTarget) {
return;
}
LockTexture();
SurfaceFormat format;
switch (mContentType) {
case gfxASurface::CONTENT_ALPHA:
format = FORMAT_A8;
break;
case gfxASurface::CONTENT_COLOR:
format = FORMAT_B8G8R8X8;
break;
case gfxASurface::CONTENT_COLOR_ALPHA:
format = FORMAT_B8G8R8A8;
break;
default:
format = FORMAT_B8G8R8A8;
}
mDrawTarget = Factory::CreateDrawTargetForD3D10Texture(mTexture, format);
ReleaseTexture();
}
void
TextureClientD3D11::LockTexture()
{
RefPtr<IDXGIKeyedMutex> mutex;
mTexture->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
mutex->AcquireSync(0, INFINITE);
mIsLocked = true;
}
void
TextureClientD3D11::ReleaseTexture()
{
// TODO - Bas - We seem to have places that unlock without ever having locked,
// that's kind of bad.
if (!mIsLocked) {
return;
}
if (mDrawTarget) {
mDrawTarget->Flush();
}
RefPtr<IDXGIKeyedMutex> mutex;
mTexture->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
mutex->ReleaseSync(0);
mIsLocked = false;
}
void
TextureClientD3D11::ClearDT()
{
// An Azure DrawTarget needs to be locked when it gets NULL'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.
//
// Perhaps this should be debug only.
if (mDrawTarget) {
LockTexture();
mDrawTarget = nullptr;
ReleaseTexture();
}
}
IntSize
TextureHostShmemD3D11::GetSize() const
{
if (mIterating) {
gfx::IntRect rect = GetTileRect(mCurrentTile);
return gfx::IntSize(rect.width, rect.height);
}
return TextureSourceD3D11::GetSize();
}
nsIntRect
TextureHostShmemD3D11::GetTileRect()
{
IntRect rect = GetTileRect(mCurrentTile);
return nsIntRect(rect.x, rect.y, rect.width, rect.height);
}
static uint32_t GetRequiredTiles(uint32_t aSize, uint32_t aMaxSize)
{
uint32_t requiredTiles = aSize / aMaxSize;
if (aSize % aMaxSize) {
requiredTiles++;
}
return requiredTiles;
}
void
TextureHostShmemD3D11::SetCompositor(Compositor* aCompositor)
{
CompositorD3D11 *d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
mDevice = d3dCompositor ? d3dCompositor->GetDevice() : nullptr;
}
void
TextureHostShmemD3D11::UpdateImpl(const SurfaceDescriptor& aImage, nsIntRegion *aRegion)
{
MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TShmem);
AutoOpenSurface openSurf(OPEN_READ_ONLY, aImage);
nsRefPtr<gfxImageSurface> surf = openSurf.GetAsImage();
gfxIntSize size = surf->GetSize();
uint32_t bpp = 0;
DXGI_FORMAT dxgiFormat;
switch (surf->Format()) {
case gfxImageSurface::ImageFormatRGB24:
mFormat = FORMAT_B8G8R8X8;
dxgiFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
bpp = 4;
break;
case gfxImageSurface::ImageFormatARGB32:
mFormat = FORMAT_B8G8R8A8;
dxgiFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
bpp = 4;
break;
case gfxImageSurface::ImageFormatA8:
mFormat = FORMAT_A8;
dxgiFormat = DXGI_FORMAT_A8_UNORM;
bpp = 1;
break;
}
mSize = IntSize(size.width, size.height);
CD3D11_TEXTURE2D_DESC desc(dxgiFormat, size.width, size.height,
1, 1, D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_IMMUTABLE);
int32_t maxSize = GetMaxTextureSizeForFeatureLevel(mDevice->GetFeatureLevel());
if (size.width <= maxSize && size.height <= maxSize) {
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = surf->Data();
initData.SysMemPitch = surf->Stride();
mDevice->CreateTexture2D(&desc, &initData, byRef(mTextures[0]));
mIsTiled = false;
} else {
mIsTiled = true;
uint32_t tileCount = GetRequiredTiles(size.width, maxSize) *
GetRequiredTiles(size.height, maxSize);
mTileTextures.resize(tileCount);
for (uint32_t i = 0; i < tileCount; i++) {
IntRect tileRect = GetTileRect(i);
desc.Width = tileRect.width;
desc.Height = tileRect.height;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = surf->Data() + tileRect.y * surf->Stride() + tileRect.x * bpp;
initData.SysMemPitch = surf->Stride();
mDevice->CreateTexture2D(&desc, &initData, byRef(mTileTextures[i]));
}
}
}
IntRect
TextureHostShmemD3D11::GetTileRect(uint32_t aID) const
{
uint32_t maxSize = GetMaxTextureSizeForFeatureLevel(mDevice->GetFeatureLevel());
uint32_t horizontalTiles = GetRequiredTiles(mSize.width, maxSize);
uint32_t verticalTiles = GetRequiredTiles(mSize.height, maxSize);
uint32_t verticalTile = aID / horizontalTiles;
uint32_t horizontalTile = aID % horizontalTiles;
return IntRect(horizontalTile * maxSize,
verticalTile * maxSize,
horizontalTile < (horizontalTiles - 1) ? maxSize : mSize.width % maxSize,
verticalTile < (verticalTiles - 1) ? maxSize : mSize.height % maxSize);
}
void
TextureHostDXGID3D11::SetCompositor(Compositor* aCompositor)
{
CompositorD3D11 *d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
mDevice = d3dCompositor ? d3dCompositor->GetDevice() : nullptr;
}
IntSize
TextureHostDXGID3D11::GetSize() const
{
return TextureSourceD3D11::GetSize();
}
bool
TextureHostDXGID3D11::Lock()
{
LockTexture();
return true;
}
void
TextureHostDXGID3D11::Unlock()
{
ReleaseTexture();
}
void
TextureHostDXGID3D11::UpdateImpl(const SurfaceDescriptor& aImage, nsIntRegion *aRegion)
{
MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TSurfaceDescriptorD3D10);
mDevice->OpenSharedResource((HANDLE)aImage.get_SurfaceDescriptorD3D10().handle(),
__uuidof(ID3D11Texture2D), (void**)(ID3D11Texture2D**)byRef(mTextures[0]));
mFormat = aImage.get_SurfaceDescriptorD3D10().hasAlpha() ? FORMAT_B8G8R8A8 : FORMAT_B8G8R8X8;
D3D11_TEXTURE2D_DESC desc;
mTextures[0]->GetDesc(&desc);
mSize = IntSize(desc.Width, desc.Height);
}
void
TextureHostDXGID3D11::LockTexture()
{
RefPtr<IDXGIKeyedMutex> mutex;
mTextures[0]->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
mutex->AcquireSync(0, INFINITE);
}
void
TextureHostDXGID3D11::ReleaseTexture()
{
RefPtr<IDXGIKeyedMutex> mutex;
mTextures[0]->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
mutex->ReleaseSync(0);
}
void
TextureHostYCbCrD3D11::SetCompositor(Compositor* aCompositor)
{
CompositorD3D11 *d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
mDevice = d3dCompositor ? d3dCompositor->GetDevice() : nullptr;
}
IntSize
TextureHostYCbCrD3D11::GetSize() const
{
return TextureSourceD3D11::GetSize();
}
void
TextureHostYCbCrD3D11::UpdateImpl(const SurfaceDescriptor& aImage, nsIntRegion *aRegion)
{
MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TYCbCrImage);
ShmemYCbCrImage shmemImage(aImage.get_YCbCrImage().data(),
aImage.get_YCbCrImage().offset());
gfxIntSize gfxCbCrSize = shmemImage.GetCbCrSize();
gfxIntSize size = shmemImage.GetYSize();
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = shmemImage.GetYData();
initData.SysMemPitch = shmemImage.GetYStride();
CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_R8_UNORM, size.width, size.height,
1, 1, D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_IMMUTABLE);
mDevice->CreateTexture2D(&desc, &initData, byRef(mTextures[0]));
initData.pSysMem = shmemImage.GetCbData();
initData.SysMemPitch = shmemImage.GetCbCrStride();
desc.Width = shmemImage.GetCbCrSize().width;
desc.Height = shmemImage.GetCbCrSize().height;
mDevice->CreateTexture2D(&desc, &initData, byRef(mTextures[1]));
initData.pSysMem = shmemImage.GetCrData();
mDevice->CreateTexture2D(&desc, &initData, byRef(mTextures[2]));
mSize = IntSize(size.width, size.height);
}
}
}

246
gfx/layers/d3d11/TextureD3D11.h
Просмотреть файл

@ -1,246 +0,0 @@
/* -*- 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/. */
#ifndef MOZILLA_GFX_TEXTURED3D11_H
#define MOZILLA_GFX_TEXTURED3D11_H
#include "mozilla/layers/Compositor.h"
#include "mozilla/layers/TextureClient.h"
#include <d3d11.h>
#include <vector>
class gfxD2DSurface;
namespace mozilla {
namespace layers {
class TextureSourceD3D11
{
public:
TextureSourceD3D11()
{ }
virtual ID3D11Texture2D *GetD3D11Texture() { return mTextures[0]; }
virtual bool IsYCbCrSource() const { return false; }
struct YCbCrTextures
{
ID3D11Texture2D *mY;
ID3D11Texture2D *mCb;
ID3D11Texture2D *mCr;
};
virtual YCbCrTextures GetYCbCrTextures() {
YCbCrTextures textures = { mTextures[0], mTextures[1], mTextures[2] };
return textures;
}
protected:
virtual gfx::IntSize GetSize() const { return mSize; }
gfx::IntSize mSize;
RefPtr<ID3D11Texture2D> mTextures[3];
};
class CompositingRenderTargetD3D11 : public CompositingRenderTarget,
public TextureSourceD3D11
{
public:
// Use aTexture == nullptr for rendering to the window
CompositingRenderTargetD3D11(ID3D11Texture2D *aTexture);
virtual TextureSourceD3D11* AsSourceD3D11() MOZ_OVERRIDE { return this; }
virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;
void SetSize(const gfx::IntSize& aSize) { mSize = aSize; }
private:
friend class CompositorD3D11;
RefPtr<ID3D11RenderTargetView> mRTView;
};
class TextureClientD3D11 : public TextureClient
{
public:
TextureClientD3D11(CompositableForwarder* aCompositableForwarder, const TextureInfo& aTextureInfo);
~TextureClientD3D11();
virtual bool SupportsType(TextureClientType aType) MOZ_OVERRIDE { return aType == TEXTURE_CONTENT; }
virtual void EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType) MOZ_OVERRIDE;
virtual gfxASurface* LockSurface() MOZ_OVERRIDE;
virtual gfx::DrawTarget* LockDrawTarget() MOZ_OVERRIDE;
virtual void Unlock() MOZ_OVERRIDE;
virtual void SetDescriptor(const SurfaceDescriptor& aDescriptor) MOZ_OVERRIDE;
virtual gfxASurface::gfxContentType GetContentType() MOZ_OVERRIDE { return mContentType; }
private:
void EnsureSurface();
void EnsureDrawTarget();
void LockTexture();
void ReleaseTexture();
void ClearDT();
RefPtr<ID3D10Texture2D> mTexture;
nsRefPtr<gfxD2DSurface> mSurface;
RefPtr<gfx::DrawTarget> mDrawTarget;
gfx::IntSize mSize;
bool mIsLocked;
gfxContentType mContentType;
};
class TextureHostShmemD3D11 : public TextureHost
, public TextureSourceD3D11
, public TileIterator
{
public:
TextureHostShmemD3D11()
: mDevice(nullptr)
, mIsTiled(false)
, mCurrentTile(0)
, mIterating(false)
{
}
virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
virtual TextureSourceD3D11* AsSourceD3D11() MOZ_OVERRIDE { return this; }
virtual ID3D11Texture2D *GetD3D11Texture() MOZ_OVERRIDE {
return mIsTiled ? mTileTextures[mCurrentTile] : TextureSourceD3D11::GetD3D11Texture();
}
virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;
virtual LayerRenderState GetRenderState() { return LayerRenderState(); }
virtual bool Lock() MOZ_OVERRIDE { return true; }
#ifdef MOZ_LAYERS_HAVE_LOG
virtual const char* Name() { return "TextureHostShmemD3D11"; }
#endif
virtual void BeginTileIteration() MOZ_OVERRIDE {
mIterating = true;
mCurrentTile = 0;
}
virtual void EndTileIteration() MOZ_OVERRIDE {
mIterating = false;
}
virtual nsIntRect GetTileRect() MOZ_OVERRIDE;
virtual size_t GetTileCount() MOZ_OVERRIDE { return mTileTextures.size(); }
virtual bool NextTile() MOZ_OVERRIDE {
return (++mCurrentTile < mTileTextures.size());
}
virtual TileIterator* AsTileIterator() MOZ_OVERRIDE {
return mIsTiled ? this : nullptr;
}
protected:
virtual void UpdateImpl(const SurfaceDescriptor& aSurface,
nsIntRegion* aRegion) MOZ_OVERRIDE;
private:
gfx::IntRect GetTileRect(uint32_t aID) const;
RefPtr<ID3D11Device> mDevice;
bool mIsTiled;
std::vector< RefPtr<ID3D11Texture2D> > mTileTextures;
uint32_t mCurrentTile;
bool mIterating;
};
class TextureHostDXGID3D11 : public TextureHost
, public TextureSourceD3D11
{
public:
TextureHostDXGID3D11()
: mDevice(nullptr)
{
}
virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
virtual TextureSourceD3D11* AsSourceD3D11() MOZ_OVERRIDE { return this; }
virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;
virtual bool Lock() MOZ_OVERRIDE;
virtual void Unlock() MOZ_OVERRIDE;
#ifdef MOZ_LAYERS_HAVE_LOG
virtual const char* Name() { return "TextureHostDXGID3D11"; }
#endif
protected:
virtual void UpdateImpl(const SurfaceDescriptor& aSurface,
nsIntRegion* aRegion) MOZ_OVERRIDE;
private:
void LockTexture();
void ReleaseTexture();
gfx::IntRect GetTileRect(uint32_t aID) const; // TODO[Bas] not defined anywhere?
RefPtr<ID3D11Device> mDevice;
};
class TextureHostYCbCrD3D11 : public TextureHost
, public TextureSourceD3D11
{
public:
TextureHostYCbCrD3D11()
: mDevice(nullptr)
{
mFormat = gfx::FORMAT_YUV;
}
virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
virtual TextureSourceD3D11* AsSourceD3D11() MOZ_OVERRIDE { return this; }
virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;
virtual bool IsYCbCrSource() const MOZ_OVERRIDE { return true; }
#ifdef MOZ_LAYERS_HAVE_LOG
virtual const char* Name() MOZ_OVERRIDE { return "TextureImageTextureHostD3D11"; }
#endif
protected:
virtual void UpdateImpl(const SurfaceDescriptor& aSurface,
nsIntRegion* aRegion) MOZ_OVERRIDE;
private:
RefPtr<ID3D11Device> mDevice;
};
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;
}
}
}
#endif /* MOZILLA_GFX_TEXTURED3D11_H */

30
gfx/layers/d3d11/genshaders.sh
Просмотреть файл

@ -1,30 +0,0 @@
# 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/.
tempfile=tmpShaderHeader
rm CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ELayerQuadVS -nologo -Tvs_4_0_level_9_3 -Fh$tempfile -VnLayerQuadVS
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ESolidColorShader -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnSolidColorShader
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ERGBShader -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnRGBShader
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ERGBAShader -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnRGBAShader
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -EYCbCrShader -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnYCbCrShader
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ELayerQuadMaskVS -nologo -Tvs_4_0_level_9_3 -Fh$tempfile -VnLayerQuadMaskVS
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ELayerQuadMask3DVS -nologo -Tvs_4_0_level_9_3 -Fh$tempfile -VnLayerQuadMask3DVS
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ESolidColorShaderMask -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnSolidColorShaderMask
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ERGBShaderMask -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnRGBShaderMask
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ERGBAShaderMask -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnRGBAShaderMask
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -ERGBAShaderMask3D -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnRGBAShaderMask3D
cat $tempfile >> CompositorD3D11Shaders.h
fxc CompositorD3D11.fx -EYCbCrShaderMask -Tps_4_0_level_9_3 -nologo -Fh$tempfile -VnYCbCrShaderMask
cat $tempfile >> CompositorD3D11Shaders.h

8
gfx/layers/ipc/CompositorParent.cpp
Просмотреть файл

@ -13,9 +13,6 @@
#include "CompositorParent.h"
#include "mozilla/layers/CompositorOGL.h"
#include "mozilla/layers/BasicCompositor.h"
#ifdef XP_WIN
#include "mozilla/layers/CompositorD3D11.h"
#endif
#include "LayerTransactionParent.h"
#include "nsIWidget.h"
#include "nsGkAtoms.h"
@ -571,11 +568,6 @@ CompositorParent::AllocPLayerTransaction(const LayersBackend& aBackendHint,
} else if (aBackendHint == mozilla::layers::LAYERS_BASIC) {
mLayerManager =
new LayerManagerComposite(new BasicCompositor(mWidget));
#ifdef XP_WIN
} else if (aBackendHint == mozilla::layers::LAYERS_D3D11) {
mLayerManager =
new LayerManagerComposite(new CompositorD3D11(mWidget));
#endif
} else {
NS_ERROR("Unsupported backend selected for Async Compositor");
return nullptr;

2
gfx/layers/moz.build
Просмотреть файл

@ -56,9 +56,7 @@ if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
'ReadbackManagerD3D10.h',
]
EXPORTS.mozilla.layers += [
'CompositorD3D11.h',
'ShadowLayerUtilsD3D10.h',
'TextureD3D11.h',
]
EXPORTS.gfxipc += [

132
gfx/thebes/gfxWindowsPlatform.cpp
Просмотреть файл

@ -53,8 +53,6 @@ using namespace mozilla::gfx;
#include "nsMemory.h"
#endif
#include <d3d11.h>
#include "nsIMemoryReporter.h"
#include <winternl.h>
#include "d3dkmtQueryStatistics.h"
@ -160,25 +158,12 @@ typedef HRESULT (WINAPI*D3D10CreateDevice1Func)(
UINT SDKVersion,
ID3D10Device1 **ppDevice
);
#endif
typedef HRESULT(WINAPI*CreateDXGIFactory1Func)(
REFIID riid,
void **ppFactory
);
typedef HRESULT (WINAPI*D3D11CreateDeviceFunc)(
IDXGIAdapter *pAdapter,
D3D_DRIVER_TYPE DriverType,
HMODULE Software,
UINT Flags,
D3D_FEATURE_LEVEL *pFeatureLevels,
UINT FeatureLevels,
UINT SDKVersion,
ID3D11Device **ppDevice,
D3D_FEATURE_LEVEL *pFeatureLevel,
ID3D11DeviceContext *ppImmediateContext
);
#endif
class GPUAdapterMultiReporter : public nsIMemoryMultiReporter {
@ -332,7 +317,6 @@ BuildKeyNameFromFontName(nsAString &aName)
}
gfxWindowsPlatform::gfxWindowsPlatform()
: mD3D11DeviceInitialized(false)
{
mPrefFonts.Init(50);
@ -544,19 +528,16 @@ gfxWindowsPlatform::VerifyD2DDevice(bool aAttemptForce)
nsRefPtr<ID3D10Device1> device;
nsModuleHandle dxgiModule(LoadLibrarySystem32(L"dxgi.dll"));
CreateDXGIFactory1Func createDXGIFactory1 = (CreateDXGIFactory1Func)
GetProcAddress(dxgiModule, "CreateDXGIFactory1");
int supportedFeatureLevelsCount = ArrayLength(kSupportedFeatureLevels);
// If we're not running in Metro don't allow DX9.3
if (!IsRunningInWindowsMetro()) {
supportedFeatureLevelsCount--;
}
nsRefPtr<IDXGIAdapter1> adapter1 = GetDXGIAdapter();
if (!adapter1) {
// Unable to create adapter, abort acceleration.
return;
}
// It takes a lot of time (5-10% of startup time or ~100ms) to do both
// a createD3DDevice on D3D10_FEATURE_LEVEL_10_0. We therefore store
// the last used feature level to go direct to that.
@ -564,6 +545,28 @@ gfxWindowsPlatform::VerifyD2DDevice(bool aAttemptForce)
if (featureLevelIndex >= supportedFeatureLevelsCount || featureLevelIndex < 0)
featureLevelIndex = 0;
// Try to use a DXGI 1.1 adapter in order to share resources
// across processes.
nsRefPtr<IDXGIAdapter1> adapter1;
if (createDXGIFactory1) {
nsRefPtr<IDXGIFactory1> factory1;
HRESULT hr = createDXGIFactory1(__uuidof(IDXGIFactory1),
getter_AddRefs(factory1));
if (FAILED(hr) || !factory1) {
// This seems to happen with some people running the iZ3D driver.
// They won't get acceleration.
return;
}
hr = factory1->EnumAdapters1(0, getter_AddRefs(adapter1));
if (FAILED(hr) || !adapter1) {
// We should return and not accelerate if we can't obtain
// an adapter.
return;
}
}
// Start with the last used feature level, and move to lower DX versions
// until we find one that works.
HRESULT hr = E_FAIL;
@ -1429,89 +1432,8 @@ gfxWindowsPlatform::SetupClearTypeParams()
#endif
}
ID3D11Device*
gfxWindowsPlatform::GetD3D11Device()
{
if (mD3D11DeviceInitialized) {
return mD3D11Device;
}
mD3D11DeviceInitialized = true;
nsModuleHandle d3d11Module(LoadLibrarySystem32(L"d3d11.dll"));
D3D11CreateDeviceFunc d3d11CreateDevice = (D3D11CreateDeviceFunc)
GetProcAddress(d3d11Module, "D3D11CreateDevice");
if (!d3d11CreateDevice) {
return nullptr;
}
D3D_FEATURE_LEVEL featureLevels[] = {
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
D3D_FEATURE_LEVEL_9_3
};
RefPtr<IDXGIAdapter1> adapter = GetDXGIAdapter();
if (!adapter) {
return nullptr;
}
HRESULT hr = d3d11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL,
D3D11_CREATE_DEVICE_BGRA_SUPPORT,
featureLevels, sizeof(featureLevels) / sizeof(D3D_FEATURE_LEVEL),
D3D11_SDK_VERSION, byRef(mD3D11Device), nullptr, nullptr);
// We leak these everywhere and we need them our entire runtime anyway, let's
// leak it here as well.
d3d11Module.disown();
return mD3D11Device;
}
bool
gfxWindowsPlatform::IsOptimus()
{
return GetModuleHandleA("nvumdshim.dll");
}
IDXGIAdapter1*
gfxWindowsPlatform::GetDXGIAdapter()
{
if (mAdapter) {
return mAdapter;
}
nsModuleHandle dxgiModule(LoadLibrarySystem32(L"dxgi.dll"));
CreateDXGIFactory1Func createDXGIFactory1 = (CreateDXGIFactory1Func)
GetProcAddress(dxgiModule, "CreateDXGIFactory1");
// Try to use a DXGI 1.1 adapter in order to share resources
// across processes.
if (createDXGIFactory1) {
nsRefPtr<IDXGIFactory1> factory1;
HRESULT hr = createDXGIFactory1(__uuidof(IDXGIFactory1),
getter_AddRefs(factory1));
if (FAILED(hr) || !factory1) {
// This seems to happen with some people running the iZ3D driver.
// They won't get acceleration.
return nullptr;
}
hr = factory1->EnumAdapters1(0, byRef(mAdapter));
if (FAILED(hr)) {
// We should return and not accelerate if we can't obtain
// an adapter.
return nullptr;
}
}
// We leak this module everywhere, we might as well do so here as well.
dxgiModule.disown();
return mAdapter;
}

10
gfx/thebes/gfxWindowsPlatform.h
Просмотреть файл

@ -25,8 +25,6 @@
#include "nsTArray.h"
#include "nsDataHashtable.h"
#include "mozilla/RefPtr.h"
#include <windows.h>
#include <objbase.h>
@ -34,9 +32,6 @@
#include <dxgi.h>
#endif
class ID3D11Device;
class IDXGIAdapter1;
class nsIMemoryMultiReporter;
// Utility to get a Windows HDC from a thebes context,
@ -260,7 +255,6 @@ public:
cairo_device_t *GetD2DDevice() { return mD2DDevice; }
ID3D10Device1 *GetD3D10Device() { return mD2DDevice ? cairo_d2d_device_get_device(mD2DDevice) : nullptr; }
#endif
ID3D11Device *GetD3D11Device();
static bool IsOptimus();
@ -273,7 +267,6 @@ protected:
private:
void Init();
IDXGIAdapter1 *GetDXGIAdapter();
bool mUseDirectWrite;
bool mUsingGDIFonts;
@ -287,9 +280,6 @@ private:
#ifdef CAIRO_HAS_D2D_SURFACE
cairo_device_t *mD2DDevice;
#endif
mozilla::RefPtr<IDXGIAdapter1> mAdapter;
mozilla::RefPtr<ID3D11Device> mD3D11Device;
bool mD3D11DeviceInitialized;
virtual qcms_profile* GetPlatformCMSOutputProfile();

26
widget/windows/nsWindow.cpp
Просмотреть файл

@ -3202,6 +3202,13 @@ GetLayerManagerPrefs(LayerManagerPrefs* aManagerPrefs)
aManagerPrefs->mDisableAcceleration || safeMode;
}
bool
nsWindow::ShouldUseOffMainThreadCompositing()
{
// OMTC doesn't work on Windows right now.
return false;
}
LayerManager*
nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
LayersBackend aBackendHint,
@ -3233,18 +3240,9 @@ nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
RECT windowRect;
::GetClientRect(mWnd, &windowRect);
// Try OMTC first.
if (!mLayerManager && ShouldUseOffMainThreadCompositing()) {
// e10s uses the parameter to pass in the shadow manager from the TabChild
// so we don't expect to see it there since this doesn't support e10s.
NS_ASSERTION(aShadowManager == nullptr, "Async Compositor not supported with e10s");
CreateCompositor();
}
if (!mLayerManager ||
(!sAllowD3D9 && aPersistence == LAYER_MANAGER_PERSISTENT &&
mLayerManager->GetBackendType() == LAYERS_BASIC &&
!ShouldUseOffMainThreadCompositing())) {
mLayerManager->GetBackendType() == LAYERS_BASIC)) {
// If D3D9 is not currently allowed but the permanent manager is required,
// -and- we're currently using basic layers, run through this check.
LayerManagerPrefs prefs;
@ -7271,7 +7269,7 @@ bool nsWindow::AutoErase(HDC dc)
void
nsWindow::AllowD3D9Callback(nsWindow *aWindow)
{
if (aWindow->mLayerManager && !aWindow->ShouldUseOffMainThreadCompositing()) {
if (aWindow->mLayerManager) {
aWindow->mLayerManager->Destroy();
aWindow->mLayerManager = NULL;
}
@ -7280,7 +7278,7 @@ nsWindow::AllowD3D9Callback(nsWindow *aWindow)
void
nsWindow::AllowD3D9WithReinitializeCallback(nsWindow *aWindow)
{
if (aWindow->mLayerManager && !aWindow->ShouldUseOffMainThreadCompositing()) {
if (aWindow->mLayerManager) {
aWindow->mLayerManager->Destroy();
aWindow->mLayerManager = NULL;
(void) aWindow->GetLayerManager();
@ -7300,9 +7298,7 @@ nsWindow::StartAllowingD3D9(bool aReinitialize)
// accelerated one, we *will* throw out all the current layer
// managers. We early-return here because currently, if
// |disableAcceleration|, we will always use basic managers and
// it's a waste to recreate them. If we're using OMTC we don't want to
// recreate out layer manager and its compositor either. This is even
// more wasteful.
// it's a waste to recreate them.
//
// NB: the above implies that it's eminently possible for us to
// skip this early return but still recreate basic managers.

3
widget/windows/nsWindow.h
Просмотреть файл

@ -281,8 +281,7 @@ public:
static void SetupKeyModifiersSequence(nsTArray<KeyPair>* aArray, uint32_t aModifiers);
virtual mozilla::layers::LayersBackend GetPreferredCompositorBackend() { return mozilla::layers::LAYERS_D3D11; }
virtual bool ShouldUseOffMainThreadCompositing();
protected:
// A magic number to identify the FAKETRACKPOINTSCROLLABLE window created

4
widget/windows/nsWindowGfx.cpp
Просмотреть файл

@ -545,10 +545,6 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t aNestingLevel)
}
break;
#endif
case LAYERS_CLIENT:
// Do nothing, the compositor will handle drawing.
break;
default:
NS_ERROR("Unknown layers backend used!");
break;

23
widget/xpwidgets/nsBaseWidget.cpp
Просмотреть файл

@ -877,9 +877,6 @@ void nsBaseWidget::CreateCompositor()
void nsBaseWidget::CreateCompositor(int aWidth, int aHeight)
{
// Recreating this is tricky, as we may still have an old and we need
// to make sure it's properly destroyed by calling DestroyCompositor!
mCompositorParent = NewCompositorParent(aWidth, aHeight);
AsyncChannel *parentChannel = mCompositorParent->GetIPCChannel();
LayerManager* lm = new ClientLayerManager(this);
@ -890,8 +887,12 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight)
TextureFactoryIdentifier textureFactoryIdentifier;
PLayerTransactionChild* shadowManager;
mozilla::layers::LayersBackend backendHint = GetPreferredCompositorBackend();
mozilla::layers::LayersBackend backendHint;
if (mUseLayersAcceleration) {
backendHint = mozilla::layers::LAYERS_OPENGL;
} else {
backendHint = mozilla::layers::LAYERS_BASIC;
}
shadowManager = mCompositorChild->SendPLayerTransactionConstructor(
backendHint, 0, &textureFactoryIdentifier);
@ -906,14 +907,12 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight)
lf->IdentifyTextureHost(textureFactoryIdentifier);
mLayerManager = lm;
return;
} else {
// We don't currently want to support not having a LayersChild
NS_RUNTIMEABORT("failed to construct LayersChild");
delete lm;
mCompositorChild = nullptr;
}
// Failed to create a compositor!
NS_WARNING("Failed to create an OMT compositor.");
DestroyCompositor();
// Compositor child had the only reference to LayerManager and will have
// deallocated it when being freed.
}
bool nsBaseWidget::ShouldUseOffMainThreadCompositing()

3
widget/xpwidgets/nsBaseWidget.h
Просмотреть файл

@ -336,9 +336,6 @@ protected:
virtual CompositorChild* GetRemoteRenderer() MOZ_OVERRIDE;
virtual mozilla::layers::LayersBackend GetPreferredCompositorBackend()
{ return mUseLayersAcceleration ? mozilla::layers::LAYERS_OPENGL : mozilla::layers::LAYERS_BASIC; }
protected:
/**
* Starts the OMTC compositor destruction sequence.