corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1674878 - Expose more detailed WR backend information to TextureFactoryIdentifier. r=jrmuizel

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D95588
This commit is contained in:
Matt Woodrow
2020-11-03 18:24:43 +00:00
parent 0e6f315550
commit b4541e6213
14 changed files with 143 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dom/media/platforms/wmf/WMFDecoderModule.cpp
View File

@@ -68,7 +68,7 @@ static bool IsRemoteAcceleratedCompositor(const SupportDecoderParams& aParams) {
TextureFactoryIdentifier ident =
aParams.mKnowsCompositor->GetTextureFactoryIdentifier();
return ident.mParentBackend != LayersBackend::LAYERS_BASIC &&
!ident.mUsingSoftwareWebRender &&
!aParams.mKnowsCompositor->UsingSoftwareWebRender() &&
ident.mParentProcessType == GeckoProcessType_GPU;
}

34
gfx/layers/CompositorTypes.h
View File

@@ -178,6 +178,8 @@ typedef uintptr_t SyncHandle;
*/
struct TextureFactoryIdentifier {
LayersBackend mParentBackend;
WebRenderBackend mWebRenderBackend;
WebRenderCompositor mWebRenderCompositor;
GeckoProcessType mParentProcessType;
int32_t mMaxTextureSize;
bool mSupportsTextureDirectMapping;
@@ -188,7 +190,6 @@ struct TextureFactoryIdentifier {
bool mSupportsPartialUploads;
bool mSupportsComponentAlpha;
bool mUsingAdvancedLayers;
bool mUsingSoftwareWebRender;
SyncHandle mSyncHandle;
explicit TextureFactoryIdentifier(
@@ -201,6 +202,33 @@ struct TextureFactoryIdentifier {
bool aSupportsPartialUploads = false, bool aSupportsComponentAlpha = true,
SyncHandle aSyncHandle = 0)
: mParentBackend(aLayersBackend),
mWebRenderBackend(WebRenderBackend::HARDWARE),
mWebRenderCompositor(WebRenderCompositor::DRAW),
mParentProcessType(aParentProcessType),
mMaxTextureSize(aMaxTextureSize),
mSupportsTextureDirectMapping(aSupportsTextureDirectMapping),
mCompositorUseANGLE(aCompositorUseANGLE),
mCompositorUseDComp(aCompositorUseDComp),
mUseCompositorWnd(aUseCompositorWnd),
mSupportsTextureBlitting(aSupportsTextureBlitting),
mSupportsPartialUploads(aSupportsPartialUploads),
mSupportsComponentAlpha(aSupportsComponentAlpha),
mUsingAdvancedLayers(false),
mSyncHandle(aSyncHandle) {}
explicit TextureFactoryIdentifier(
WebRenderBackend aWebRenderBackend,
WebRenderCompositor aWebRenderCompositor,
GeckoProcessType aParentProcessType = GeckoProcessType_Default,
int32_t aMaxTextureSize = 4096,
bool aSupportsTextureDirectMapping = false,
bool aCompositorUseANGLE = false, bool aCompositorUseDComp = false,
bool aUseCompositorWnd = false, bool aSupportsTextureBlitting = false,
bool aSupportsPartialUploads = false, bool aSupportsComponentAlpha = true,
SyncHandle aSyncHandle = 0)
: mParentBackend(LayersBackend::LAYERS_WR),
mWebRenderBackend(aWebRenderBackend),
mWebRenderCompositor(aWebRenderCompositor),
mParentProcessType(aParentProcessType),
mMaxTextureSize(aMaxTextureSize),
mSupportsTextureDirectMapping(aSupportsTextureDirectMapping),
@@ -211,11 +239,12 @@ struct TextureFactoryIdentifier {
mSupportsPartialUploads(aSupportsPartialUploads),
mSupportsComponentAlpha(aSupportsComponentAlpha),
mUsingAdvancedLayers(false),
mUsingSoftwareWebRender(false),
mSyncHandle(aSyncHandle) {}
bool operator==(const TextureFactoryIdentifier& aOther) const {
return mParentBackend == aOther.mParentBackend &&
mWebRenderBackend == aOther.mWebRenderBackend &&
mWebRenderCompositor == aOther.mWebRenderCompositor &&
mParentProcessType == aOther.mParentProcessType &&
mMaxTextureSize == aOther.mMaxTextureSize &&
mSupportsTextureDirectMapping ==
@@ -227,7 +256,6 @@ struct TextureFactoryIdentifier {
mSupportsPartialUploads == aOther.mSupportsPartialUploads &&
mSupportsComponentAlpha == aOther.mSupportsComponentAlpha &&
mUsingAdvancedLayers == aOther.mUsingAdvancedLayers &&
mUsingSoftwareWebRender == aOther.mUsingSoftwareWebRender &&
mSyncHandle == aOther.mSyncHandle;
}
};

10
gfx/layers/LayersTypes.h
View File

@@ -175,6 +175,16 @@ enum class LayersBackend : int8_t {
LAYERS_LAST
};
enum class WebRenderBackend : int8_t { HARDWARE = 0, SOFTWARE, LAST };
enum class WebRenderCompositor : int8_t {
DRAW = 0,
DIRECT_COMPOSITION,
CORE_ANIMATION,
SOFTWARE,
LAST
};
const char* GetLayersBackendName(LayersBackend aBackend);
enum class TextureType : int8_t {

4
gfx/layers/ipc/KnowsCompositor.h
View File

@@ -119,7 +119,9 @@ class KnowsCompositor {
}
bool UsingSoftwareWebRender() const {
return mTextureFactoryIdentifier.mUsingSoftwareWebRender;
return GetCompositorBackendType() == layers::LayersBackend::LAYERS_WR &&
mTextureFactoryIdentifier.mWebRenderBackend ==
WebRenderBackend::SOFTWARE;
}
const TextureFactoryIdentifier& GetTextureFactoryIdentifier() const {

20
gfx/layers/ipc/LayersMessageUtils.h
View File

@@ -100,6 +100,20 @@ struct ParamTraits<mozilla::layers::LayersBackend>
mozilla::layers::LayersBackend::LAYERS_NONE,
mozilla::layers::LayersBackend::LAYERS_LAST> {};
template <>
struct ParamTraits<mozilla::layers::WebRenderBackend>
: public ContiguousEnumSerializer<
mozilla::layers::WebRenderBackend,
mozilla::layers::WebRenderBackend::HARDWARE,
mozilla::layers::WebRenderBackend::LAST> {};
template <>
struct ParamTraits<mozilla::layers::WebRenderCompositor>
: public ContiguousEnumSerializer<
mozilla::layers::WebRenderCompositor,
mozilla::layers::WebRenderCompositor::DRAW,
mozilla::layers::WebRenderCompositor::LAST> {};
template <>
struct ParamTraits<mozilla::layers::TextureType>
: public ContiguousEnumSerializer<mozilla::layers::TextureType,
@@ -462,6 +476,8 @@ struct ParamTraits<mozilla::layers::TextureFactoryIdentifier> {
static void Write(Message* aMsg, const paramType& aParam) {
WriteParam(aMsg, aParam.mParentBackend);
WriteParam(aMsg, aParam.mWebRenderBackend);
WriteParam(aMsg, aParam.mWebRenderCompositor);
WriteParam(aMsg, aParam.mParentProcessType);
WriteParam(aMsg, aParam.mMaxTextureSize);
WriteParam(aMsg, aParam.mSupportsTextureDirectMapping);
@@ -472,7 +488,6 @@ struct ParamTraits<mozilla::layers::TextureFactoryIdentifier> {
WriteParam(aMsg, aParam.mSupportsPartialUploads);
WriteParam(aMsg, aParam.mSupportsComponentAlpha);
WriteParam(aMsg, aParam.mUsingAdvancedLayers);
WriteParam(aMsg, aParam.mUsingSoftwareWebRender);
WriteParam(aMsg, aParam.mSyncHandle);
}
@@ -480,6 +495,8 @@ struct ParamTraits<mozilla::layers::TextureFactoryIdentifier> {
paramType* aResult) {
bool result =
ReadParam(aMsg, aIter, &aResult->mParentBackend) &&
ReadParam(aMsg, aIter, &aResult->mWebRenderBackend) &&
ReadParam(aMsg, aIter, &aResult->mWebRenderCompositor) &&
ReadParam(aMsg, aIter, &aResult->mParentProcessType) &&
ReadParam(aMsg, aIter, &aResult->mMaxTextureSize) &&
ReadParam(aMsg, aIter, &aResult->mSupportsTextureDirectMapping) &&
@@ -490,7 +507,6 @@ struct ParamTraits<mozilla::layers::TextureFactoryIdentifier> {
ReadParam(aMsg, aIter, &aResult->mSupportsPartialUploads) &&
ReadParam(aMsg, aIter, &aResult->mSupportsComponentAlpha) &&
ReadParam(aMsg, aIter, &aResult->mUsingAdvancedLayers) &&
ReadParam(aMsg, aIter, &aResult->mUsingSoftwareWebRender) &&
ReadParam(aMsg, aIter, &aResult->mSyncHandle);
return result;
}

17
gfx/layers/wr/WebRenderBridgeParent.cpp
View File

@@ -641,7 +641,7 @@ bool WebRenderBridgeParent::UpdateResources(
if (scheduleRelease) {
// When software WR is enabled, shared surfaces are read during rendering
// rather than copied to the texture cache.
wr::Checkpoint when = gfx::gfxVars::UseSoftwareWebRender()
wr::Checkpoint when = mApi->GetBackendType() == WebRenderBackend::SOFTWARE
? wr::Checkpoint::FrameRendered
: wr::Checkpoint::FrameTexturesUpdated;
aUpdates.Notify(when, std::move(scheduleRelease));
@@ -708,7 +708,7 @@ bool WebRenderBridgeParent::AddSharedExternalImage(
mSharedSurfaceIds.insert(std::make_pair(key, aExtId));
auto imageType =
gfx::gfxVars::UseSoftwareWebRender()
mApi->GetBackendType() == WebRenderBackend::SOFTWARE
? wr::ExternalImageType::TextureHandle(wr::TextureTarget::Default)
: wr::ExternalImageType::Buffer();
wr::ImageDescriptor descriptor(dSurf->GetSize(), dSurf->Stride(),
@@ -822,7 +822,7 @@ bool WebRenderBridgeParent::UpdateSharedExternalImage(
}
auto imageType =
gfx::gfxVars::UseSoftwareWebRender()
mApi->GetBackendType() == WebRenderBackend::SOFTWARE
? wr::ExternalImageType::TextureHandle(wr::TextureTarget::Default)
: wr::ExternalImageType::Buffer();
wr::ImageDescriptor descriptor(dSurf->GetSize(), dSurf->Stride(),
@@ -2488,12 +2488,11 @@ mozilla::ipc::IPCResult WebRenderBridgeParent::RecvReleaseCompositable(
TextureFactoryIdentifier WebRenderBridgeParent::GetTextureFactoryIdentifier() {
MOZ_ASSERT(mApi);
TextureFactoryIdentifier ident(LayersBackend::LAYERS_WR, XRE_GetProcessType(),
mApi->GetMaxTextureSize(), false,
mApi->GetUseANGLE(), mApi->GetUseDComp(),
mAsyncImageManager->UseCompositorWnd(), false,
false, false, mApi->GetSyncHandle());
ident.mUsingSoftwareWebRender = gfx::gfxVars::UseSoftwareWebRender();
TextureFactoryIdentifier ident(
mApi->GetBackendType(), mApi->GetCompositorType(), XRE_GetProcessType(),
mApi->GetMaxTextureSize(), false, mApi->GetUseANGLE(),
mApi->GetUseDComp(), mAsyncImageManager->UseCompositorWnd(), false, false,
false, mApi->GetSyncHandle());
return ident;
}

2
gfx/layers/wr/WebRenderLayerManager.cpp
View File

@@ -157,7 +157,7 @@ CompositorBridgeChild* WebRenderLayerManager::GetCompositorBridgeChild() {
}
void WebRenderLayerManager::GetBackendName(nsAString& name) {
if (WrBridge()->GetTextureFactoryIdentifier().mUsingSoftwareWebRender) {
if (WrBridge()->UsingSoftwareWebRender()) {
name.AssignLiteral("WebRender (Software)");
} else {
name.AssignLiteral("WebRender");

7
gfx/webrender_bindings/RenderCompositor.h
View File

@@ -78,6 +78,13 @@ class RenderCompositor {
virtual bool UseTripleBuffering() const { return false; }
virtual layers::WebRenderBackend BackendType() const {
return layers::WebRenderBackend::HARDWARE;
}
virtual layers::WebRenderCompositor CompositorType() const {
return layers::WebRenderCompositor::DRAW;
}
// True if AttachExternalImage supports being used with an external
// image that maps to a RenderBufferTextureHost
virtual bool SupportsExternalBufferTextures() const { return false; }

7
gfx/webrender_bindings/RenderCompositorANGLE.h
View File

@@ -58,6 +58,13 @@ class RenderCompositorANGLE : public RenderCompositor {
bool UseTripleBuffering() const override { return mUseTripleBuffering; }
layers::WebRenderCompositor CompositorType() const override {
if (UseDComp()) {
return layers::WebRenderCompositor::DIRECT_COMPOSITION;
}
return layers::WebRenderCompositor::DRAW;
}
LayoutDeviceIntSize GetBufferSize() override;
bool IsContextLost() override;

10
gfx/webrender_bindings/RenderCompositorNative.cpp
View File

@@ -1,3 +1,5 @@
#include "RenderCompositorNative.h"
#include "RenderCompositorNative.h"
/* -*- 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
@@ -120,6 +122,14 @@ void RenderCompositorNative::Pause() {}
bool RenderCompositorNative::Resume() { return true; }
inline layers::WebRenderCompositor RenderCompositorNative::CompositorType()
const {
if (gfx::gfxVars::UseWebRenderCompositor()) {
return layers::WebRenderCompositor::CORE_ANIMATION;
}
return layers::WebRenderCompositor::DRAW;
}
LayoutDeviceIntSize RenderCompositorNative::GetBufferSize() {
return mWidget->GetClientSize();
}

6
gfx/webrender_bindings/RenderCompositorNative.h
View File

@@ -36,6 +36,8 @@ class RenderCompositorNative : public RenderCompositor {
void Pause() override;
bool Resume() override;
layers::WebRenderCompositor CompositorType() const override;
LayoutDeviceIntSize GetBufferSize() override;
bool ShouldUseNativeCompositor() override;
@@ -189,6 +191,10 @@ class RenderCompositorNativeSWGL : public RenderCompositorNative {
void CancelFrame() override;
layers::WebRenderBackend BackendType() const override {
return layers::WebRenderBackend::SOFTWARE;
}
// Maps an underlying layer and sets aData to the top left pixel of
// aValidRect. The row stride is set to aStride, note this doesn't
// mean there are always aStride bytes available per row (the

7
gfx/webrender_bindings/RenderCompositorSWGL.h
View File

@@ -33,6 +33,13 @@ class RenderCompositorSWGL : public RenderCompositor {
void Pause() override;
bool Resume() override;
layers::WebRenderBackend BackendType() const override {
return layers::WebRenderBackend::SOFTWARE;
}
layers::WebRenderCompositor CompositorType() const override {
return layers::WebRenderCompositor::SOFTWARE;
}
bool SurfaceOriginIsTopLeft() override { return true; }
LayoutDeviceIntSize GetBufferSize() override;

39
gfx/webrender_bindings/WebRenderAPI.cpp
View File

@@ -25,6 +25,8 @@
// clang-format on
namespace mozilla {
using namespace layers;
namespace wr {
MOZ_DEFINE_MALLOC_SIZE_OF(WebRenderMallocSizeOf)
@@ -57,13 +59,16 @@ static uint16_t SideBitsToHitInfoBits(SideBits aSideBits) {
class NewRenderer : public RendererEvent {
public:
NewRenderer(wr::DocumentHandle** aDocHandle,
layers::CompositorBridgeParent* aBridge, int32_t* aMaxTextureSize,
bool* aUseANGLE, bool* aUseDComp, bool* aUseTripleBuffering,
bool* aSupportsExternalBufferTextures,
layers::CompositorBridgeParent* aBridge,
WebRenderBackend* aBackend, WebRenderCompositor* aCompositor,
int32_t* aMaxTextureSize, bool* aUseANGLE, bool* aUseDComp,
bool* aUseTripleBuffering, bool* aSupportsExternalBufferTextures,
RefPtr<widget::CompositorWidget>&& aWidget,
layers::SynchronousTask* aTask, LayoutDeviceIntSize aSize,
layers::SyncHandle* aHandle, nsACString* aError)
: mDocHandle(aDocHandle),
mBackend(aBackend),
mCompositor(aCompositor),
mMaxTextureSize(aMaxTextureSize),
mUseANGLE(aUseANGLE),
mUseDComp(aUseDComp),
@@ -92,6 +97,8 @@ class NewRenderer : public RendererEvent {
return;
}
*mBackend = compositor->BackendType();
*mCompositor = compositor->CompositorType();
*mUseANGLE = compositor->UseANGLE();
*mUseDComp = compositor->UseDComp();
*mUseTripleBuffering = compositor->UseTripleBuffering();
@@ -176,6 +183,8 @@ class NewRenderer : public RendererEvent {
private:
wr::DocumentHandle** mDocHandle;
WebRenderBackend* mBackend;
WebRenderCompositor* mCompositor;
int32_t* mMaxTextureSize;
bool* mUseANGLE;
bool* mUseDComp;
@@ -343,6 +352,8 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Create(
"The FFI bindings assume size_t is the same size as uintptr_t!");
wr::DocumentHandle* docHandle = nullptr;
WebRenderBackend backend = WebRenderBackend::HARDWARE;
WebRenderCompositor compositor = WebRenderCompositor::DRAW;
int32_t maxTextureSize = 0;
bool useANGLE = false;
bool useDComp = false;
@@ -355,9 +366,9 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Create(
// task until the next time we need to access the DocumentHandle object.
layers::SynchronousTask task("Create Renderer");
auto event = MakeUnique<NewRenderer>(
&docHandle, aBridge, &maxTextureSize, &useANGLE, &useDComp,
&useTripleBuffering, &supportsExternalBufferTextures, std::move(aWidget),
&task, aSize, &syncHandle, &aError);
&docHandle, aBridge, &backend, &compositor, &maxTextureSize, &useANGLE,
&useDComp, &useTripleBuffering, &supportsExternalBufferTextures,
std::move(aWidget), &task, aSize, &syncHandle, &aError);
RenderThread::Get()->RunEvent(aWindowId, std::move(event));
task.Wait();
@@ -367,8 +378,9 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Create(
}
return RefPtr<WebRenderAPI>(
new WebRenderAPI(docHandle, aWindowId, maxTextureSize, useANGLE,
useDComp, useTripleBuffering,
new WebRenderAPI(docHandle, aWindowId, backend, compositor,
maxTextureSize, useANGLE, useDComp,
useTripleBuffering,
supportsExternalBufferTextures, syncHandle))
.forget();
}
@@ -377,9 +389,10 @@ already_AddRefed<WebRenderAPI> WebRenderAPI::Clone() {
wr::DocumentHandle* docHandle = nullptr;
wr_api_clone(mDocHandle, &docHandle);
RefPtr<WebRenderAPI> renderApi = new WebRenderAPI(
docHandle, mId, mMaxTextureSize, mUseANGLE, mUseDComp,
mUseTripleBuffering, mSupportsExternalBufferTextures, mSyncHandle);
RefPtr<WebRenderAPI> renderApi =
new WebRenderAPI(docHandle, mId, mBackend, mCompositor, mMaxTextureSize,
mUseANGLE, mUseDComp, mUseTripleBuffering,
mSupportsExternalBufferTextures, mSyncHandle);
renderApi->mRootApi = this; // Hold root api
renderApi->mRootDocumentApi = this;
@@ -391,12 +404,16 @@ wr::WrIdNamespace WebRenderAPI::GetNamespace() {
}
WebRenderAPI::WebRenderAPI(wr::DocumentHandle* aHandle, wr::WindowId aId,
WebRenderBackend aBackend,
WebRenderCompositor aCompositor,
uint32_t aMaxTextureSize, bool aUseANGLE,
bool aUseDComp, bool aUseTripleBuffering,
bool aSupportsExternalBufferTextures,
layers::SyncHandle aSyncHandle)
: mDocHandle(aHandle),
mId(aId),
mBackend(aBackend),
mCompositor(aCompositor),
mMaxTextureSize(aMaxTextureSize),
mUseANGLE(aUseANGLE),
mUseDComp(aUseDComp),

6
gfx/webrender_bindings/WebRenderAPI.h
View File

@@ -270,6 +270,8 @@ class WebRenderAPI final {
void AccumulateMemoryReport(wr::MemoryReport*);
wr::WrIdNamespace GetNamespace();
layers::WebRenderBackend GetBackendType() { return mBackend; }
layers::WebRenderCompositor GetCompositorType() { return mCompositor; }
uint32_t GetMaxTextureSize() const { return mMaxTextureSize; }
bool GetUseANGLE() const { return mUseANGLE; }
bool GetUseDComp() const { return mUseDComp; }
@@ -308,6 +310,8 @@ class WebRenderAPI final {
protected:
WebRenderAPI(wr::DocumentHandle* aHandle, wr::WindowId aId,
layers::WebRenderBackend aBackend,
layers::WebRenderCompositor aCompositor,
uint32_t aMaxTextureSize, bool aUseANGLE, bool aUseDComp,
bool aUseTripleBuffering, bool aSupportsExternalBufferTextures,
layers::SyncHandle aSyncHandle);
@@ -320,6 +324,8 @@ class WebRenderAPI final {
wr::DocumentHandle* mDocHandle;
wr::WindowId mId;
layers::WebRenderBackend mBackend;
layers::WebRenderCompositor mCompositor;
int32_t mMaxTextureSize;
bool mUseANGLE;
bool mUseDComp;