Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 10:44:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1300699 - (Part 3) Implement the TextureClient creating functions for the gtest. r=jerry

Browse Source
This commit is contained in:
Kevin Chen 2017-02-14 01:20:00 +08:00
parent 7098a27b99
commit e8bec7d8c2
4 changed files with 236 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
gfx/layers/IMFYCbCrImage.cpp
View File

@ -160,8 +160,8 @@ static bool UploadData(IDirect3DDevice9* aDevice,
return FinishTextures(aDevice, aTexture, surf);
}
TextureClient*
IMFYCbCrImage::GetD3D9TextureClient(KnowsCompositor* aForwarder)
DXGIYCbCrTextureData*
IMFYCbCrImage::GetD3D9TextureData(Data aData, gfx::IntSize aSize)
{
RefPtr<IDirect3DDevice9> device = DeviceManagerD3D9::GetDevice();
if (!device) {
@ -171,21 +171,21 @@ IMFYCbCrImage::GetD3D9TextureClient(KnowsCompositor* aForwarder)
RefPtr<IDirect3DTexture9> textureY;
HANDLE shareHandleY = 0;
if (!UploadData(device, textureY, shareHandleY,
mData.mYChannel, mData.mYSize, mData.mYStride)) {
aData.mYChannel, aData.mYSize, aData.mYStride)) {
return nullptr;
}
RefPtr<IDirect3DTexture9> textureCb;
HANDLE shareHandleCb = 0;
if (!UploadData(device, textureCb, shareHandleCb,
mData.mCbChannel, mData.mCbCrSize, mData.mCbCrStride)) {
aData.mCbChannel, aData.mCbCrSize, aData.mCbCrStride)) {
return nullptr;
}
RefPtr<IDirect3DTexture9> textureCr;
HANDLE shareHandleCr = 0;
if (!UploadData(device, textureCr, shareHandleCr,
mData.mCrChannel, mData.mCbCrSize, mData.mCbCrStride)) {
aData.mCrChannel, aData.mCbCrSize, aData.mCbCrStride)) {
return nullptr;
}
@ -212,43 +212,26 @@ IMFYCbCrImage::GetD3D9TextureClient(KnowsCompositor* aForwarder)
return nullptr;
}
mTextureClient = TextureClient::CreateWithData(
DXGIYCbCrTextureData::Create(TextureFlags::DEFAULT,
textureY, textureCb, textureCr,
shareHandleY, shareHandleCb, shareHandleCr,
GetSize(), mData.mYSize, mData.mCbCrSize),
TextureFlags::DEFAULT,
aForwarder->GetTextureForwarder()
);
return mTextureClient;
return DXGIYCbCrTextureData::Create(TextureFlags::DEFAULT, textureY,
textureCb, textureCr, shareHandleY,
shareHandleCb, shareHandleCr, aSize,
aData.mYSize, aData.mCbCrSize);
}
TextureClient*
IMFYCbCrImage::GetTextureClient(KnowsCompositor* aForwarder)
DXGIYCbCrTextureData*
IMFYCbCrImage::GetD3D11TextureData(Data aData, gfx::IntSize aSize)
{
if (mTextureClient) {
return mTextureClient;
}
HRESULT hr;
RefPtr<ID3D10Multithread> mt;
RefPtr<ID3D11Device> device =
gfx::DeviceManagerDx::Get()->GetContentDevice();
if (!device) {
device =
gfx::DeviceManagerDx::Get()->GetCompositorDevice();
}
LayersBackend backend = aForwarder->GetCompositorBackendType();
if (!device || backend != LayersBackend::LAYERS_D3D11) {
if (backend == LayersBackend::LAYERS_D3D9 ||
backend == LayersBackend::LAYERS_D3D11) {
return GetD3D9TextureClient(aForwarder);
}
return nullptr;
}
HRESULT hr;
RefPtr<ID3D10Multithread> mt;
hr = device->QueryInterface((ID3D10Multithread**)getter_AddRefs(mt));
if (FAILED(hr)) {
@ -263,13 +246,13 @@ IMFYCbCrImage::GetTextureClient(KnowsCompositor* aForwarder)
return nullptr;
}
if (mData.mYStride < 0 || mData.mCbCrStride < 0) {
if (aData.mYStride < 0 || aData.mCbCrStride < 0) {
// D3D11 only supports unsigned stride values.
return nullptr;
}
CD3D11_TEXTURE2D_DESC newDesc(DXGI_FORMAT_R8_UNORM,
mData.mYSize.width, mData.mYSize.height, 1, 1);
aData.mYSize.width, aData.mYSize.height, 1, 1);
if (device == gfx::DeviceManagerDx::Get()->GetCompositorDevice()) {
newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
@ -281,8 +264,8 @@ IMFYCbCrImage::GetTextureClient(KnowsCompositor* aForwarder)
hr = device->CreateTexture2D(&newDesc, nullptr, getter_AddRefs(textureY));
NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
newDesc.Width = mData.mCbCrSize.width;
newDesc.Height = mData.mCbCrSize.height;
newDesc.Width = aData.mCbCrSize.width;
newDesc.Height = aData.mCbCrSize.height;
RefPtr<ID3D11Texture2D> textureCb;
hr = device->CreateTexture2D(&newDesc, nullptr, getter_AddRefs(textureCb));
@ -313,28 +296,80 @@ IMFYCbCrImage::GetTextureClient(KnowsCompositor* aForwarder)
D3D11_BOX box;
box.front = box.top = box.left = 0;
box.back = 1;
box.right = mData.mYSize.width;
box.bottom = mData.mYSize.height;
ctx->UpdateSubresource(textureY, 0, &box, mData.mYChannel, mData.mYStride, 0);
box.right = aData.mYSize.width;
box.bottom = aData.mYSize.height;
ctx->UpdateSubresource(textureY, 0, &box, aData.mYChannel, aData.mYStride, 0);
box.right = mData.mCbCrSize.width;
box.bottom = mData.mCbCrSize.height;
ctx->UpdateSubresource(textureCb, 0, &box, mData.mCbChannel, mData.mCbCrStride, 0);
ctx->UpdateSubresource(textureCr, 0, &box, mData.mCrChannel, mData.mCbCrStride, 0);
box.right = aData.mCbCrSize.width;
box.bottom = aData.mCbCrSize.height;
ctx->UpdateSubresource(textureCb, 0, &box, aData.mCbChannel, aData.mCbCrStride, 0);
ctx->UpdateSubresource(textureCr, 0, &box, aData.mCrChannel, aData.mCbCrStride, 0);
mt->Leave();
}
return DXGIYCbCrTextureData::Create(TextureFlags::DEFAULT, textureY,
textureCb, textureCr, aSize, aData.mYSize,
aData.mCbCrSize);
}
TextureClient*
IMFYCbCrImage::GetD3D9TextureClient(KnowsCompositor* aForwarder)
{
DXGIYCbCrTextureData* textureData = GetD3D9TextureData(mData, GetSize());
if (textureData == nullptr) {
return nullptr;
}
mTextureClient = TextureClient::CreateWithData(
DXGIYCbCrTextureData::Create(TextureFlags::DEFAULT,
textureY, textureCb, textureCr,
GetSize(), mData.mYSize, mData.mCbCrSize),
TextureFlags::DEFAULT,
textureData, TextureFlags::DEFAULT,
aForwarder->GetTextureForwarder()
);
return mTextureClient;
}
TextureClient*
IMFYCbCrImage::GetD3D11TextureClient(KnowsCompositor* aForwarder)
{
DXGIYCbCrTextureData* textureData = GetD3D11TextureData(mData, GetSize());
if (textureData == nullptr) {
return nullptr;
}
mTextureClient = TextureClient::CreateWithData(
textureData, TextureFlags::DEFAULT,
aForwarder->GetTextureForwarder()
);
return mTextureClient;
}
TextureClient*
IMFYCbCrImage::GetTextureClient(KnowsCompositor* aForwarder)
{
if (mTextureClient) {
return mTextureClient;
}
RefPtr<ID3D11Device> device =
gfx::DeviceManagerDx::Get()->GetContentDevice();
if (!device) {
device =
gfx::DeviceManagerDx::Get()->GetCompositorDevice();
}
LayersBackend backend = aForwarder->GetCompositorBackendType();
if (!device || backend != LayersBackend::LAYERS_D3D11) {
if (backend == LayersBackend::LAYERS_D3D9 ||
backend == LayersBackend::LAYERS_D3D11) {
return GetD3D9TextureClient(aForwarder);
}
return nullptr;
}
return GetD3D11TextureClient(aForwarder);
}
} // namespace layers
} // namespace mozilla

