From 51dd6c34c2aa593e77108fb97754551d75e69230 Mon Sep 17 00:00:00 2001 From: Nicolas Silva Date: Mon, 19 Oct 2015 14:46:17 +0200 Subject: [PATCH] Bug 1200595 - D3D9 TextureData implementation. r=Bas --- gfx/layers/D3D9SurfaceImage.cpp | 46 +++-- gfx/layers/D3D9SurfaceImage.h | 6 +- gfx/layers/client/TextureClient.cpp | 5 +- gfx/layers/d3d9/TextureD3D9.cpp | 270 +++++++++++----------------- gfx/layers/d3d9/TextureD3D9.h | 117 +++++------- 5 files changed, 178 insertions(+), 266 deletions(-) diff --git a/gfx/layers/D3D9SurfaceImage.cpp b/gfx/layers/D3D9SurfaceImage.cpp index 84bac69f169f..279e9dfd8e7b 100644 --- a/gfx/layers/D3D9SurfaceImage.cpp +++ b/gfx/layers/D3D9SurfaceImage.cpp @@ -56,14 +56,15 @@ D3D9SurfaceImage::AllocateAndCopy(D3D9RecycleAllocator* aAllocator, // 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. - RefPtr textureClient = + RefPtr textureClient = aAllocator->CreateOrRecycleClient(gfx::SurfaceFormat::B8G8R8X8, aRegion.Size()); if (!textureClient) { return E_FAIL; } // Copy the image onto the texture, preforming YUV -> RGB conversion if necessary. - RefPtr textureSurface = textureClient->GetD3D9Surface(); + RefPtr textureSurface = static_cast( + textureClient->GetInternalData())->GetD3D9Surface(); if (!textureSurface) { return E_FAIL; } @@ -121,7 +122,7 @@ D3D9SurfaceImage::EnsureSynchronized() const D3DSURFACE_DESC& D3D9SurfaceImage::GetDesc() const { - return mTextureClient->GetDesc(); + return static_cast(mTextureClient->GetInternalData())->GetDesc(); } gfx::IntSize @@ -142,7 +143,9 @@ D3D9SurfaceImage::GetTextureClient(CompositableClient* aClient) already_AddRefed D3D9SurfaceImage::GetAsSourceSurface() { - NS_ENSURE_TRUE(mTextureClient, nullptr); + if (!mTextureClient) { + return nullptr; + } HRESULT hr; RefPtr surface = gfx::Factory::CreateDataSourceSurface(mSize, gfx::SurfaceFormat::B8G8R8X8); @@ -153,14 +156,15 @@ D3D9SurfaceImage::GetAsSourceSurface() // Ensure that the texture is ready to be used. EnsureSynchronized(); + DXGID3D9TextureData* texData = static_cast(mTextureClient->GetInternalData()); // Readback the texture from GPU memory into system memory, so that // we can copy it into the Cairo image. This is expensive. - RefPtr textureSurface = mTextureClient->GetD3D9Surface(); + RefPtr textureSurface = texData->GetD3D9Surface(); if (!textureSurface) { return nullptr; } - RefPtr device = mTextureClient->GetD3D9Device(); + RefPtr device = texData->GetD3D9Device(); if (!device) { return nullptr; } @@ -208,28 +212,20 @@ D3D9RecycleAllocator::Allocate(gfx::SurfaceFormat aFormat, TextureFlags aTextureFlags, TextureAllocationFlags aAllocFlags) { - return SharedTextureClientD3D9::Create(mSurfaceAllocator, - aFormat, - aTextureFlags, - mDevice, - aSize); -} - -already_AddRefed -D3D9RecycleAllocator::CreateOrRecycleClient(gfx::SurfaceFormat aFormat, - const gfx::IntSize& aSize) -{ - RefPtr textureClient = - CreateOrRecycle(aFormat, - aSize, - BackendSelector::Content, - layers::TextureFlags::DEFAULT); - if (!textureClient) { + TextureData* data = DXGID3D9TextureData::Create(aSize, aFormat, aTextureFlags, mDevice); + if (!data) { return nullptr; } - RefPtr textureD3D9 = static_cast(textureClient.get()); - return textureD3D9.forget(); + return MakeAndAddRef(data, aTextureFlags, mSurfaceAllocator); +} + +already_AddRefed +D3D9RecycleAllocator::CreateOrRecycleClient(gfx::SurfaceFormat aFormat, + const gfx::IntSize& aSize) +{ + return CreateOrRecycle(aFormat, aSize, BackendSelector::Content, + TextureFlags::DEFAULT); } } // namespace layers diff --git a/gfx/layers/D3D9SurfaceImage.h b/gfx/layers/D3D9SurfaceImage.h index b5a38447fc1f..86c7616ad2e4 100644 --- a/gfx/layers/D3D9SurfaceImage.h +++ b/gfx/layers/D3D9SurfaceImage.h @@ -15,7 +15,7 @@ namespace mozilla { namespace layers { -class SharedTextureClientD3D9; +class TextureClient; class D3D9RecycleAllocator : public TextureClientRecycleAllocator { @@ -26,7 +26,7 @@ public: , mDevice(aDevice) {} - already_AddRefed + already_AddRefed CreateOrRecycleClient(gfx::SurfaceFormat aFormat, const gfx::IntSize& aSize); @@ -73,7 +73,7 @@ private: gfx::IntSize mSize; RefPtr mQuery; - RefPtr mTextureClient; + RefPtr mTextureClient; bool mValid; bool mIsFirstFrame; }; diff --git a/gfx/layers/client/TextureClient.cpp b/gfx/layers/client/TextureClient.cpp index f5f833f6ed14..0e30283bfcf3 100644 --- a/gfx/layers/client/TextureClient.cpp +++ b/gfx/layers/client/TextureClient.cpp @@ -582,7 +582,10 @@ TextureClient::CreateForDrawing(CompositableForwarder* aAllocator, aSize.height <= maxTextureSize && NS_IsMainThread()) { if (gfxWindowsPlatform::GetPlatform()->GetD3D9Device()) { - texture = new TextureClientD3D9(aAllocator, aFormat, aTextureFlags); + TextureData* data = D3D9TextureData::Create(aSize, aFormat, aAllocFlags); + if (data) { + return MakeAndAddRef(data, aTextureFlags, aAllocator); + } } } diff --git a/gfx/layers/d3d9/TextureD3D9.cpp b/gfx/layers/d3d9/TextureD3D9.cpp index 0c37f16c601a..0448a6296dad 100644 --- a/gfx/layers/d3d9/TextureD3D9.cpp +++ b/gfx/layers/d3d9/TextureD3D9.cpp @@ -442,45 +442,62 @@ DataTextureSourceD3D9::GetTileRect() return GetTileRect(mCurrentTile); } -TextureClientD3D9::TextureClientD3D9(ISurfaceAllocator* aAllocator, - gfx::SurfaceFormat aFormat, - TextureFlags aFlags) - : TextureClient(aAllocator, aFlags) - , mFormat(aFormat) - , mIsLocked(false) - , mNeedsClear(false) - , mNeedsClearWhite(false) - , mLockRect(false) + +D3D9TextureData::D3D9TextureData(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, + IDirect3DTexture9* aTexture) +: mTexture(aTexture) +, mSize(aSize) +, mFormat(aFormat) +, mNeedsClear(false) +, mNeedsClearWhite(false) { - MOZ_COUNT_CTOR(TextureClientD3D9); + MOZ_COUNT_CTOR(D3D9TextureData); } -TextureClientD3D9::~TextureClientD3D9() +D3D9TextureData::~D3D9TextureData() { - MOZ_COUNT_DTOR(TextureClientD3D9); + MOZ_COUNT_DTOR(D3D9TextureData); } -already_AddRefed -TextureClientD3D9::CreateSimilar(TextureFlags aFlags, TextureAllocationFlags aAllocFlags) const +D3D9TextureData* +D3D9TextureData::Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, + TextureAllocationFlags aAllocFlags) { - RefPtr tex = new TextureClientD3D9(mAllocator, mFormat, - mFlags | aFlags); - - if (!tex->AllocateForSurface(mSize, aAllocFlags)) { + _D3DFORMAT format = SurfaceFormatToD3D9Format(aFormat); + DeviceManagerD3D9* deviceManager = gfxWindowsPlatform::GetPlatform()->GetD3D9DeviceManager(); + RefPtr d3d9Texture = deviceManager ? deviceManager->CreateTexture(aSize, format, + D3DPOOL_SYSTEMMEM, + nullptr) + : nullptr; + if (!d3d9Texture) { + NS_WARNING("Could not create a d3d9 texture"); return nullptr; } + D3D9TextureData* data = new D3D9TextureData(aSize, aFormat, d3d9Texture); - return tex.forget(); + data->mNeedsClear = aAllocFlags & ALLOC_CLEAR_BUFFER; + data->mNeedsClearWhite = aAllocFlags & ALLOC_CLEAR_BUFFER_WHITE; + + return data; +} + +TextureData* +D3D9TextureData::CreateSimilar(ISurfaceAllocator*, TextureFlags aFlags, TextureAllocationFlags aAllocFlags) const +{ + return D3D9TextureData::Create(mSize, mFormat, aAllocFlags); +} + +void +D3D9TextureData::FinalizeOnIPDLThread(TextureClient* aWrapper) +{ + if (mTexture) { + aWrapper->KeepUntilFullDeallocation(MakeUnique>(mTexture)); + } } bool -TextureClientD3D9::Lock(OpenMode aMode) +D3D9TextureData::Lock(OpenMode aMode, FenceHandle*) { - MOZ_ASSERT(!mIsLocked); - if (!IsValid() || !IsAllocated()) { - return false; - } - if (!gfxWindowsPlatform::GetPlatform()->GetD3D9Device()) { // If the device has failed then we should not lock the surface, // even if we could. @@ -495,71 +512,44 @@ TextureClientD3D9::Lock(OpenMode aMode) return false; } } - - mIsLocked = true; - return true; } - void -TextureClientD3D9::Unlock() +D3D9TextureData::Unlock() { - MOZ_ASSERT(mIsLocked, "Unlocked called while the texture is not locked!"); - if (!mIsLocked) { - return; - } - - if (mDrawTarget) { - mDrawTarget->Flush(); - mDrawTarget = nullptr; - } - if (mLockRect) { mD3D9Surface->UnlockRect(); mLockRect = false; } - - mIsLocked = false; } bool -TextureClientD3D9::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) +D3D9TextureData::Serialize(SurfaceDescriptor& aOutDescriptor) { - MOZ_ASSERT(IsValid()); - if (!IsAllocated()) { - return false; - } - mTexture->AddRef(); // Release in TextureHostD3D9::TextureHostD3D9 aOutDescriptor = SurfaceDescriptorD3D9(reinterpret_cast(mTexture.get())); return true; } -gfx::DrawTarget* -TextureClientD3D9::BorrowDrawTarget() +already_AddRefed +D3D9TextureData::BorrowDrawTarget() { - MOZ_ASSERT(mIsLocked && mD3D9Surface); - if (!mIsLocked || !mD3D9Surface) { - NS_WARNING("Calling BorrowDrawTarget on an Unlocked TextureClient"); - gfxCriticalNote << "BorrowDrawTarget on an Unlocked TextureClient"; + MOZ_ASSERT(mD3D9Surface); + if (!mD3D9Surface) { return nullptr; } - if (mDrawTarget) { - return mDrawTarget; - } - + RefPtr dt; if (ContentForFormat(mFormat) == gfxContentType::COLOR) { RefPtr surface = new gfxWindowsSurface(mD3D9Surface); if (!surface || surface->CairoStatus()) { - NS_WARNING("Could not create surface for d3d9 surface"); - gfxCriticalNote << "Failed creation on D3D9"; + NS_WARNING("Could not create gfxASurface for d3d9 surface"); return nullptr; } - mDrawTarget = - gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(surface, mSize); - if (!mDrawTarget) { - gfxCriticalNote << "Bad draw target creation for surface D3D9 " << mSize; + dt = gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(surface, mSize); + + if (!dt) { + return nullptr; } } else { // gfxWindowsSurface don't support transparency so we can't use the d3d9 @@ -571,31 +561,31 @@ TextureClientD3D9::BorrowDrawTarget() gfxCriticalError() << "Failed to lock rect borrowing the target in D3D9 " << hexa(hr); return nullptr; } - mDrawTarget = - gfxPlatform::GetPlatform()->CreateDrawTargetForData((uint8_t*)rect.pBits, mSize, - rect.Pitch, mFormat); - if (!mDrawTarget) { - gfxCriticalNote << "Bad draw target creation for data D3D9 " << mSize << ", " << (int)mFormat; + dt = gfxPlatform::GetPlatform()->CreateDrawTargetForData((uint8_t*)rect.pBits, mSize, + rect.Pitch, mFormat); + if (!dt) { + return nullptr; } - mLockRect = true; + + mLockRect = true; } if (mNeedsClear) { - mDrawTarget->ClearRect(Rect(0, 0, GetSize().width, GetSize().height)); + dt->ClearRect(Rect(0, 0, GetSize().width, GetSize().height)); mNeedsClear = false; } if (mNeedsClearWhite) { - mDrawTarget->FillRect(Rect(0, 0, GetSize().width, GetSize().height), ColorPattern(Color(1.0, 1.0, 1.0, 1.0))); + dt->FillRect(Rect(0, 0, GetSize().width, GetSize().height), ColorPattern(Color(1.0, 1.0, 1.0, 1.0))); mNeedsClearWhite = false; } - return mDrawTarget; + return dt.forget(); } -void -TextureClientD3D9::UpdateFromSurface(gfx::SourceSurface* aSurface) +bool +D3D9TextureData::UpdateFromSurface(gfx::SourceSurface* aSurface) { - MOZ_ASSERT(mIsLocked && mD3D9Surface); + MOZ_ASSERT(mD3D9Surface); // gfxWindowsSurface don't support transparency so we can't use the d3d9 // windows surface optimization. @@ -604,25 +594,21 @@ TextureClientD3D9::UpdateFromSurface(gfx::SourceSurface* aSurface) HRESULT hr = mD3D9Surface->LockRect(&rect, nullptr, 0); if (FAILED(hr) || !rect.pBits) { gfxCriticalError() << "Failed to lock rect borrowing the target in D3D9 " << hexa(hr); - return; + return false; } RefPtr srcSurf = aSurface->GetDataSurface(); if (!srcSurf) { gfxCriticalError() << "Failed to GetDataSurface in UpdateFromSurface."; - return; - } - - if (mSize != srcSurf->GetSize() || mFormat != srcSurf->GetFormat()) { - gfxCriticalError() << "Attempt to update texture client from a surface with a different size or format! This: " << mSize << " " << mFormat << " Other: " << srcSurf->GetSize() << " " << srcSurf->GetFormat(); - return; + mD3D9Surface->UnlockRect(); + return false; } DataSourceSurface::MappedSurface sourceMap; if (!srcSurf->Map(DataSourceSurface::READ, &sourceMap)) { gfxCriticalError() << "Failed to map source surface for UpdateFromSurface."; - return; + return false; } for (int y = 0; y < srcSurf->GetSize().height; y++) { @@ -633,94 +619,65 @@ TextureClientD3D9::UpdateFromSurface(gfx::SourceSurface* aSurface) srcSurf->Unmap(); mD3D9Surface->UnlockRect(); -} -bool -TextureClientD3D9::AllocateForSurface(gfx::IntSize aSize, TextureAllocationFlags aFlags) -{ - MOZ_ASSERT(!IsAllocated()); - mSize = aSize; - _D3DFORMAT format = SurfaceFormatToD3D9Format(mFormat); - - DeviceManagerD3D9* deviceManager = gfxWindowsPlatform::GetPlatform()->GetD3D9DeviceManager(); - if (!deviceManager || - !(mTexture = deviceManager->CreateTexture(mSize, format, D3DPOOL_SYSTEMMEM, nullptr))) { - NS_WARNING("Could not create d3d9 texture"); - return false; - } - - mNeedsClear = aFlags & ALLOC_CLEAR_BUFFER; - mNeedsClearWhite = aFlags & ALLOC_CLEAR_BUFFER_WHITE; - - MOZ_ASSERT(mTexture); return true; } -SharedTextureClientD3D9::SharedTextureClientD3D9(ISurfaceAllocator* aAllocator, - gfx::SurfaceFormat aFormat, - TextureFlags aFlags) - : TextureClient(aAllocator, aFlags) - , mFormat(aFormat) - , mHandle(0) - , mIsLocked(false) +DXGID3D9TextureData::DXGID3D9TextureData(gfx::SurfaceFormat aFormat, + IDirect3DTexture9* aTexture, HANDLE aHandle, + IDirect3DDevice9* aDevice) +: mFormat(aFormat) +, mTexture(aTexture) +, mHandle(aHandle) +, mDevice(aDevice) { - MOZ_COUNT_CTOR(SharedTextureClientD3D9); + MOZ_COUNT_CTOR(DXGID3D9TextureData); } -SharedTextureClientD3D9::~SharedTextureClientD3D9() +DXGID3D9TextureData::~DXGID3D9TextureData() { - MOZ_COUNT_DTOR(SharedTextureClientD3D9); - if (mTexture) { - gfxWindowsPlatform::sD3D9SharedTextureUsed -= mDesc.Width * mDesc.Height * 4; - } -} - -void -SharedTextureClientD3D9::FinalizeOnIPDLThread() -{ - if (mTexture && mActor) { - KeepUntilFullDeallocation(MakeUnique>(mTexture)); - } + gfxWindowsPlatform::sD3D9SharedTextureUsed -= mDesc.Width * mDesc.Height * 4; + MOZ_COUNT_DTOR(DXGID3D9TextureData); } // static -already_AddRefed -SharedTextureClientD3D9::Create(ISurfaceAllocator* aAllocator, - gfx::SurfaceFormat aFormat, - TextureFlags aFlags, - IDirect3DDevice9* aDevice, - const gfx::IntSize& aSize) +DXGID3D9TextureData* +DXGID3D9TextureData::Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, + TextureFlags aFlags, + IDirect3DDevice9* aDevice) { MOZ_ASSERT(aFormat == gfx::SurfaceFormat::B8G8R8X8); + if (aFormat != gfx::SurfaceFormat::B8G8R8X8) { + return nullptr; + } RefPtr texture; HANDLE shareHandle = nullptr; - HRESULT hr = aDevice->CreateTexture(aSize.width, - aSize.height, + HRESULT hr = aDevice->CreateTexture(aSize.width, aSize.height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, getter_AddRefs(texture), &shareHandle); - NS_ENSURE_TRUE(SUCCEEDED(hr) && shareHandle, nullptr); + if (FAILED(hr) || !shareHandle) { + return nullptr; + } - RefPtr client = - new SharedTextureClientD3D9(aAllocator, - aFormat, - aFlags); - - client->mDevice = aDevice; - client->mTexture = texture; - client->mHandle = shareHandle; - texture->GetLevelDesc(0, &client->mDesc); + 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::sD3D9SharedTextureUsed += aSize.width * aSize.height * 4; - return client.forget(); + return data; } already_AddRefed -SharedTextureClientD3D9::GetD3D9Surface() const +DXGID3D9TextureData::GetD3D9Surface() const { RefPtr textureSurface; HRESULT hr = mTexture->GetSurfaceLevel(0, getter_AddRefs(textureSurface)); @@ -730,34 +687,13 @@ SharedTextureClientD3D9::GetD3D9Surface() const } bool -SharedTextureClientD3D9::Lock(OpenMode) +DXGID3D9TextureData::Serialize(SurfaceDescriptor& aOutDescriptor) { - MOZ_ASSERT(!mIsLocked); - if (!IsValid()) { - return false; - } - mIsLocked = true; - return true; -} - -void -SharedTextureClientD3D9::Unlock() -{ - MOZ_ASSERT(mIsLocked, "Unlock called while the texture is not locked!"); -} - -bool -SharedTextureClientD3D9::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) -{ - MOZ_ASSERT(IsValid()); - if (!IsAllocated()) { - return false; - } - aOutDescriptor = SurfaceDescriptorD3D10((WindowsHandle)(mHandle), mFormat, GetSize()); return true; } + TextureHostD3D9::TextureHostD3D9(TextureFlags aFlags, const SurfaceDescriptorD3D9& aDescriptor) : TextureHost(aFlags) diff --git a/gfx/layers/d3d9/TextureD3D9.h b/gfx/layers/d3d9/TextureD3D9.h index 46f9234fc713..604896e1cecd 100644 --- a/gfx/layers/d3d9/TextureD3D9.h +++ b/gfx/layers/d3d9/TextureD3D9.h @@ -10,6 +10,7 @@ #include "mozilla/layers/TextureClient.h" #include "mozilla/layers/TextureHost.h" #include "mozilla/GfxMessageUtils.h" +#include "mozilla/gfx/2D.h" #include "gfxWindowsPlatform.h" #include "d3d9.h" #include @@ -174,52 +175,49 @@ protected: * Needs a D3D9 context on the client side. * The corresponding TextureHost is TextureHostD3D9. */ -class TextureClientD3D9 : public TextureClient +class D3D9TextureData : public TextureData { public: - TextureClientD3D9(ISurfaceAllocator* aAllocator, gfx::SurfaceFormat aFormat, - TextureFlags aFlags); + ~D3D9TextureData(); - virtual ~TextureClientD3D9(); - - // TextureClient - - virtual bool IsAllocated() const override { return !!mTexture; } - - virtual bool Lock(OpenMode aOpenMode) override; - - virtual void Unlock() override; - - virtual bool IsLocked() const override { return mIsLocked; } - - virtual bool ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) override; - - virtual gfx::IntSize GetSize() const { return mSize; } - - virtual gfx::SurfaceFormat GetFormat() const { return mFormat; } - - virtual bool CanExposeDrawTarget() const override { return true; } - - virtual gfx::DrawTarget* BorrowDrawTarget() override; - - virtual void UpdateFromSurface(gfx::SourceSurface* aSurface) override; - - virtual bool AllocateForSurface(gfx::IntSize aSize, - TextureAllocationFlags aFlags = ALLOC_DEFAULT) override; + virtual bool SupportsMoz2D() const override { return true; } virtual bool HasInternalBuffer() const override { return true; } - virtual already_AddRefed - CreateSimilar(TextureFlags aFlags = TextureFlags::DEFAULT, - TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT) const override; + virtual bool Serialize(SurfaceDescriptor& aOutDescrptor) override; + + virtual bool Lock(OpenMode aMode, FenceHandle*) override; + + virtual void Unlock() override; + + virtual already_AddRefed BorrowDrawTarget() override; + + virtual gfx::SurfaceFormat GetFormat() const override { return mFormat; } + + virtual gfx::IntSize GetSize() const override { return mSize; } + + virtual bool UpdateFromSurface(gfx::SourceSurface* aSurface) override; + + virtual TextureData* + CreateSimilar(ISurfaceAllocator* aAllocator, + TextureFlags aFlags, + TextureAllocationFlags aAllocFlags) const override; + + static D3D9TextureData* + Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, TextureAllocationFlags aFlags); + + virtual void Deallocate(ISurfaceAllocator* aAllocator) {} + +protected: + virtual void FinalizeOnIPDLThread(TextureClient* aWrapper) override; + + D3D9TextureData(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, + IDirect3DTexture9* aTexture); -private: RefPtr mTexture; RefPtr mD3D9Surface; - RefPtr mDrawTarget; gfx::IntSize mSize; gfx::SurfaceFormat mFormat; - bool mIsLocked; bool mNeedsClear; bool mNeedsClearWhite; bool mLockRect; @@ -230,49 +228,27 @@ private: * At the moment it is only used with D3D11 compositing, and the corresponding * TextureHost is DXGITextureHostD3D11. */ -class SharedTextureClientD3D9 : public TextureClient +class DXGID3D9TextureData : public TextureData { public: - SharedTextureClientD3D9(ISurfaceAllocator* aAllocator, - gfx::SurfaceFormat aFormat, - TextureFlags aFlags); + static DXGID3D9TextureData* + Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, TextureFlags aFlags, IDirect3DDevice9* aDevice); - virtual ~SharedTextureClientD3D9(); + ~DXGID3D9TextureData(); - // Creates a TextureClient and init width. - static already_AddRefed - Create(ISurfaceAllocator* aAllocator, - gfx::SurfaceFormat aFormat, - TextureFlags aFlags, - IDirect3DDevice9* aDevice, - const gfx::IntSize& aSize); - - // TextureClient - - virtual bool IsAllocated() const override { return !!mTexture; } + virtual gfx::IntSize GetSize() const { return gfx::IntSize(mDesc.Width, mDesc.Height); } virtual gfx::SurfaceFormat GetFormat() const override { return mFormat; } - virtual bool Lock(OpenMode aOpenMode) override; + virtual bool Lock(OpenMode, FenceHandle*) override { return true; } - virtual void Unlock() override; + virtual void Unlock() override {} - virtual bool IsLocked() const override { return mIsLocked; } + virtual bool Serialize(SurfaceDescriptor& aOutDescriptor) override; - virtual bool ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) override; + virtual bool HasInternalBuffer() const override { return false; } - virtual gfx::IntSize GetSize() const - { - return gfx::IntSize(mDesc.Width, mDesc.Height); - } - - virtual bool HasInternalBuffer() const override { return true; } - - // This TextureClient should not be used in a context where we use CreateSimilar - // (ex. component alpha) because the underlying texture data is always created by - // an external producer. - virtual already_AddRefed - CreateSimilar(TextureFlags, TextureAllocationFlags) const override { return nullptr; } + virtual void Deallocate(ISurfaceAllocator* aAllocator) {} IDirect3DDevice9* GetD3D9Device() { return mDevice; } IDirect3DTexture9* GetD3D9Texture() { return mTexture; } @@ -284,15 +260,16 @@ public: return mDesc; } -private: - virtual void FinalizeOnIPDLThread() override; +protected: + DXGID3D9TextureData(gfx::SurfaceFormat aFormat, + IDirect3DTexture9* aTexture, HANDLE aHandle, + IDirect3DDevice9* aDevice); RefPtr mDevice; RefPtr mTexture; gfx::SurfaceFormat mFormat; HANDLE mHandle; D3DSURFACE_DESC mDesc; - bool mIsLocked; }; class TextureHostD3D9 : public TextureHost