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

Bug 1285692 - Remove unnecessary KeyedMutex usage with DX_interop. - r=jrmuizel

Browse Source 
While we've been doing AcquireSync()+LockObject() previously, this doesn't
seem to be required. It makes sense that LockObject would AcquireSync (or
in-driver equivalent) when given a KeyedMutex'd D3D11Texture, given the
wording of the spec that (Un)LockObject synchronizes GL with D3D.
Unfortunately, the extension spec doesn't explicitly state this.

MozReview-Commit-ID: 3FgNl1npO34
This commit is contained in:
Jeff Gilbert 2016-07-08 17:54:14 -07:00
parent 4f5557b7e1
commit 3593dd9aad
2 changed files with 4 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
gfx/gl/SharedSurfaceD3D11Interop.cpp
View File

@ -245,13 +245,6 @@ SharedSurface_D3D11Interop::Create(const RefPtr<DXGLDevice>& dxgl,
return nullptr; return nullptr;
} }
RefPtr<IDXGIKeyedMutex> keyedMutex;
hr = textureD3D->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(keyedMutex));
if (FAILED(hr)) {
NS_WARNING("Failed to obtained keyed mutex from texture!");
return nullptr;
}
HANDLE sharedHandle; HANDLE sharedHandle;
textureDXGI->GetSharedHandle(&sharedHandle); textureDXGI->GetSharedHandle(&sharedHandle);
@ -268,7 +261,7 @@ SharedSurface_D3D11Interop::Create(const RefPtr<DXGLDevice>& dxgl,
typedef SharedSurface_D3D11Interop ptrT; typedef SharedSurface_D3D11Interop ptrT;
UniquePtr<ptrT> ret ( new ptrT(gl, size, hasAlpha, renderbufferGL, dxgl, objectWGL, UniquePtr<ptrT> ret ( new ptrT(gl, size, hasAlpha, renderbufferGL, dxgl, objectWGL,
textureD3D, sharedHandle, keyedMutex) ); textureD3D, sharedHandle) );
return Move(ret); return Move(ret);
} }
@ -279,8 +272,7 @@ SharedSurface_D3D11Interop::SharedSurface_D3D11Interop(GLContext* gl,
const RefPtr<DXGLDevice>& dxgl, const RefPtr<DXGLDevice>& dxgl,
HANDLE objectWGL, HANDLE objectWGL,
const RefPtr<ID3D11Texture2D>& textureD3D, const RefPtr<ID3D11Texture2D>& textureD3D,
HANDLE sharedHandle, HANDLE sharedHandle)
const RefPtr<IDXGIKeyedMutex>& keyedMutex)
: SharedSurface(SharedSurfaceType::DXGLInterop2, : SharedSurface(SharedSurfaceType::DXGLInterop2,
AttachmentType::GLRenderbuffer, AttachmentType::GLRenderbuffer,
gl, gl,
@ -293,13 +285,11 @@ SharedSurface_D3D11Interop::SharedSurface_D3D11Interop(GLContext* gl,
, mTextureD3D(textureD3D) , mTextureD3D(textureD3D)
, mNeedsFinish(gfxPrefs::WebGLDXGLNeedsFinish()) , mNeedsFinish(gfxPrefs::WebGLDXGLNeedsFinish())
, mSharedHandle(sharedHandle) , mSharedHandle(sharedHandle)
, mKeyedMutex(keyedMutex)
, mLockedForGL(false)
{ } { }
SharedSurface_D3D11Interop::~SharedSurface_D3D11Interop() SharedSurface_D3D11Interop::~SharedSurface_D3D11Interop()
{ {
MOZ_ASSERT(!mLockedForGL); MOZ_ASSERT(!IsProducerAcquired());
if (!mDXGL->UnregisterObject(mObjectWGL)) { if (!mDXGL->UnregisterObject(mObjectWGL)) {
NS_WARNING("Failed to release a DXGL object, possibly leaking it."); NS_WARNING("Failed to release a DXGL object, possibly leaking it.");
@ -316,39 +306,15 @@ SharedSurface_D3D11Interop::~SharedSurface_D3D11Interop()
void void
SharedSurface_D3D11Interop::ProducerAcquireImpl() SharedSurface_D3D11Interop::ProducerAcquireImpl()
{ {
MOZ_ASSERT(!mLockedForGL);
if (mKeyedMutex) {
const uint64_t keyValue = 0;
const DWORD timeoutMs = 10000;
HRESULT hr = mKeyedMutex->AcquireSync(keyValue, timeoutMs);
if (hr == WAIT_TIMEOUT) {
// Doubt we should do this? Maybe Wait for ever?
MOZ_CRASH("GFX: d3d11Interop timeout");
}
}
// Now we have the mutex, we can lock for GL.
MOZ_ALWAYS_TRUE(mDXGL->LockObject(mObjectWGL)); MOZ_ALWAYS_TRUE(mDXGL->LockObject(mObjectWGL));
mLockedForGL = true;
} }
void void
SharedSurface_D3D11Interop::ProducerReleaseImpl() SharedSurface_D3D11Interop::ProducerReleaseImpl()
{ {
MOZ_ASSERT(mLockedForGL);
mGL->fFlush(); mGL->fFlush();
MOZ_ALWAYS_TRUE(mDXGL->UnlockObject(mObjectWGL)); MOZ_ALWAYS_TRUE(mDXGL->UnlockObject(mObjectWGL));
mLockedForGL = false;
// Now we have unlocked for GL, we can release to consumer.
if (mKeyedMutex) {
mKeyedMutex->ReleaseSync(0);
}
if (mNeedsFinish) { if (mNeedsFinish) {
mGL->fFinish(); mGL->fFinish();
} }

7
gfx/gl/SharedSurfaceD3D11Interop.h
View File

@ -30,10 +30,6 @@ public:
const RefPtr<ID3D11Texture2D> mTextureD3D; const RefPtr<ID3D11Texture2D> mTextureD3D;
const bool mNeedsFinish; const bool mNeedsFinish;
protected:
RefPtr<IDXGIKeyedMutex> mKeyedMutex;
bool mLockedForGL;
public: public:
static UniquePtr<SharedSurface_D3D11Interop> Create(const RefPtr<DXGLDevice>& dxgl, static UniquePtr<SharedSurface_D3D11Interop> Create(const RefPtr<DXGLDevice>& dxgl,
GLContext* gl, GLContext* gl,
@ -54,8 +50,7 @@ protected:
const RefPtr<DXGLDevice>& dxgl, const RefPtr<DXGLDevice>& dxgl,
HANDLE objectWGL, HANDLE objectWGL,
const RefPtr<ID3D11Texture2D>& textureD3D, const RefPtr<ID3D11Texture2D>& textureD3D,
HANDLE sharedHandle, HANDLE sharedHandle);
const RefPtr<IDXGIKeyedMutex>& keyedMutex);
public: public:
virtual ~SharedSurface_D3D11Interop(); virtual ~SharedSurface_D3D11Interop();