6
gfx/layers/IMFYCbCrImage.h
View File

@ -6,6 +6,7 @@
#ifndef GFX_IMFYCBCRIMAGE_H
#define GFX_IMFYCBCRIMAGE_H
#include "mozilla/layers/TextureD3D11.h"
#include "mozilla/RefPtr.h"
#include "ImageContainer.h"
#include "mfidl.h"
@ -22,9 +23,14 @@ public:
virtual TextureClient* GetTextureClient(KnowsCompositor* aForwarder) override;
static DXGIYCbCrTextureData* GetD3D9TextureData(Data aData,
gfx::IntSize aSize);
static DXGIYCbCrTextureData* GetD3D11TextureData(Data aData,
gfx::IntSize aSize);
protected:
TextureClient* GetD3D9TextureClient(KnowsCompositor* aForwarder);
TextureClient* GetD3D11TextureClient(KnowsCompositor* aForwarder);
~IMFYCbCrImage();

2
gfx/tests/gtest/TestTextureCompatibility.cpp
View File

@ -44,7 +44,7 @@ CreateTextureWithBackend(LayersBackend& aLayersBackend,
for (uint32_t i = 0; i < aTextureClients.Length(); i++) {
aTextureHosts.AppendElement(
TestCreateTextureHost(aTextureClients[i], aLayersBackend));
CreateTextureHostWithBackend(aTextureClients[i], aLayersBackend));
}
}

