diff options
Diffstat (limited to 'gfx/layers/D3D9SurfaceImage.cpp')
| -rw-r--r-- | gfx/layers/D3D9SurfaceImage.cpp | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/gfx/layers/D3D9SurfaceImage.cpp b/gfx/layers/D3D9SurfaceImage.cpp new file mode 100644 index 0000000000..2c8037a03f --- /dev/null +++ b/gfx/layers/D3D9SurfaceImage.cpp @@ -0,0 +1,275 @@ +/* -*- 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 "D3D9SurfaceImage.h" +#include "gfx2DGlue.h" +#include "gfxWindowsPlatform.h" +#include "mozilla/layers/CompositableClient.h" +#include "mozilla/layers/CompositableForwarder.h" +#include "mozilla/layers/ImageBridgeChild.h" +#include "mozilla/gfx/Types.h" +#include "mozilla/ProfilerLabels.h" + +namespace mozilla { +namespace layers { + +DXGID3D9TextureData::DXGID3D9TextureData(gfx::SurfaceFormat aFormat, + IDirect3DTexture9* aTexture, + HANDLE aHandle, + IDirect3DDevice9* aDevice) + : mDevice(aDevice), mTexture(aTexture), mFormat(aFormat), mHandle(aHandle) { + MOZ_COUNT_CTOR(DXGID3D9TextureData); +} + +DXGID3D9TextureData::~DXGID3D9TextureData() { + gfxWindowsPlatform::sD3D9SharedTextures -= mDesc.Width * mDesc.Height * 4; + MOZ_COUNT_DTOR(DXGID3D9TextureData); +} + +// static +DXGID3D9TextureData* DXGID3D9TextureData::Create(gfx::IntSize aSize, + gfx::SurfaceFormat aFormat, + TextureFlags aFlags, + IDirect3DDevice9* aDevice) { + AUTO_PROFILER_LABEL("DXGID3D9TextureData::Create", GRAPHICS); + MOZ_ASSERT(aFormat == gfx::SurfaceFormat::B8G8R8A8); + if (aFormat != gfx::SurfaceFormat::B8G8R8A8) { + return nullptr; + } + + RefPtr<IDirect3DTexture9> texture; + HANDLE shareHandle = nullptr; + HRESULT hr = aDevice->CreateTexture( + aSize.width, aSize.height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, + D3DPOOL_DEFAULT, getter_AddRefs(texture), &shareHandle); + if (FAILED(hr) || !shareHandle) { + return nullptr; + } + + D3DSURFACE_DESC surfaceDesc; + hr = texture->GetLevelDesc(0, &surfaceDesc); + if (FAILED(hr)) { + return nullptr; + } + DXGID3D9TextureData* data = + new DXGID3D9TextureData(aFormat, texture, shareHandle, aDevice); + data->mDesc = surfaceDesc; + + gfxWindowsPlatform::sD3D9SharedTextures += aSize.width * aSize.height * 4; + return data; +} + +void DXGID3D9TextureData::FillInfo(TextureData::Info& aInfo) const { + aInfo.size = GetSize(); + aInfo.format = mFormat; + aInfo.supportsMoz2D = false; + aInfo.canExposeMappedData = false; + aInfo.hasSynchronization = false; +} + +already_AddRefed<IDirect3DSurface9> DXGID3D9TextureData::GetD3D9Surface() + const { + RefPtr<IDirect3DSurface9> textureSurface; + HRESULT hr = mTexture->GetSurfaceLevel(0, getter_AddRefs(textureSurface)); + NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); + + return textureSurface.forget(); +} + +bool DXGID3D9TextureData::Serialize(SurfaceDescriptor& aOutDescriptor) { + SurfaceDescriptorD3D10 desc((WindowsHandle)(mHandle), + /* gpuProcessTextureId */ Nothing(), + /* arrayIndex */ 0, mFormat, GetSize(), + gfx::ColorSpace2::SRGB, gfx::ColorRange::FULL); + // In reality, with D3D9 we will only ever deal with RGBA textures. + bool isYUV = mFormat == gfx::SurfaceFormat::NV12 || + mFormat == gfx::SurfaceFormat::P010 || + mFormat == gfx::SurfaceFormat::P016; + if (isYUV) { + gfxCriticalError() << "Unexpected YUV format for DXGID3D9TextureData: " + << mFormat; + desc.colorSpace() = gfx::ColorSpace2::BT601_525; + desc.colorRange() = gfx::ColorRange::LIMITED; + } + aOutDescriptor = desc; + return true; +} + +D3D9SurfaceImage::D3D9SurfaceImage() + : Image(nullptr, ImageFormat::D3D9_RGB32_TEXTURE), + mSize(0, 0), + mShareHandle(0), + mValid(true) {} + +D3D9SurfaceImage::~D3D9SurfaceImage() {} + +HRESULT +D3D9SurfaceImage::AllocateAndCopy(D3D9RecycleAllocator* aAllocator, + IDirect3DSurface9* aSurface, + const gfx::IntRect& aRegion) { + NS_ENSURE_TRUE(aSurface, E_POINTER); + HRESULT hr; + RefPtr<IDirect3DSurface9> surface = aSurface; + + RefPtr<IDirect3DDevice9> device; + hr = surface->GetDevice(getter_AddRefs(device)); + NS_ENSURE_TRUE(SUCCEEDED(hr), E_FAIL); + + RefPtr<IDirect3D9> d3d9; + hr = device->GetDirect3D(getter_AddRefs(d3d9)); + NS_ENSURE_TRUE(SUCCEEDED(hr), E_FAIL); + + D3DSURFACE_DESC desc; + surface->GetDesc(&desc); + // Ensure we can convert the textures format to RGB conversion + // in StretchRect. Fail if we can't. + hr = d3d9->CheckDeviceFormatConversion(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, + desc.Format, D3DFMT_A8R8G8B8); + NS_ENSURE_TRUE(SUCCEEDED(hr), hr); + + // DXVA surfaces aren't created sharable, so we need to copy the surface + // to a sharable texture to that it's accessible to the layer manager's + // device. + if (aAllocator) { + mTextureClient = aAllocator->CreateOrRecycleClient( + gfx::SurfaceFormat::B8G8R8A8, aRegion.Size()); + if (!mTextureClient) { + return E_FAIL; + } + + DXGID3D9TextureData* texData = + static_cast<DXGID3D9TextureData*>(mTextureClient->GetInternalData()); + mTexture = texData->GetD3D9Texture(); + mShareHandle = texData->GetShareHandle(); + mDesc = texData->GetDesc(); + } else { + hr = device->CreateTexture(aRegion.Size().width, aRegion.Size().height, 1, + D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, + D3DPOOL_DEFAULT, getter_AddRefs(mTexture), + &mShareHandle); + if (FAILED(hr) || !mShareHandle) { + return E_FAIL; + } + + hr = mTexture->GetLevelDesc(0, &mDesc); + if (FAILED(hr)) { + return E_FAIL; + } + } + + // Copy the image onto the texture, preforming YUV -> RGB conversion if + // necessary. + RefPtr<IDirect3DSurface9> textureSurface = GetD3D9Surface(); + if (!textureSurface) { + return E_FAIL; + } + + RECT src = {aRegion.X(), aRegion.Y(), aRegion.XMost(), aRegion.YMost()}; + hr = + device->StretchRect(surface, &src, textureSurface, nullptr, D3DTEXF_NONE); + NS_ENSURE_TRUE(SUCCEEDED(hr), hr); + + mSize = aRegion.Size(); + return S_OK; +} + +already_AddRefed<IDirect3DSurface9> D3D9SurfaceImage::GetD3D9Surface() const { + RefPtr<IDirect3DSurface9> textureSurface; + HRESULT hr = mTexture->GetSurfaceLevel(0, getter_AddRefs(textureSurface)); + NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); + return textureSurface.forget(); +} + +HANDLE +D3D9SurfaceImage::GetShareHandle() const { return mShareHandle; } + +gfx::IntSize D3D9SurfaceImage::GetSize() const { return mSize; } + +TextureClient* D3D9SurfaceImage::GetTextureClient( + KnowsCompositor* aKnowsCompositor) { + MOZ_ASSERT(mTextureClient); + MOZ_ASSERT(mTextureClient->GetAllocator() == + aKnowsCompositor->GetTextureForwarder()); + return mTextureClient; +} + +already_AddRefed<gfx::SourceSurface> D3D9SurfaceImage::GetAsSourceSurface() { + if (!mTexture) { + return nullptr; + } + + HRESULT hr; + RefPtr<gfx::DataSourceSurface> surface = + gfx::Factory::CreateDataSourceSurface(mSize, + gfx::SurfaceFormat::B8G8R8X8); + if (NS_WARN_IF(!surface)) { + return nullptr; + } + + // Readback the texture from GPU memory into system memory, so that + // we can copy it into the Cairo image. This is expensive. + RefPtr<IDirect3DSurface9> textureSurface = GetD3D9Surface(); + if (!textureSurface) { + return nullptr; + } + + RefPtr<IDirect3DDevice9> device; + hr = textureSurface->GetDevice(getter_AddRefs(device)); + NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); + + RefPtr<IDirect3DSurface9> systemMemorySurface; + hr = device->CreateOffscreenPlainSurface( + mSize.width, mSize.height, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, + getter_AddRefs(systemMemorySurface), 0); + NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); + + hr = device->GetRenderTargetData(textureSurface, systemMemorySurface); + NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); + + D3DLOCKED_RECT rect; + hr = systemMemorySurface->LockRect(&rect, nullptr, 0); + NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); + + gfx::DataSourceSurface::MappedSurface mappedSurface; + if (!surface->Map(gfx::DataSourceSurface::WRITE, &mappedSurface)) { + systemMemorySurface->UnlockRect(); + return nullptr; + } + + const unsigned char* src = (const unsigned char*)(rect.pBits); + const unsigned srcPitch = rect.Pitch; + for (int y = 0; y < mSize.height; y++) { + memcpy(mappedSurface.mData + mappedSurface.mStride * y, + (unsigned char*)(src) + srcPitch * y, mSize.width * 4); + } + + systemMemorySurface->UnlockRect(); + surface->Unmap(); + + return surface.forget(); +} + +already_AddRefed<TextureClient> D3D9RecycleAllocator::Allocate( + gfx::SurfaceFormat aFormat, gfx::IntSize aSize, BackendSelector aSelector, + TextureFlags aTextureFlags, TextureAllocationFlags aAllocFlags) { + TextureData* data = + DXGID3D9TextureData::Create(aSize, aFormat, aTextureFlags, mDevice); + if (!data) { + return nullptr; + } + + return MakeAndAddRef<TextureClient>(data, aTextureFlags, + mKnowsCompositor->GetTextureForwarder()); +} + +already_AddRefed<TextureClient> D3D9RecycleAllocator::CreateOrRecycleClient( + gfx::SurfaceFormat aFormat, const gfx::IntSize& aSize) { + return CreateOrRecycle(aFormat, aSize, BackendSelector::Content, + TextureFlags::DEFAULT); +} + +} // namespace layers +} // namespace mozilla |