151
gfx/tests/gtest/TextureHelper.h
View File

@ -6,17 +6,62 @@
#include <vector>
#include "gfxImageSurface.h"
#include "gfxPlatform.h"
#include "mozilla/layers/BufferTexture.h"
#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/TextureClient.h"
#include "mozilla/layers/TextureHost.h"
#include "mozilla/RefPtr.h"
#ifdef XP_WIN
#include "DeviceManagerD3D9.h"
#include "IMFYCbCrImage.h"
#include "mozilla/gfx/DeviceManagerDx.h"
#include "mozilla/layers/TextureD3D11.h"
#include "mozilla/layers/TextureD3D9.h"
#include "mozilla/layers/TextureDIB.h"
#endif
using mozilla::gfx::SurfaceFormat;
namespace mozilla {
namespace layers {
#ifdef XP_WIN
TextureData*
CreateDXGID3D9TextureData(IntSize aSize, SurfaceFormat aFormat,
TextureFlags aTextureFlag)
{
RefPtr<IDirect3D9Ex> d3d9Ex;
HMODULE d3d9lib = LoadLibraryW(L"d3d9.dll");
decltype(Direct3DCreate9Ex)* d3d9Create =
(decltype(Direct3DCreate9Ex)*)GetProcAddress(d3d9lib, "Direct3DCreate9Ex");
HRESULT hr = d3d9Create(D3D_SDK_VERSION, getter_AddRefs(d3d9Ex));
if (!d3d9Ex) {
return nullptr;
}
D3DPRESENT_PARAMETERS params = { 0 };
params.BackBufferWidth = 1;
params.BackBufferHeight = 1;
params.BackBufferFormat = D3DFMT_A8R8G8B8;
params.BackBufferCount = 1;
params.SwapEffect = D3DSWAPEFFECT_DISCARD;
params.hDeviceWindow = nullptr;
params.Windowed = TRUE;
params.Flags = D3DPRESENTFLAG_VIDEO;
RefPtr<IDirect3DDevice9Ex> device;
hr = d3d9Ex->CreateDeviceEx(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, nullptr,
D3DCREATE_FPU_PRESERVE | D3DCREATE_MULTITHREADED |
D3DCREATE_MIXED_VERTEXPROCESSING,
&params, nullptr, getter_AddRefs(device));
return DXGID3D9TextureData::Create(aSize, aFormat, aTextureFlag, device);
}
#endif
/**
* Create a YCbCrTextureClient according to the given backend.
@ -24,7 +69,63 @@ namespace layers {
static already_AddRefed<TextureClient>
CreateYCbCrTextureClientWithBackend(LayersBackend aLayersBackend)
{
// TODO: Create TextureClient.
TextureData* data = nullptr;
IntSize size = IntSize(200, 150);
IntSize ySize = IntSize(400, 300);
RefPtr<gfxImageSurface> ySurface =
new gfxImageSurface(ySize, SurfaceFormat::A8);
RefPtr<gfxImageSurface> cbSurface =
new gfxImageSurface(size, SurfaceFormat::A8);
RefPtr<gfxImageSurface> crSurface =
new gfxImageSurface(size, SurfaceFormat::A8);
PlanarYCbCrData clientData;
clientData.mYChannel = ySurface->Data();
clientData.mCbChannel = cbSurface->Data();
clientData.mCrChannel = crSurface->Data();
clientData.mYSize = ySurface->GetSize();
clientData.mPicSize = ySurface->GetSize();
clientData.mCbCrSize = cbSurface->GetSize();
clientData.mYStride = ySurface->Stride();
clientData.mCbCrStride = cbSurface->Stride();
clientData.mStereoMode = StereoMode::MONO;
clientData.mYSkip = 0;
clientData.mCbSkip = 0;
clientData.mCrSkip = 0;
clientData.mCrSkip = 0;
clientData.mPicX = 0;
clientData.mPicX = 0;
// Create YCbCrTexture for basice backend.
if (aLayersBackend == LayersBackend::LAYERS_BASIC) {
return TextureClient::CreateForYCbCr(nullptr, clientData.mYSize,
clientData.mCbCrSize, StereoMode::MONO,
YUVColorSpace::BT601,
TextureFlags::DEALLOCATE_CLIENT);
}
#ifdef XP_WIN
RefPtr<ID3D11Device> device = DeviceManagerDx::Get()->GetContentDevice();
if (!device || aLayersBackend != LayersBackend::LAYERS_D3D11) {
if (aLayersBackend == LayersBackend::LAYERS_D3D11 ||
aLayersBackend == LayersBackend::LAYERS_D3D9) {
// Create GetD3D9TextureData.
data = IMFYCbCrImage::GetD3D9TextureData(clientData, size);
}
} else {
// Create YCbCrD3D11TextureData
data = IMFYCbCrImage::GetD3D11TextureData(clientData, size);
}
#endif
if (data) {
return MakeAndAddRef<TextureClient>(data, TextureFlags::DEALLOCATE_CLIENT,
nullptr);
}
return nullptr;
}
@ -34,7 +135,50 @@ CreateYCbCrTextureClientWithBackend(LayersBackend aLayersBackend)
static already_AddRefed<TextureClient>
CreateTextureClientWithBackend(LayersBackend aLayersBackend)
{
// TODO: Create TextureClient.
TextureData* data = nullptr;
SurfaceFormat format = gfxPlatform::GetPlatform()->Optimal2DFormatForContent(
gfxContentType::COLOR_ALPHA);
BackendType moz2DBackend =
gfxPlatform::GetPlatform()->GetContentBackendFor(aLayersBackend);
TextureAllocationFlags allocFlags = TextureAllocationFlags::ALLOC_DEFAULT;
IntSize size = IntSize(400, 300);
TextureFlags textureFlags = TextureFlags::DEALLOCATE_CLIENT;
if (!gfx::Factory::AllowedSurfaceSize(size)) {
return nullptr;
}
#ifdef XP_WIN
if (aLayersBackend == LayersBackend::LAYERS_D3D11 &&
(moz2DBackend == BackendType::DIRECT2D ||
moz2DBackend == BackendType::DIRECT2D1_1)) {
// Create DXGITextureData.
data = DXGITextureData::Create(size, format, allocFlags);
} else if (aLayersBackend == LayersBackend::LAYERS_D3D9 &&
moz2DBackend == BackendType::CAIRO) {
// Create DXGID3D9TextureData or D3D9TextureData.
data = CreateDXGID3D9TextureData(size, format, textureFlags);
if (!data && DeviceManagerD3D9::GetDevice()) {
data = D3D9TextureData::Create(size, format, allocFlags);
}
} else if (!data && format == SurfaceFormat::B8G8R8X8 &&
moz2DBackend == BackendType::CAIRO) {
// Create DIBTextureData.
data = DIBTextureData::Create(size, format, nullptr);
}
#endif
if (!data && aLayersBackend == LayersBackend::LAYERS_BASIC) {
// Create BufferTextureData.
data = BufferTextureData::Create(size, format, moz2DBackend, aLayersBackend,
textureFlags, allocFlags, nullptr);
}
if (data) {
return MakeAndAddRef<TextureClient>(data, textureFlags, nullptr);
}
return nullptr;
}
@ -42,7 +186,8 @@ CreateTextureClientWithBackend(LayersBackend aLayersBackend)
* Create a TextureHost according to the given TextureClient.
*/
already_AddRefed<TextureHost>
CreateTextureHostWithBackend(TextureClient* aClient, LayersBackend& aLayersBackend)
CreateTextureHostWithBackend(TextureClient* aClient,
LayersBackend& aLayersBackend)
{
if (!aClient) {
return nullptr;