From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- gfx/webrender_bindings/Cargo.toml | 40 + gfx/webrender_bindings/DCLayerTree.cpp | 2080 ++++++++++ gfx/webrender_bindings/DCLayerTree.h | 480 +++ gfx/webrender_bindings/Moz2DImageRenderer.cpp | 481 +++ gfx/webrender_bindings/README.webrender | 23 + .../RenderAndroidHardwareBufferTextureHost.cpp | 248 ++ .../RenderAndroidHardwareBufferTextureHost.h | 73 + .../RenderAndroidSurfaceTextureHost.cpp | 326 ++ .../RenderAndroidSurfaceTextureHost.h | 96 + gfx/webrender_bindings/RenderBufferTextureHost.cpp | 254 ++ gfx/webrender_bindings/RenderBufferTextureHost.h | 81 + gfx/webrender_bindings/RenderCompositor.cpp | 286 ++ gfx/webrender_bindings/RenderCompositor.h | 222 ++ gfx/webrender_bindings/RenderCompositorANGLE.cpp | 1025 +++++ gfx/webrender_bindings/RenderCompositorANGLE.h | 160 + .../RenderCompositorD3D11SWGL.cpp | 488 +++ gfx/webrender_bindings/RenderCompositorD3D11SWGL.h | 118 + gfx/webrender_bindings/RenderCompositorEGL.cpp | 325 ++ gfx/webrender_bindings/RenderCompositorEGL.h | 75 + .../RenderCompositorLayersSWGL.cpp | 481 +++ .../RenderCompositorLayersSWGL.h | 195 + gfx/webrender_bindings/RenderCompositorNative.cpp | 672 ++++ gfx/webrender_bindings/RenderCompositorNative.h | 233 ++ gfx/webrender_bindings/RenderCompositorOGL.cpp | 126 + gfx/webrender_bindings/RenderCompositorOGL.h | 49 + gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp | 508 +++ gfx/webrender_bindings/RenderCompositorOGLSWGL.h | 104 + .../RenderCompositorRecordedFrame.h | 49 + gfx/webrender_bindings/RenderCompositorSWGL.cpp | 315 ++ gfx/webrender_bindings/RenderCompositorSWGL.h | 90 + gfx/webrender_bindings/RenderD3D11TextureHost.cpp | 775 ++++ gfx/webrender_bindings/RenderD3D11TextureHost.h | 230 ++ gfx/webrender_bindings/RenderDMABUFTextureHost.cpp | 67 + gfx/webrender_bindings/RenderDMABUFTextureHost.h | 46 + .../RenderDcompSurfaceTextureHost.cpp | 45 + .../RenderDcompSurfaceTextureHost.h | 70 + .../RenderEGLImageTextureHost.cpp | 96 + gfx/webrender_bindings/RenderEGLImageTextureHost.h | 46 + .../RenderExternalTextureHost.cpp | 265 ++ gfx/webrender_bindings/RenderExternalTextureHost.h | 81 + .../RenderMacIOSurfaceTextureHost.cpp | 157 + .../RenderMacIOSurfaceTextureHost.h | 61 + .../RenderSharedSurfaceTextureHost.cpp | 78 + .../RenderSharedSurfaceTextureHost.h | 57 + gfx/webrender_bindings/RenderTextureHost.cpp | 58 + gfx/webrender_bindings/RenderTextureHost.h | 141 + gfx/webrender_bindings/RenderTextureHostSWGL.cpp | 231 ++ gfx/webrender_bindings/RenderTextureHostSWGL.h | 80 + .../RenderTextureHostWrapper.cpp | 212 + gfx/webrender_bindings/RenderTextureHostWrapper.h | 81 + gfx/webrender_bindings/RenderThread.cpp | 1649 ++++++++ gfx/webrender_bindings/RenderThread.h | 493 +++ gfx/webrender_bindings/RendererOGL.cpp | 430 +++ gfx/webrender_bindings/RendererOGL.h | 176 + .../RendererScreenshotGrabber.cpp | 104 + gfx/webrender_bindings/RendererScreenshotGrabber.h | 101 + gfx/webrender_bindings/WebRenderAPI.cpp | 1867 +++++++++ gfx/webrender_bindings/WebRenderAPI.h | 958 +++++ gfx/webrender_bindings/WebRenderTypes.cpp | 110 + gfx/webrender_bindings/WebRenderTypes.h | 920 +++++ gfx/webrender_bindings/cbindgen.toml | 55 + gfx/webrender_bindings/moz.build | 137 + gfx/webrender_bindings/rustfmt.toml | 16 + gfx/webrender_bindings/src/bindings.rs | 4046 ++++++++++++++++++++ gfx/webrender_bindings/src/lib.rs | 43 + gfx/webrender_bindings/src/moz2d_renderer.rs | 871 +++++ gfx/webrender_bindings/src/program_cache.rs | 355 ++ gfx/webrender_bindings/src/swgl_bindings.rs | 101 + gfx/webrender_bindings/webrender_ffi.h | 123 + 69 files changed, 25135 insertions(+) create mode 100644 gfx/webrender_bindings/Cargo.toml create mode 100644 gfx/webrender_bindings/DCLayerTree.cpp create mode 100644 gfx/webrender_bindings/DCLayerTree.h create mode 100644 gfx/webrender_bindings/Moz2DImageRenderer.cpp create mode 100644 gfx/webrender_bindings/README.webrender create mode 100644 gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h create mode 100644 gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h create mode 100644 gfx/webrender_bindings/RenderBufferTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderBufferTextureHost.h create mode 100644 gfx/webrender_bindings/RenderCompositor.cpp create mode 100644 gfx/webrender_bindings/RenderCompositor.h create mode 100644 gfx/webrender_bindings/RenderCompositorANGLE.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorANGLE.h create mode 100644 gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorD3D11SWGL.h create mode 100644 gfx/webrender_bindings/RenderCompositorEGL.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorEGL.h create mode 100644 gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorLayersSWGL.h create mode 100644 gfx/webrender_bindings/RenderCompositorNative.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorNative.h create mode 100644 gfx/webrender_bindings/RenderCompositorOGL.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorOGL.h create mode 100644 gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorOGLSWGL.h create mode 100644 gfx/webrender_bindings/RenderCompositorRecordedFrame.h create mode 100644 gfx/webrender_bindings/RenderCompositorSWGL.cpp create mode 100644 gfx/webrender_bindings/RenderCompositorSWGL.h create mode 100644 gfx/webrender_bindings/RenderD3D11TextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderD3D11TextureHost.h create mode 100644 gfx/webrender_bindings/RenderDMABUFTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderDMABUFTextureHost.h create mode 100644 gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h create mode 100644 gfx/webrender_bindings/RenderEGLImageTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderEGLImageTextureHost.h create mode 100644 gfx/webrender_bindings/RenderExternalTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderExternalTextureHost.h create mode 100644 gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h create mode 100644 gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h create mode 100644 gfx/webrender_bindings/RenderTextureHost.cpp create mode 100644 gfx/webrender_bindings/RenderTextureHost.h create mode 100644 gfx/webrender_bindings/RenderTextureHostSWGL.cpp create mode 100644 gfx/webrender_bindings/RenderTextureHostSWGL.h create mode 100644 gfx/webrender_bindings/RenderTextureHostWrapper.cpp create mode 100644 gfx/webrender_bindings/RenderTextureHostWrapper.h create mode 100644 gfx/webrender_bindings/RenderThread.cpp create mode 100644 gfx/webrender_bindings/RenderThread.h create mode 100644 gfx/webrender_bindings/RendererOGL.cpp create mode 100644 gfx/webrender_bindings/RendererOGL.h create mode 100644 gfx/webrender_bindings/RendererScreenshotGrabber.cpp create mode 100644 gfx/webrender_bindings/RendererScreenshotGrabber.h create mode 100644 gfx/webrender_bindings/WebRenderAPI.cpp create mode 100644 gfx/webrender_bindings/WebRenderAPI.h create mode 100644 gfx/webrender_bindings/WebRenderTypes.cpp create mode 100644 gfx/webrender_bindings/WebRenderTypes.h create mode 100644 gfx/webrender_bindings/cbindgen.toml create mode 100644 gfx/webrender_bindings/moz.build create mode 100644 gfx/webrender_bindings/rustfmt.toml create mode 100644 gfx/webrender_bindings/src/bindings.rs create mode 100644 gfx/webrender_bindings/src/lib.rs create mode 100644 gfx/webrender_bindings/src/moz2d_renderer.rs create mode 100644 gfx/webrender_bindings/src/program_cache.rs create mode 100644 gfx/webrender_bindings/src/swgl_bindings.rs create mode 100644 gfx/webrender_bindings/webrender_ffi.h (limited to 'gfx/webrender_bindings') diff --git a/gfx/webrender_bindings/Cargo.toml b/gfx/webrender_bindings/Cargo.toml new file mode 100644 index 0000000000..f6b3fd637f --- /dev/null +++ b/gfx/webrender_bindings/Cargo.toml @@ -0,0 +1,40 @@ +[package] +name = "webrender_bindings" +version = "0.1.0" +authors = ["The Mozilla Project Developers"] +license = "MPL-2.0" + +[dependencies] +dirs = "4" +rayon = "1" +num_cpus = "1.7.0" +tracy-rs = "0.1" +euclid = { version = "0.22.5", features = ["serde"] } +app_units = "0.7" +gleam = "0.15" +log = "0.4" +nsstring = { path = "../../xpcom/rust/nsstring" } +bincode = "1.0" +uuid = { version = "1.0", features = ["v4"] } +fxhash = "0.2.1" +thin-vec = { version = "0.2.1", features = ["gecko-ffi"] } +swgl = { path = "../wr/swgl" } +wr_malloc_size_of = { path = "../wr/wr_malloc_size_of" } +gecko-profiler = { path = "../../tools/profiler/rust-api" } +remove_dir_all = "0.5.3" + +[dependencies.webrender] +path = "../wr/webrender" +version = "0.62.0" +default-features = false +features = ["capture", "serialize_program", "gecko", "sw_compositor"] + +[target.'cfg(target_os = "windows")'.dependencies] +dwrote = "0.11" +winapi = "0.3" + +[target.'cfg(target_os = "macos")'.dependencies] +core-foundation = "0.9" +core-graphics = "0.23" +foreign-types = "0.5.0" +objc = "0.2" diff --git a/gfx/webrender_bindings/DCLayerTree.cpp b/gfx/webrender_bindings/DCLayerTree.cpp new file mode 100644 index 0000000000..eee5601182 --- /dev/null +++ b/gfx/webrender_bindings/DCLayerTree.cpp @@ -0,0 +1,2080 @@ +/* -*- 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 "DCLayerTree.h" + +// - + +#include +#include +#include +#include + +// - + +#include "gfxWindowsPlatform.h" +#include "GLContext.h" +#include "GLContextEGL.h" +#include "mozilla/gfx/DeviceManagerDx.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/gfx/GPUParent.h" +#include "mozilla/gfx/Matrix.h" +#include "mozilla/layers/HelpersD3D11.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/webrender/RenderD3D11TextureHost.h" +#include "mozilla/webrender/RenderDcompSurfaceTextureHost.h" +#include "mozilla/webrender/RenderTextureHost.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/WindowsVersion.h" +#include "mozilla/Telemetry.h" +#include "nsPrintfCString.h" +#include "WinUtils.h" + +// - + +#if defined(__MINGW32__) // 64 defines both 32 and 64 +// We need to fake some things, while we wait on updates to mingw's dcomp.h +// header. Just enough that we can successfully fail to work there. +# define MOZ_MINGW_DCOMP_H_INCOMPLETE +struct IDCompositionColorMatrixEffect : public IDCompositionFilterEffect {}; +struct IDCompositionTableTransferEffect : public IDCompositionFilterEffect {}; +#endif // defined(__MINGW32__) + +namespace mozilla { +namespace wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +#define LOG_H(msg, ...) \ + MOZ_LOG(gDcompSurface, LogLevel::Debug, \ + ("DCSurfaceHandle=%p, " msg, this, ##__VA_ARGS__)) + +StaticAutoPtr DCLayerTree::sGpuOverlayInfo; + +/* static */ +UniquePtr DCLayerTree::Create(gl::GLContext* aGL, + EGLConfig aEGLConfig, + ID3D11Device* aDevice, + ID3D11DeviceContext* aCtx, + HWND aHwnd, nsACString& aError) { + RefPtr dCompDevice = + gfx::DeviceManagerDx::Get()->GetDirectCompositionDevice(); + if (!dCompDevice) { + aError.Assign("DCLayerTree(no device)"_ns); + return nullptr; + } + + auto layerTree = + MakeUnique(aGL, aEGLConfig, aDevice, aCtx, dCompDevice); + if (!layerTree->Initialize(aHwnd, aError)) { + return nullptr; + } + + return layerTree; +} + +void DCLayerTree::Shutdown() { DCLayerTree::sGpuOverlayInfo = nullptr; } + +DCLayerTree::DCLayerTree(gl::GLContext* aGL, EGLConfig aEGLConfig, + ID3D11Device* aDevice, ID3D11DeviceContext* aCtx, + IDCompositionDevice2* aCompositionDevice) + : mGL(aGL), + mEGLConfig(aEGLConfig), + mDevice(aDevice), + mCtx(aCtx), + mCompositionDevice(aCompositionDevice), + mDebugCounter(false), + mDebugVisualRedrawRegions(false), + mEGLImage(EGL_NO_IMAGE), + mColorRBO(0), + mPendingCommit(false) { + LOG("DCLayerTree::DCLayerTree()"); +} + +DCLayerTree::~DCLayerTree() { + LOG("DCLayerTree::~DCLayerTree()"); + + ReleaseNativeCompositorResources(); +} + +void DCLayerTree::ReleaseNativeCompositorResources() { + const auto gl = GetGLContext(); + + DestroyEGLSurface(); + + // Delete any cached FBO objects + for (auto it = mFrameBuffers.begin(); it != mFrameBuffers.end(); ++it) { + gl->fDeleteRenderbuffers(1, &it->depthRboId); + gl->fDeleteFramebuffers(1, &it->fboId); + } +} + +bool DCLayerTree::Initialize(HWND aHwnd, nsACString& aError) { + HRESULT hr; + + RefPtr desktopDevice; + hr = mCompositionDevice->QueryInterface( + (IDCompositionDesktopDevice**)getter_AddRefs(desktopDevice)); + if (FAILED(hr)) { + aError.Assign(nsPrintfCString( + "DCLayerTree(get IDCompositionDesktopDevice failed %lx)", hr)); + return false; + } + + hr = desktopDevice->CreateTargetForHwnd(aHwnd, TRUE, + getter_AddRefs(mCompositionTarget)); + if (FAILED(hr)) { + aError.Assign(nsPrintfCString( + "DCLayerTree(create DCompositionTarget failed %lx)", hr)); + return false; + } + + hr = mCompositionDevice->CreateVisual(getter_AddRefs(mRootVisual)); + if (FAILED(hr)) { + aError.Assign(nsPrintfCString( + "DCLayerTree(create root DCompositionVisual failed %lx)", hr)); + return false; + } + + hr = + mCompositionDevice->CreateVisual(getter_AddRefs(mDefaultSwapChainVisual)); + if (FAILED(hr)) { + aError.Assign(nsPrintfCString( + "DCLayerTree(create swap chain DCompositionVisual failed %lx)", hr)); + return false; + } + + if (gfx::gfxVars::UseWebRenderDCompVideoHwOverlayWin() || + gfx::gfxVars::UseWebRenderDCompVideoSwOverlayWin()) { + if (!InitializeVideoOverlaySupport()) { + RenderThread::Get()->HandleWebRenderError(WebRenderError::VIDEO_OVERLAY); + } + } + if (!sGpuOverlayInfo) { + // Set default if sGpuOverlayInfo was not set. + sGpuOverlayInfo = new GpuOverlayInfo(); + } + + // Initialize SwapChainInfo + SupportsSwapChainTearing(); + + mCompositionTarget->SetRoot(mRootVisual); + // Set interporation mode to nearest, to ensure 1:1 sampling. + // By default, a visual inherits the interpolation mode of the parent visual. + // If no visuals set the interpolation mode, the default for the entire visual + // tree is nearest neighbor interpolation. + mRootVisual->SetBitmapInterpolationMode( + DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR); + return true; +} + +bool FlagsSupportsOverlays(UINT flags) { + return (flags & (DXGI_OVERLAY_SUPPORT_FLAG_DIRECT | + DXGI_OVERLAY_SUPPORT_FLAG_SCALING)); +} + +// A warpper of IDXGIOutput4::CheckOverlayColorSpaceSupport() +bool CheckOverlayColorSpaceSupport(DXGI_FORMAT aDxgiFormat, + DXGI_COLOR_SPACE_TYPE aDxgiColorSpace, + RefPtr aOutput, + RefPtr aD3d11Device) { + UINT colorSpaceSupportFlags = 0; + RefPtr output4; + + if (FAILED(aOutput->QueryInterface(__uuidof(IDXGIOutput4), + getter_AddRefs(output4)))) { + return false; + } + + if (FAILED(output4->CheckOverlayColorSpaceSupport( + aDxgiFormat, aDxgiColorSpace, aD3d11Device, + &colorSpaceSupportFlags))) { + return false; + } + + return (colorSpaceSupportFlags & + DXGI_OVERLAY_COLOR_SPACE_SUPPORT_FLAG_PRESENT); +} + +bool DCLayerTree::InitializeVideoOverlaySupport() { + MOZ_ASSERT(IsWin10AnniversaryUpdateOrLater()); + + HRESULT hr; + + hr = mDevice->QueryInterface( + (ID3D11VideoDevice**)getter_AddRefs(mVideoDevice)); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to get D3D11VideoDevice: " << gfx::hexa(hr); + return false; + } + + hr = + mCtx->QueryInterface((ID3D11VideoContext**)getter_AddRefs(mVideoContext)); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to get D3D11VideoContext: " << gfx::hexa(hr); + return false; + } + + if (sGpuOverlayInfo) { + return true; + } + + UniquePtr info = MakeUnique(); + + RefPtr dxgiDevice; + RefPtr adapter; + mDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice)); + dxgiDevice->GetAdapter(getter_AddRefs(adapter)); + + unsigned int i = 0; + while (true) { + RefPtr output; + if (FAILED(adapter->EnumOutputs(i++, getter_AddRefs(output)))) { + break; + } + RefPtr output3; + if (FAILED(output->QueryInterface(__uuidof(IDXGIOutput3), + getter_AddRefs(output3)))) { + break; + } + + output3->CheckOverlaySupport(DXGI_FORMAT_NV12, mDevice, + &info->mNv12OverlaySupportFlags); + output3->CheckOverlaySupport(DXGI_FORMAT_YUY2, mDevice, + &info->mYuy2OverlaySupportFlags); + output3->CheckOverlaySupport(DXGI_FORMAT_B8G8R8A8_UNORM, mDevice, + &info->mBgra8OverlaySupportFlags); + output3->CheckOverlaySupport(DXGI_FORMAT_R10G10B10A2_UNORM, mDevice, + &info->mRgb10a2OverlaySupportFlags); + + if (FlagsSupportsOverlays(info->mNv12OverlaySupportFlags)) { + // NV12 format is preferred if it's supported. + info->mOverlayFormatUsed = DXGI_FORMAT_NV12; + info->mSupportsHardwareOverlays = true; + } + + if (!info->mSupportsHardwareOverlays && + FlagsSupportsOverlays(info->mYuy2OverlaySupportFlags)) { + // If NV12 isn't supported, fallback to YUY2 if it's supported. + info->mOverlayFormatUsed = DXGI_FORMAT_YUY2; + info->mSupportsHardwareOverlays = true; + } + + // RGB10A2 overlay is used for displaying HDR content. In Intel's + // platform, RGB10A2 overlay is enabled only when + // DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 is supported. + if (FlagsSupportsOverlays(info->mRgb10a2OverlaySupportFlags)) { + if (!CheckOverlayColorSpaceSupport( + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020, output, mDevice)) + info->mRgb10a2OverlaySupportFlags = 0; + } + + // Early out after the first output that reports overlay support. All + // outputs are expected to report the same overlay support according to + // Microsoft's WDDM documentation: + // https://docs.microsoft.com/en-us/windows-hardware/drivers/display/multiplane-overlay-hardware-requirements + if (info->mSupportsHardwareOverlays) { + break; + } + } + + if (!StaticPrefs::gfx_webrender_dcomp_video_yuv_overlay_win_AtStartup()) { + info->mOverlayFormatUsed = DXGI_FORMAT_B8G8R8A8_UNORM; + info->mSupportsHardwareOverlays = false; + } + + info->mSupportsOverlays = info->mSupportsHardwareOverlays; + + // Note: "UniquePtr::release" here is saying "release your ownership stake + // on your pointer, so that our StaticAutoPtr can take over ownership". + // (StaticAutoPtr doesn't have a move constructor that could directly steal + // the contents of a UniquePtr via std::move().) + sGpuOverlayInfo = info.release(); + + if (auto* gpuParent = gfx::GPUParent::GetSingleton()) { + gpuParent->NotifyOverlayInfo(GetOverlayInfo()); + } + + return true; +} + +DCSurface* DCLayerTree::GetSurface(wr::NativeSurfaceId aId) const { + auto surface_it = mDCSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end()); + return surface_it->second.get(); +} + +void DCLayerTree::SetDefaultSwapChain(IDXGISwapChain1* aSwapChain) { + LOG("DCLayerTree::SetDefaultSwapChain()"); + + mRootVisual->AddVisual(mDefaultSwapChainVisual, TRUE, nullptr); + mDefaultSwapChainVisual->SetContent(aSwapChain); + // Default SwapChain's visual does not need linear interporation. + mDefaultSwapChainVisual->SetBitmapInterpolationMode( + DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR); + mPendingCommit = true; +} + +void DCLayerTree::MaybeUpdateDebug() { + bool updated = false; + updated |= MaybeUpdateDebugCounter(); + updated |= MaybeUpdateDebugVisualRedrawRegions(); + if (updated) { + mPendingCommit = true; + } +} + +void DCLayerTree::MaybeCommit() { + if (!mPendingCommit) { + return; + } + mCompositionDevice->Commit(); +} + +void DCLayerTree::WaitForCommitCompletion() { + mCompositionDevice->WaitForCommitCompletion(); +} + +void DCLayerTree::DisableNativeCompositor() { + MOZ_ASSERT(mCurrentSurface.isNothing()); + MOZ_ASSERT(mCurrentLayers.empty()); + + ReleaseNativeCompositorResources(); + mPrevLayers.clear(); + mRootVisual->RemoveAllVisuals(); +} + +bool DCLayerTree::MaybeUpdateDebugCounter() { + bool debugCounter = StaticPrefs::gfx_webrender_debug_dcomp_counter(); + if (mDebugCounter == debugCounter) { + return false; + } + + RefPtr debugDevice; + HRESULT hr = mCompositionDevice->QueryInterface( + (IDCompositionDeviceDebug**)getter_AddRefs(debugDevice)); + if (FAILED(hr)) { + return false; + } + + if (debugCounter) { + debugDevice->EnableDebugCounters(); + } else { + debugDevice->DisableDebugCounters(); + } + + mDebugCounter = debugCounter; + return true; +} + +bool DCLayerTree::MaybeUpdateDebugVisualRedrawRegions() { + bool debugVisualRedrawRegions = + StaticPrefs::gfx_webrender_debug_dcomp_redraw_regions(); + if (mDebugVisualRedrawRegions == debugVisualRedrawRegions) { + return false; + } + + RefPtr visualDebug; + HRESULT hr = mRootVisual->QueryInterface( + (IDCompositionVisualDebug**)getter_AddRefs(visualDebug)); + if (FAILED(hr)) { + return false; + } + + if (debugVisualRedrawRegions) { + visualDebug->EnableRedrawRegions(); + } else { + visualDebug->DisableRedrawRegions(); + } + + mDebugVisualRedrawRegions = debugVisualRedrawRegions; + return true; +} + +void DCLayerTree::CompositorBeginFrame() { + mCurrentFrame++; + mUsedOverlayTypesInFrame = DCompOverlayTypes::NO_OVERLAY; +} + +void DCLayerTree::CompositorEndFrame() { + auto start = TimeStamp::Now(); + // Check if the visual tree of surfaces is the same as last frame. + bool same = mPrevLayers == mCurrentLayers; + + if (!same) { + // If not, we need to rebuild the visual tree. Note that addition or + // removal of tiles no longer needs to rebuild the main visual tree + // here, since they are added as children of the surface visual. + mRootVisual->RemoveAllVisuals(); + } + + for (auto it = mCurrentLayers.begin(); it != mCurrentLayers.end(); ++it) { + auto surface_it = mDCSurfaces.find(*it); + MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end()); + const auto surface = surface_it->second.get(); + // Ensure surface is trimmed to updated tile valid rects + surface->UpdateAllocatedRect(); + if (!same) { + // Add surfaces in z-order they were added to the scene. + const auto visual = surface->GetVisual(); + mRootVisual->AddVisual(visual, false, nullptr); + } + } + + mPrevLayers.swap(mCurrentLayers); + mCurrentLayers.clear(); + + mCompositionDevice->Commit(); + + auto end = TimeStamp::Now(); + mozilla::Telemetry::Accumulate(mozilla::Telemetry::COMPOSITE_SWAP_TIME, + (end - start).ToMilliseconds() * 10.); + + // Remove any framebuffers that haven't been + // used in the last 60 frames. + // + // This should use nsTArray::RemoveElementsBy once + // CachedFrameBuffer is able to properly destroy + // itself in the destructor. + const auto gl = GetGLContext(); + for (uint32_t i = 0, len = mFrameBuffers.Length(); i < len; ++i) { + auto& fb = mFrameBuffers[i]; + if ((mCurrentFrame - fb.lastFrameUsed) > 60) { + gl->fDeleteRenderbuffers(1, &fb.depthRboId); + gl->fDeleteFramebuffers(1, &fb.fboId); + mFrameBuffers.UnorderedRemoveElementAt(i); + --i; // Examine the element again, if necessary. + --len; + } + } + + if (!StaticPrefs::gfx_webrender_dcomp_video_check_slow_present()) { + return; + } + + // Disable video overlay if mCompositionDevice->Commit() with video overlay is + // too slow. It drops fps. + + const auto maxCommitWaitDurationMs = 20; + const auto maxSlowCommitCount = 5; + const auto commitDurationMs = + static_cast((end - start).ToMilliseconds()); + + nsPrintfCString marker("CommitWait overlay %u %ums ", + (uint8_t)mUsedOverlayTypesInFrame, commitDurationMs); + PROFILER_MARKER_TEXT("CommitWait", GRAPHICS, {}, marker); + + if (mUsedOverlayTypesInFrame != DCompOverlayTypes::NO_OVERLAY && + commitDurationMs > maxCommitWaitDurationMs) { + mSlowCommitCount++; + } else { + mSlowCommitCount = 0; + } + + if (mSlowCommitCount <= maxSlowCommitCount) { + return; + } + + if (mUsedOverlayTypesInFrame & DCompOverlayTypes::SOFTWARE_DECODED_VIDEO) { + gfxCriticalNoteOnce << "Sw video swapchain present is slow"; + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_SW_OVERLAY); + } + if (mUsedOverlayTypesInFrame & DCompOverlayTypes::HARDWARE_DECODED_VIDEO) { + gfxCriticalNoteOnce << "Hw video swapchain present is slow"; + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_HW_OVERLAY); + } +} + +void DCLayerTree::Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, + uint32_t* aFboId, wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) { + auto surface = GetSurface(aId.surface_id); + auto tile = surface->GetTile(aId.x, aId.y); + wr::DeviceIntPoint targetOffset{0, 0}; + + // If tile owns an IDCompositionSurface we use it, otherwise we're using an + // IDCompositionVirtualSurface owned by the DCSurface. + RefPtr compositionSurface; + if (surface->mIsVirtualSurface) { + gfx::IntRect validRect(aValidRect.min.x, aValidRect.min.y, + aValidRect.width(), aValidRect.height()); + if (!tile->mValidRect.IsEqualEdges(validRect)) { + tile->mValidRect = validRect; + surface->DirtyAllocatedRect(); + } + wr::DeviceIntSize tileSize = surface->GetTileSize(); + compositionSurface = surface->GetCompositionSurface(); + wr::DeviceIntPoint virtualOffset = surface->GetVirtualOffset(); + targetOffset.x = virtualOffset.x + tileSize.width * aId.x; + targetOffset.y = virtualOffset.y + tileSize.height * aId.y; + } else { + compositionSurface = tile->Bind(aValidRect); + } + + if (tile->mNeedsFullDraw) { + // dcomp requires that the first BeginDraw on a non-virtual surface is the + // full size of the pixel buffer. + auto tileSize = surface->GetTileSize(); + aDirtyRect.min.x = 0; + aDirtyRect.min.y = 0; + aDirtyRect.max.x = tileSize.width; + aDirtyRect.max.y = tileSize.height; + tile->mNeedsFullDraw = false; + } + + *aFboId = CreateEGLSurfaceForCompositionSurface( + aDirtyRect, aOffset, compositionSurface, targetOffset); + mCurrentSurface = Some(compositionSurface); +} + +void DCLayerTree::Unbind() { + if (mCurrentSurface.isNothing()) { + return; + } + + RefPtr surface = mCurrentSurface.ref(); + surface->EndDraw(); + + DestroyEGLSurface(); + mCurrentSurface = Nothing(); +} + +void DCLayerTree::CreateSurface(wr::NativeSurfaceId aId, + wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) { + auto it = mDCSurfaces.find(aId); + MOZ_RELEASE_ASSERT(it == mDCSurfaces.end()); + if (it != mDCSurfaces.end()) { + // DCSurface already exists. + return; + } + + // Tile size needs to be positive. + if (aTileSize.width <= 0 || aTileSize.height <= 0) { + gfxCriticalNote << "TileSize is not positive aId: " << wr::AsUint64(aId) + << " aTileSize(" << aTileSize.width << "," + << aTileSize.height << ")"; + } + + bool isVirtualSurface = + StaticPrefs::gfx_webrender_dcomp_use_virtual_surfaces_AtStartup(); + auto surface = MakeUnique(aTileSize, aVirtualOffset, + isVirtualSurface, aIsOpaque, this); + if (!surface->Initialize()) { + gfxCriticalNote << "Failed to initialize DCSurface: " << wr::AsUint64(aId); + return; + } + + mDCSurfaces[aId] = std::move(surface); +} + +void DCLayerTree::CreateExternalSurface(wr::NativeSurfaceId aId, + bool aIsOpaque) { + auto it = mDCSurfaces.find(aId); + MOZ_RELEASE_ASSERT(it == mDCSurfaces.end()); + + auto surface = MakeUnique(aIsOpaque, this); + if (!surface->Initialize()) { + gfxCriticalNote << "Failed to initialize DCExternalSurfaceWrapper: " + << wr::AsUint64(aId); + return; + } + + mDCSurfaces[aId] = std::move(surface); +} + +void DCLayerTree::DestroySurface(NativeSurfaceId aId) { + auto surface_it = mDCSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end()); + auto surface = surface_it->second.get(); + + mRootVisual->RemoveVisual(surface->GetVisual()); + mDCSurfaces.erase(surface_it); +} + +void DCLayerTree::CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) { + auto surface = GetSurface(aId); + surface->CreateTile(aX, aY); +} + +void DCLayerTree::DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) { + auto surface = GetSurface(aId); + surface->DestroyTile(aX, aY); +} + +void DCLayerTree::AttachExternalImage(wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage) { + auto surface_it = mDCSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surface_it != mDCSurfaces.end()); + surface_it->second->AttachExternalImage(aExternalImage); +} + +void DCExternalSurfaceWrapper::AttachExternalImage( + wr::ExternalImageId aExternalImage) { + if (auto* surface = EnsureSurfaceForExternalImage(aExternalImage)) { + surface->AttachExternalImage(aExternalImage); + } +} + +template +struct QI { + template + [[nodiscard]] static inline RefPtr From(FromT* const from) { + RefPtr to; + (void)from->QueryInterface(static_cast(getter_AddRefs(to))); + return to; + } +}; + +DCSurface* DCExternalSurfaceWrapper::EnsureSurfaceForExternalImage( + wr::ExternalImageId aExternalImage) { + if (mSurface) { + return mSurface.get(); + } + + // Create a new surface based on the texture type. + RenderTextureHost* texture = + RenderThread::Get()->GetRenderTexture(aExternalImage); + if (texture && texture->AsRenderDXGITextureHost()) { + mSurface.reset(new DCSurfaceVideo(mIsOpaque, mDCLayerTree)); + if (!mSurface->Initialize()) { + gfxCriticalNote << "Failed to initialize DCSurfaceVideo: " + << wr::AsUint64(aExternalImage); + mSurface = nullptr; + } + } else if (texture && texture->AsRenderDcompSurfaceTextureHost()) { + mSurface.reset(new DCSurfaceHandle(mIsOpaque, mDCLayerTree)); + if (!mSurface->Initialize()) { + gfxCriticalNote << "Failed to initialize DCSurfaceHandle: " + << wr::AsUint64(aExternalImage); + mSurface = nullptr; + } + } + if (!mSurface) { + gfxCriticalNote << "Failed to create a surface for external image: " + << gfx::hexa(texture); + return nullptr; + } + + // Add surface's visual which will contain video data to our root visual. + const auto surfaceVisual = mSurface->GetVisual(); + mVisual->AddVisual(surfaceVisual, true, nullptr); + + // - + // Apply color management. + + [&]() { + const auto cmsMode = GfxColorManagementMode(); + if (cmsMode == CMSMode::Off) return; + + const auto dcomp = mDCLayerTree->GetCompositionDevice(); + const auto dcomp3 = QI::From(dcomp); + if (!dcomp3) { + NS_WARNING( + "No IDCompositionDevice3, cannot use dcomp for color management."); + return; + } + + // - + + const auto cspace = [&]() { + const auto rangedCspace = texture->GetYUVColorSpace(); + const auto info = FromYUVRangedColorSpace(rangedCspace); + auto ret = ToColorSpace2(info.space); + if (ret == gfx::ColorSpace2::Display && cmsMode == CMSMode::All) { + ret = gfx::ColorSpace2::SRGB; + } + return ret; + }(); + + const bool rec709GammaAsSrgb = + StaticPrefs::gfx_color_management_rec709_gamma_as_srgb(); + const bool rec2020GammaAsRec709 = + StaticPrefs::gfx_color_management_rec2020_gamma_as_rec709(); + + auto cspaceDesc = color::ColorspaceDesc{}; + switch (cspace) { + case gfx::ColorSpace2::Display: + return; // No color management needed! + case gfx::ColorSpace2::SRGB: + cspaceDesc.chrom = color::Chromaticities::Srgb(); + cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb(); + break; + + case gfx::ColorSpace2::DISPLAY_P3: + cspaceDesc.chrom = color::Chromaticities::DisplayP3(); + cspaceDesc.tf = color::PiecewiseGammaDesc::DisplayP3(); + break; + + case gfx::ColorSpace2::BT601_525: + cspaceDesc.chrom = color::Chromaticities::Rec601_525_Ntsc(); + if (rec709GammaAsSrgb) { + cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb(); + } else { + cspaceDesc.tf = color::PiecewiseGammaDesc::Rec709(); + } + break; + + case gfx::ColorSpace2::BT709: + cspaceDesc.chrom = color::Chromaticities::Rec709(); + if (rec709GammaAsSrgb) { + cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb(); + } else { + cspaceDesc.tf = color::PiecewiseGammaDesc::Rec709(); + } + break; + + case gfx::ColorSpace2::BT2020: + cspaceDesc.chrom = color::Chromaticities::Rec2020(); + if (rec2020GammaAsRec709 && rec709GammaAsSrgb) { + cspaceDesc.tf = color::PiecewiseGammaDesc::Srgb(); + } else if (rec2020GammaAsRec709) { + cspaceDesc.tf = color::PiecewiseGammaDesc::Rec709(); + } else { + // Just Rec709 with slightly more precision. + cspaceDesc.tf = color::PiecewiseGammaDesc::Rec2020_12bit(); + } + break; + } + + const auto cprofileIn = color::ColorProfileDesc::From(cspaceDesc); + auto cprofileOut = mDCLayerTree->OutputColorProfile(); + bool pretendSrgb = true; + if (pretendSrgb) { + cprofileOut = color::ColorProfileDesc::From({ + color::Chromaticities::Srgb(), + color::PiecewiseGammaDesc::Srgb(), + }); + } + const auto conversion = color::ColorProfileConversionDesc::From({ + .src = cprofileIn, + .dst = cprofileOut, + }); + + // - + + auto chain = ColorManagementChain::From(*dcomp3, conversion); + mCManageChain = Some(chain); + + surfaceVisual->SetEffect(mCManageChain->last.get()); + }(); + + return mSurface.get(); +} + +void DCExternalSurfaceWrapper::PresentExternalSurface(gfx::Matrix& aTransform) { + MOZ_ASSERT(mSurface); + if (auto* surface = mSurface->AsDCSurfaceVideo()) { + if (surface->CalculateSwapChainSize(aTransform)) { + surface->PresentVideo(); + } + } else if (auto* surface = mSurface->AsDCSurfaceHandle()) { + surface->PresentSurfaceHandle(); + } +} + +template +static inline D2D1_RECT_F D2DRect(const T& aRect) { + return D2D1::RectF(aRect.X(), aRect.Y(), aRect.XMost(), aRect.YMost()); +} + +static inline D2D1_MATRIX_3X2_F D2DMatrix(const gfx::Matrix& aTransform) { + return D2D1::Matrix3x2F(aTransform._11, aTransform._12, aTransform._21, + aTransform._22, aTransform._31, aTransform._32); +} + +void DCLayerTree::AddSurface(wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering) { + auto it = mDCSurfaces.find(aId); + MOZ_RELEASE_ASSERT(it != mDCSurfaces.end()); + const auto surface = it->second.get(); + const auto visual = surface->GetVisual(); + + wr::DeviceIntPoint virtualOffset = surface->GetVirtualOffset(); + + float sx = aTransform.scale.x; + float sy = aTransform.scale.y; + float tx = aTransform.offset.x; + float ty = aTransform.offset.y; + gfx::Matrix transform(sx, 0.0, 0.0, sy, tx, ty); + + surface->PresentExternalSurface(transform); + + transform.PreTranslate(-virtualOffset.x, -virtualOffset.y); + + // The DirectComposition API applies clipping *before* any + // transforms/offset, whereas we want the clip applied after. Right now, we + // only support rectilinear transforms, and then we transform our clip into + // pre-transform coordinate space for it to be applied there. + // DirectComposition does have an option for pre-transform clipping, if you + // create an explicit IDCompositionEffectGroup object and set a 3D transform + // on that. I suspect that will perform worse though, so we should only do + // that for complex transforms (which are never provided right now). + MOZ_ASSERT(transform.IsRectilinear()); + gfx::Rect clip = transform.Inverse().TransformBounds(gfx::Rect( + aClipRect.min.x, aClipRect.min.y, aClipRect.width(), aClipRect.height())); + // Set the clip rect - converting from world space to the pre-offset space + // that DC requires for rectangle clips. + visual->SetClip(D2DRect(clip)); + + // TODO: The input matrix is a 4x4, but we only support a 3x2 at + // the D3D API level (unless we QI to IDCompositionVisual3, which might + // not be available?). + // Should we assert here, or restrict at the WR API level. + visual->SetTransform(D2DMatrix(transform)); + + if (aImageRendering == wr::ImageRendering::Auto) { + visual->SetBitmapInterpolationMode( + DCOMPOSITION_BITMAP_INTERPOLATION_MODE_LINEAR); + } else { + visual->SetBitmapInterpolationMode( + DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR); + } + + mCurrentLayers.push_back(aId); +} + +GLuint DCLayerTree::GetOrCreateFbo(int aWidth, int aHeight) { + const auto gl = GetGLContext(); + GLuint fboId = 0; + + // Check if we have a cached FBO with matching dimensions + for (auto it = mFrameBuffers.begin(); it != mFrameBuffers.end(); ++it) { + if (it->width == aWidth && it->height == aHeight) { + fboId = it->fboId; + it->lastFrameUsed = mCurrentFrame; + break; + } + } + + // If not, create a new FBO with attached depth buffer + if (fboId == 0) { + // Create the depth buffer + GLuint depthRboId; + gl->fGenRenderbuffers(1, &depthRboId); + gl->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, depthRboId); + gl->fRenderbufferStorage(LOCAL_GL_RENDERBUFFER, LOCAL_GL_DEPTH_COMPONENT24, + aWidth, aHeight); + + // Create the framebuffer and attach the depth buffer to it + gl->fGenFramebuffers(1, &fboId); + gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fboId); + gl->fFramebufferRenderbuffer(LOCAL_GL_DRAW_FRAMEBUFFER, + LOCAL_GL_DEPTH_ATTACHMENT, + LOCAL_GL_RENDERBUFFER, depthRboId); + + // Store this in the cache for future calls. + // TODO(gw): Maybe we should periodically scan this list and remove old + // entries that + // haven't been used for some time? + DCLayerTree::CachedFrameBuffer frame_buffer_info; + frame_buffer_info.width = aWidth; + frame_buffer_info.height = aHeight; + frame_buffer_info.fboId = fboId; + frame_buffer_info.depthRboId = depthRboId; + frame_buffer_info.lastFrameUsed = mCurrentFrame; + mFrameBuffers.AppendElement(frame_buffer_info); + } + + return fboId; +} + +bool DCLayerTree::EnsureVideoProcessor(const gfx::IntSize& aInputSize, + const gfx::IntSize& aOutputSize) { + HRESULT hr; + + if (!mVideoDevice || !mVideoContext) { + return false; + } + + if (mVideoProcessor && (aInputSize <= mVideoInputSize) && + (aOutputSize <= mVideoOutputSize)) { + return true; + } + + mVideoProcessor = nullptr; + mVideoProcessorEnumerator = nullptr; + + D3D11_VIDEO_PROCESSOR_CONTENT_DESC desc = {}; + desc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE; + desc.InputFrameRate.Numerator = 60; + desc.InputFrameRate.Denominator = 1; + desc.InputWidth = aInputSize.width; + desc.InputHeight = aInputSize.height; + desc.OutputFrameRate.Numerator = 60; + desc.OutputFrameRate.Denominator = 1; + desc.OutputWidth = aOutputSize.width; + desc.OutputHeight = aOutputSize.height; + desc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL; + + hr = mVideoDevice->CreateVideoProcessorEnumerator( + &desc, getter_AddRefs(mVideoProcessorEnumerator)); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to create VideoProcessorEnumerator: " + << gfx::hexa(hr); + return false; + } + + hr = mVideoDevice->CreateVideoProcessor(mVideoProcessorEnumerator, 0, + getter_AddRefs(mVideoProcessor)); + if (FAILED(hr)) { + mVideoProcessor = nullptr; + mVideoProcessorEnumerator = nullptr; + gfxCriticalNote << "Failed to create VideoProcessor: " << gfx::hexa(hr); + return false; + } + + // Reduce power cosumption + // By default, the driver might perform certain processing tasks + // automatically + mVideoContext->VideoProcessorSetStreamAutoProcessingMode(mVideoProcessor, 0, + FALSE); + + mVideoInputSize = aInputSize; + mVideoOutputSize = aOutputSize; + + return true; +} + +bool DCLayerTree::SupportsHardwareOverlays() { + return sGpuOverlayInfo->mSupportsHardwareOverlays; +} + +bool DCLayerTree::SupportsSwapChainTearing() { + RefPtr device = mDevice; + static const bool supported = [device] { + RefPtr dxgiDevice; + RefPtr adapter; + device->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice)); + dxgiDevice->GetAdapter(getter_AddRefs(adapter)); + + RefPtr dxgiFactory; + HRESULT hr = adapter->GetParent( + IID_PPV_ARGS((IDXGIFactory5**)getter_AddRefs(dxgiFactory))); + if (FAILED(hr)) { + return false; + } + + BOOL presentAllowTearing = FALSE; + hr = dxgiFactory->CheckFeatureSupport(DXGI_FEATURE_PRESENT_ALLOW_TEARING, + &presentAllowTearing, + sizeof(presentAllowTearing)); + if (FAILED(hr)) { + return false; + } + + if (auto* gpuParent = gfx::GPUParent::GetSingleton()) { + gpuParent->NotifySwapChainInfo( + layers::SwapChainInfo(!!presentAllowTearing)); + } else if (XRE_IsParentProcess()) { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + } + return !!presentAllowTearing; + }(); + return supported; +} + +DXGI_FORMAT DCLayerTree::GetOverlayFormatForSDR() { + return sGpuOverlayInfo->mOverlayFormatUsed; +} + +static layers::OverlaySupportType FlagsToOverlaySupportType( + UINT aFlags, bool aSoftwareOverlaySupported) { + if (aFlags & DXGI_OVERLAY_SUPPORT_FLAG_SCALING) { + return layers::OverlaySupportType::Scaling; + } + if (aFlags & DXGI_OVERLAY_SUPPORT_FLAG_DIRECT) { + return layers::OverlaySupportType::Direct; + } + if (aSoftwareOverlaySupported) { + return layers::OverlaySupportType::Software; + } + return layers::OverlaySupportType::None; +} + +layers::OverlayInfo DCLayerTree::GetOverlayInfo() { + layers::OverlayInfo info; + + info.mSupportsOverlays = sGpuOverlayInfo->mSupportsHardwareOverlays; + info.mNv12Overlay = + FlagsToOverlaySupportType(sGpuOverlayInfo->mNv12OverlaySupportFlags, + /* aSoftwareOverlaySupported */ false); + info.mYuy2Overlay = + FlagsToOverlaySupportType(sGpuOverlayInfo->mYuy2OverlaySupportFlags, + /* aSoftwareOverlaySupported */ false); + info.mBgra8Overlay = + FlagsToOverlaySupportType(sGpuOverlayInfo->mBgra8OverlaySupportFlags, + /* aSoftwareOverlaySupported */ true); + info.mRgb10a2Overlay = + FlagsToOverlaySupportType(sGpuOverlayInfo->mRgb10a2OverlaySupportFlags, + /* aSoftwareOverlaySupported */ false); + + return info; +} + +void DCLayerTree::SetUsedOverlayTypeInFrame(DCompOverlayTypes aTypes) { + mUsedOverlayTypesInFrame |= aTypes; +} + +DCSurface::DCSurface(wr::DeviceIntSize aTileSize, + wr::DeviceIntPoint aVirtualOffset, bool aIsVirtualSurface, + bool aIsOpaque, DCLayerTree* aDCLayerTree) + : mIsVirtualSurface(aIsVirtualSurface), + mDCLayerTree(aDCLayerTree), + mTileSize(aTileSize), + mIsOpaque(aIsOpaque), + mAllocatedRectDirty(true), + mVirtualOffset(aVirtualOffset) {} + +DCSurface::~DCSurface() {} + +bool DCSurface::Initialize() { + // Create a visual for tiles to attach to, whether virtual or not. + HRESULT hr; + const auto dCompDevice = mDCLayerTree->GetCompositionDevice(); + hr = dCompDevice->CreateVisual(getter_AddRefs(mVisual)); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to create DCompositionVisual: " << gfx::hexa(hr); + return false; + } + + // If virtual surface is enabled, create and attach to visual, in this case + // the tiles won't own visuals or surfaces. + if (mIsVirtualSurface) { + DXGI_ALPHA_MODE alpha_mode = + mIsOpaque ? DXGI_ALPHA_MODE_IGNORE : DXGI_ALPHA_MODE_PREMULTIPLIED; + + hr = dCompDevice->CreateVirtualSurface( + VIRTUAL_SURFACE_SIZE, VIRTUAL_SURFACE_SIZE, DXGI_FORMAT_R8G8B8A8_UNORM, + alpha_mode, getter_AddRefs(mVirtualSurface)); + MOZ_ASSERT(SUCCEEDED(hr)); + + // Bind the surface memory to this visual + hr = mVisual->SetContent(mVirtualSurface); + MOZ_ASSERT(SUCCEEDED(hr)); + } + + return true; +} + +void DCSurface::CreateTile(int32_t aX, int32_t aY) { + TileKey key(aX, aY); + MOZ_RELEASE_ASSERT(mDCTiles.find(key) == mDCTiles.end()); + + auto tile = MakeUnique(mDCLayerTree); + if (!tile->Initialize(aX, aY, mTileSize, mIsVirtualSurface, mIsOpaque, + mVisual)) { + gfxCriticalNote << "Failed to initialize DCTile: " << aX << aY; + return; + } + + if (mIsVirtualSurface) { + mAllocatedRectDirty = true; + } else { + mVisual->AddVisual(tile->GetVisual(), false, nullptr); + } + + mDCTiles[key] = std::move(tile); +} + +void DCSurface::DestroyTile(int32_t aX, int32_t aY) { + TileKey key(aX, aY); + if (mIsVirtualSurface) { + mAllocatedRectDirty = true; + } else { + auto tile = GetTile(aX, aY); + mVisual->RemoveVisual(tile->GetVisual()); + } + mDCTiles.erase(key); +} + +void DCSurface::DirtyAllocatedRect() { mAllocatedRectDirty = true; } + +void DCSurface::UpdateAllocatedRect() { + if (mAllocatedRectDirty) { + if (mVirtualSurface) { + // The virtual surface may have holes in it (for example, an empty tile + // that has no primitives). Instead of trimming to a single bounding + // rect, supply the rect of each valid tile to handle this case. + std::vector validRects; + + for (auto it = mDCTiles.begin(); it != mDCTiles.end(); ++it) { + auto tile = GetTile(it->first.mX, it->first.mY); + RECT rect; + + rect.left = (LONG)(mVirtualOffset.x + it->first.mX * mTileSize.width + + tile->mValidRect.x); + rect.top = (LONG)(mVirtualOffset.y + it->first.mY * mTileSize.height + + tile->mValidRect.y); + rect.right = rect.left + tile->mValidRect.width; + rect.bottom = rect.top + tile->mValidRect.height; + + validRects.push_back(rect); + } + + mVirtualSurface->Trim(validRects.data(), validRects.size()); + } + // When not using a virtual surface, we still want to reset this + mAllocatedRectDirty = false; + } +} + +DCTile* DCSurface::GetTile(int32_t aX, int32_t aY) const { + TileKey key(aX, aY); + auto tile_it = mDCTiles.find(key); + MOZ_RELEASE_ASSERT(tile_it != mDCTiles.end()); + return tile_it->second.get(); +} + +DCSurfaceVideo::DCSurfaceVideo(bool aIsOpaque, DCLayerTree* aDCLayerTree) + : DCSurface(wr::DeviceIntSize{}, wr::DeviceIntPoint{}, false, aIsOpaque, + aDCLayerTree), + mSwapChainBufferCount( + StaticPrefs::gfx_webrender_dcomp_video_force_triple_buffering() ? 3 + : 2) { +} + +DCSurfaceVideo::~DCSurfaceVideo() { + ReleaseDecodeSwapChainResources(); + MOZ_ASSERT(!mSwapChainSurfaceHandle); +} + +bool IsYUVSwapChainFormat(DXGI_FORMAT aFormat) { + if (aFormat == DXGI_FORMAT_NV12 || aFormat == DXGI_FORMAT_YUY2) { + return true; + } + return false; +} + +void DCSurfaceVideo::AttachExternalImage(wr::ExternalImageId aExternalImage) { + RenderTextureHost* texture = + RenderThread::Get()->GetRenderTexture(aExternalImage); + MOZ_RELEASE_ASSERT(texture); + + if (mPrevTexture == texture) { + return; + } + + // XXX if software decoded video frame format is nv12, it could be used as + // video overlay. + if (!texture || !texture->AsRenderDXGITextureHost() || + texture->GetFormat() != gfx::SurfaceFormat::NV12) { + gfxCriticalNote << "Unsupported RenderTexture for overlay: " + << gfx::hexa(texture); + return; + } + + mRenderTextureHost = texture; +} + +bool DCSurfaceVideo::CalculateSwapChainSize(gfx::Matrix& aTransform) { + if (!mRenderTextureHost) { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return false; + } + + const auto overlayType = mRenderTextureHost->IsSoftwareDecodedVideo() + ? DCompOverlayTypes::SOFTWARE_DECODED_VIDEO + : DCompOverlayTypes::HARDWARE_DECODED_VIDEO; + mDCLayerTree->SetUsedOverlayTypeInFrame(overlayType); + + mVideoSize = mRenderTextureHost->AsRenderDXGITextureHost()->GetSize(0); + + // When RenderTextureHost, swapChainSize or VideoSwapChain are updated, + // DCSurfaceVideo::PresentVideo() needs to be called. + bool needsToPresent = mPrevTexture != mRenderTextureHost; + gfx::IntSize swapChainSize = mVideoSize; + gfx::Matrix transform = aTransform; + const bool isDRM = mRenderTextureHost->IsFromDRMSource(); + + // When video is rendered to axis aligned integer rectangle, video scaling + // could be done by VideoProcessor + bool scaleVideoAtVideoProcessor = false; + if (StaticPrefs::gfx_webrender_dcomp_video_vp_scaling_win_AtStartup() && + aTransform.PreservesAxisAlignedRectangles()) { + gfx::Size scaledSize = gfx::Size(mVideoSize) * aTransform.ScaleFactors(); + gfx::IntSize size(int32_t(std::round(scaledSize.width)), + int32_t(std::round(scaledSize.height))); + if (gfx::FuzzyEqual(scaledSize.width, size.width, 0.1f) && + gfx::FuzzyEqual(scaledSize.height, size.height, 0.1f)) { + scaleVideoAtVideoProcessor = true; + swapChainSize = size; + } + } + + if (scaleVideoAtVideoProcessor) { + // 4:2:2 subsampled formats like YUY2 must have an even width, and 4:2:0 + // subsampled formats like NV12 must have an even width and height. + if (swapChainSize.width % 2 == 1) { + swapChainSize.width += 1; + } + if (swapChainSize.height % 2 == 1) { + swapChainSize.height += 1; + } + transform = gfx::Matrix::Translation(aTransform.GetTranslation()); + } + + if (!mVideoSwapChain || mSwapChainSize != swapChainSize || mIsDRM != isDRM) { + needsToPresent = true; + ReleaseDecodeSwapChainResources(); + // Update mSwapChainSize before creating SwapChain + mSwapChainSize = swapChainSize; + mIsDRM = isDRM; + + auto swapChainFormat = GetSwapChainFormat(); + bool useYUVSwapChain = IsYUVSwapChainFormat(swapChainFormat); + if (useYUVSwapChain) { + // Tries to create YUV SwapChain + CreateVideoSwapChain(); + if (!mVideoSwapChain) { + mFailedYuvSwapChain = true; + ReleaseDecodeSwapChainResources(); + + gfxCriticalNote << "Fallback to RGB SwapChain"; + } + } + // Tries to create RGB SwapChain + if (!mVideoSwapChain) { + CreateVideoSwapChain(); + } + } + + aTransform = transform; + + return needsToPresent; +} + +void DCSurfaceVideo::PresentVideo() { + if (!mRenderTextureHost) { + return; + } + + if (!mVideoSwapChain) { + gfxCriticalNote << "Failed to create VideoSwapChain"; + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_OVERLAY); + return; + } + + mVisual->SetContent(mVideoSwapChain); + + if (!CallVideoProcessorBlt()) { + auto swapChainFormat = GetSwapChainFormat(); + bool useYUVSwapChain = IsYUVSwapChainFormat(swapChainFormat); + if (useYUVSwapChain) { + mFailedYuvSwapChain = true; + ReleaseDecodeSwapChainResources(); + return; + } + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_OVERLAY); + return; + } + + const auto device = mDCLayerTree->GetDevice(); + HRESULT hr; + if (mFirstPresent) { + mFirstPresent = false; + UINT flags = DXGI_PRESENT_USE_DURATION; + // DirectComposition can display black for a swap chain between the first + // and second time it's presented to - maybe the first Present can get lost + // somehow and it shows the wrong buffer. In that case copy the buffers so + // all have the correct contents, which seems to help. The first Present() + // after this needs to have SyncInterval > 0, or else the workaround doesn't + // help. + for (size_t i = 0; i < mSwapChainBufferCount - 1; ++i) { + hr = mVideoSwapChain->Present(0, flags); + // Ignore DXGI_STATUS_OCCLUDED since that's not an error but only + // indicates that the window is occluded and we can stop rendering. + if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) { + gfxCriticalNoteOnce << "video Present failed during first present: " + << gfx::hexa(hr); + return; + } + + RefPtr destTexture; + mVideoSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), + (void**)getter_AddRefs(destTexture)); + MOZ_ASSERT(destTexture); + RefPtr srcTexture; + hr = mVideoSwapChain->GetBuffer(1, __uuidof(ID3D11Texture2D), + (void**)getter_AddRefs(srcTexture)); + MOZ_ASSERT(srcTexture); + RefPtr context; + device->GetImmediateContext(getter_AddRefs(context)); + MOZ_ASSERT(context); + context->CopyResource(destTexture, srcTexture); + } + + // Additionally wait for the GPU to finish executing its commands, or + // there still may be a black flicker when presenting expensive content + // (e.g. 4k video). + + RefPtr dxgiDevice2; + device->QueryInterface((IDXGIDevice2**)getter_AddRefs(dxgiDevice2)); + MOZ_ASSERT(dxgiDevice2); + + HANDLE event = ::CreateEvent(nullptr, false, false, nullptr); + hr = dxgiDevice2->EnqueueSetEvent(event); + if (SUCCEEDED(hr)) { + DebugOnly result = ::WaitForSingleObject(event, INFINITE); + MOZ_ASSERT(result == WAIT_OBJECT_0); + } else { + gfxCriticalNoteOnce << "EnqueueSetEvent failed: " << gfx::hexa(hr); + } + ::CloseHandle(event); + } + + UINT flags = DXGI_PRESENT_USE_DURATION; + UINT interval = 1; + if (StaticPrefs::gfx_webrender_dcomp_video_swap_chain_present_interval_0()) { + interval = 0; + } + + auto start = TimeStamp::Now(); + hr = mVideoSwapChain->Present(interval, flags); + auto end = TimeStamp::Now(); + + if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) { + gfxCriticalNoteOnce << "video Present failed: " << gfx::hexa(hr); + } + + mPrevTexture = mRenderTextureHost; + + // Disable video overlay if mVideoSwapChain->Present() is too slow. It drops + // fps. + + if (!StaticPrefs::gfx_webrender_dcomp_video_check_slow_present()) { + return; + } + + const auto maxPresentWaitDurationMs = 2; + const auto maxSlowPresentCount = 5; + const auto presentDurationMs = + static_cast((end - start).ToMilliseconds()); + const auto overlayType = mRenderTextureHost->IsSoftwareDecodedVideo() + ? DCompOverlayTypes::SOFTWARE_DECODED_VIDEO + : DCompOverlayTypes::HARDWARE_DECODED_VIDEO; + + nsPrintfCString marker("PresentWait overlay %u %ums ", (uint8_t)overlayType, + presentDurationMs); + PROFILER_MARKER_TEXT("PresentWait", GRAPHICS, {}, marker); + + if (presentDurationMs > maxPresentWaitDurationMs) { + mSlowPresentCount++; + } else { + mSlowPresentCount = 0; + } + + if (mSlowPresentCount <= maxSlowPresentCount) { + return; + } + + if (overlayType == DCompOverlayTypes::SOFTWARE_DECODED_VIDEO) { + gfxCriticalNoteOnce << "Sw video swapchain present is slow"; + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_SW_OVERLAY); + } else { + gfxCriticalNoteOnce << "Hw video swapchain present is slow"; + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_HW_OVERLAY); + } +} + +DXGI_FORMAT DCSurfaceVideo::GetSwapChainFormat() { + if (mFailedYuvSwapChain || !mDCLayerTree->SupportsHardwareOverlays()) { + return DXGI_FORMAT_B8G8R8A8_UNORM; + } + return mDCLayerTree->GetOverlayFormatForSDR(); +} + +bool DCSurfaceVideo::CreateVideoSwapChain() { + MOZ_ASSERT(mRenderTextureHost); + + mFirstPresent = true; + + const auto device = mDCLayerTree->GetDevice(); + + RefPtr dxgiDevice; + device->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice)); + + RefPtr dxgiFactoryMedia; + { + RefPtr adapter; + dxgiDevice->GetAdapter(getter_AddRefs(adapter)); + adapter->GetParent( + IID_PPV_ARGS((IDXGIFactoryMedia**)getter_AddRefs(dxgiFactoryMedia))); + } + + mSwapChainSurfaceHandle = gfx::DeviceManagerDx::CreateDCompSurfaceHandle(); + if (!mSwapChainSurfaceHandle) { + gfxCriticalNote << "Failed to create DCompSurfaceHandle"; + return false; + } + + auto swapChainFormat = GetSwapChainFormat(); + + DXGI_SWAP_CHAIN_DESC1 desc = {}; + desc.Width = mSwapChainSize.width; + desc.Height = mSwapChainSize.height; + desc.Format = swapChainFormat; + desc.Stereo = FALSE; + desc.SampleDesc.Count = 1; + desc.BufferCount = mSwapChainBufferCount; + desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + desc.Scaling = DXGI_SCALING_STRETCH; + desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + desc.Flags = DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO; + if (IsYUVSwapChainFormat(swapChainFormat)) { + desc.Flags |= DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO; + } + if (mIsDRM) { + desc.Flags |= DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY; + } + desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE; + + HRESULT hr; + hr = dxgiFactoryMedia->CreateSwapChainForCompositionSurfaceHandle( + device, mSwapChainSurfaceHandle, &desc, nullptr, + getter_AddRefs(mVideoSwapChain)); + + if (FAILED(hr)) { + gfxCriticalNote << "Failed to create video SwapChain: " << gfx::hexa(hr) + << " " << mSwapChainSize; + return false; + } + + mSwapChainFormat = swapChainFormat; + return true; +} + +// TODO: Replace with YUVRangedColorSpace +static Maybe GetSourceDXGIColorSpace( + const gfx::YUVColorSpace aYUVColorSpace, + const gfx::ColorRange aColorRange) { + if (aYUVColorSpace == gfx::YUVColorSpace::BT601) { + if (aColorRange == gfx::ColorRange::FULL) { + return Some(DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601); + } else { + return Some(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601); + } + } else if (aYUVColorSpace == gfx::YUVColorSpace::BT709) { + if (aColorRange == gfx::ColorRange::FULL) { + return Some(DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709); + } else { + return Some(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709); + } + } else if (aYUVColorSpace == gfx::YUVColorSpace::BT2020) { + if (aColorRange == gfx::ColorRange::FULL) { + // XXX Add SMPTEST2084 handling. HDR content is not handled yet by + // video overlay. + return Some(DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020); + } else { + return Some(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020); + } + } + + return Nothing(); +} + +static Maybe GetSourceDXGIColorSpace( + const gfx::YUVRangedColorSpace aYUVColorSpace) { + const auto info = FromYUVRangedColorSpace(aYUVColorSpace); + return GetSourceDXGIColorSpace(info.space, info.range); +} + +static void SetNvidiaVideoSuperRes(ID3D11VideoContext* videoContext, + ID3D11VideoProcessor* videoProcessor, + bool enabled) { + LOG("SetNvidiaVideoSuperRes() enabled=%d", enabled); + + // Undocumented NVIDIA driver constants + constexpr GUID nvGUID = {0xD43CE1B3, + 0x1F4B, + 0x48AC, + {0xBA, 0xEE, 0xC3, 0xC2, 0x53, 0x75, 0xE6, 0xF7}}; + + constexpr UINT nvExtensionVersion = 0x1; + constexpr UINT nvExtensionMethodSuperResolution = 0x2; + struct { + UINT version; + UINT method; + UINT enable; + } streamExtensionInfo = {nvExtensionVersion, nvExtensionMethodSuperResolution, + enabled ? 1u : 0}; + + HRESULT hr; + hr = videoContext->VideoProcessorSetStreamExtension( + videoProcessor, 0, &nvGUID, sizeof(streamExtensionInfo), + &streamExtensionInfo); + + // Ignore errors as could be unsupported + if (FAILED(hr)) { + LOG("SetNvidiaVideoSuperRes() error: %lx", hr); + return; + } +} + +static UINT GetVendorId(ID3D11VideoDevice* const videoDevice) { + RefPtr dxgiDevice; + RefPtr adapter; + videoDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice)); + dxgiDevice->GetAdapter(getter_AddRefs(adapter)); + + DXGI_ADAPTER_DESC adapterDesc; + adapter->GetDesc(&adapterDesc); + + return adapterDesc.VendorId; +} + +bool DCSurfaceVideo::CallVideoProcessorBlt() { + MOZ_ASSERT(mRenderTextureHost); + + HRESULT hr; + const auto videoDevice = mDCLayerTree->GetVideoDevice(); + const auto videoContext = mDCLayerTree->GetVideoContext(); + const auto texture = mRenderTextureHost->AsRenderDXGITextureHost(); + + Maybe sourceColorSpace = + GetSourceDXGIColorSpace(texture->GetYUVColorSpace()); + if (sourceColorSpace.isNothing()) { + gfxCriticalNote << "Unsupported color space"; + return false; + } + + RefPtr texture2D = texture->GetD3D11Texture2DWithGL(); + if (!texture2D) { + gfxCriticalNote << "Failed to get D3D11Texture2D"; + return false; + } + + if (!mVideoSwapChain) { + return false; + } + + auto query = texture->GetQuery(); + if (query) { + // Wait ID3D11Query of D3D11Texture2D copy complete just before blitting for + // video overlay with non Intel GPUs. See Bug 1817617. + BOOL result; + bool ret = layers::WaitForFrameGPUQuery(mDCLayerTree->GetDevice(), + mDCLayerTree->GetDeviceContext(), + query, &result); + if (!ret) { + gfxCriticalNoteOnce << "WaitForFrameGPUQuery() failed"; + } + } + + if (!mDCLayerTree->EnsureVideoProcessor(mVideoSize, mSwapChainSize)) { + gfxCriticalNote << "EnsureVideoProcessor Failed"; + return false; + } + + RefPtr swapChain3; + mVideoSwapChain->QueryInterface( + (IDXGISwapChain3**)getter_AddRefs(swapChain3)); + if (!swapChain3) { + gfxCriticalNote << "Failed to get IDXGISwapChain3"; + return false; + } + + RefPtr videoContext1; + videoContext->QueryInterface( + (ID3D11VideoContext1**)getter_AddRefs(videoContext1)); + if (!videoContext1) { + gfxCriticalNote << "Failed to get ID3D11VideoContext1"; + return false; + } + + const auto videoProcessor = mDCLayerTree->GetVideoProcessor(); + const auto videoProcessorEnumerator = + mDCLayerTree->GetVideoProcessorEnumerator(); + + DXGI_COLOR_SPACE_TYPE inputColorSpace = sourceColorSpace.ref(); + videoContext1->VideoProcessorSetStreamColorSpace1(videoProcessor, 0, + inputColorSpace); + + DXGI_COLOR_SPACE_TYPE outputColorSpace = + IsYUVSwapChainFormat(mSwapChainFormat) + ? inputColorSpace + : DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709; + hr = swapChain3->SetColorSpace1(outputColorSpace); + if (FAILED(hr)) { + gfxCriticalNoteOnce << "SetColorSpace1 failed: " << gfx::hexa(hr); + RenderThread::Get()->NotifyWebRenderError( + wr::WebRenderError::VIDEO_OVERLAY); + return false; + } + videoContext1->VideoProcessorSetOutputColorSpace1(videoProcessor, + outputColorSpace); + + D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC inputDesc = {}; + inputDesc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D; + inputDesc.Texture2D.ArraySlice = texture->ArrayIndex(); + + RefPtr inputView; + hr = videoDevice->CreateVideoProcessorInputView( + texture2D, videoProcessorEnumerator, &inputDesc, + getter_AddRefs(inputView)); + if (FAILED(hr)) { + gfxCriticalNote << "ID3D11VideoProcessorInputView creation failed: " + << gfx::hexa(hr); + return false; + } + + D3D11_VIDEO_PROCESSOR_STREAM stream = {}; + stream.Enable = true; + stream.OutputIndex = 0; + stream.InputFrameOrField = 0; + stream.PastFrames = 0; + stream.FutureFrames = 0; + stream.pInputSurface = inputView.get(); + + RECT destRect; + destRect.left = 0; + destRect.top = 0; + destRect.right = mSwapChainSize.width; + destRect.bottom = mSwapChainSize.height; + + videoContext->VideoProcessorSetOutputTargetRect(videoProcessor, TRUE, + &destRect); + videoContext->VideoProcessorSetStreamDestRect(videoProcessor, 0, TRUE, + &destRect); + RECT sourceRect; + sourceRect.left = 0; + sourceRect.top = 0; + sourceRect.right = mVideoSize.width; + sourceRect.bottom = mVideoSize.height; + videoContext->VideoProcessorSetStreamSourceRect(videoProcessor, 0, TRUE, + &sourceRect); + + if (!mOutputView) { + RefPtr backBuf; + mVideoSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), + (void**)getter_AddRefs(backBuf)); + + D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC outputDesc = {}; + outputDesc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D; + outputDesc.Texture2D.MipSlice = 0; + + hr = videoDevice->CreateVideoProcessorOutputView( + backBuf, videoProcessorEnumerator, &outputDesc, + getter_AddRefs(mOutputView)); + if (FAILED(hr)) { + gfxCriticalNote << "ID3D11VideoProcessorOutputView creation failed: " + << gfx::hexa(hr); + return false; + } + } + + const UINT vendorId = GetVendorId(videoDevice); + if (vendorId == 0x10DE && + StaticPrefs::gfx_webrender_super_resolution_nvidia_AtStartup()) { + SetNvidiaVideoSuperRes(videoContext, videoProcessor, true); + } + + hr = videoContext->VideoProcessorBlt(videoProcessor, mOutputView, 0, 1, + &stream); + if (FAILED(hr)) { + gfxCriticalNote << "VideoProcessorBlt failed: " << gfx::hexa(hr); + return false; + } + + return true; +} + +void DCSurfaceVideo::ReleaseDecodeSwapChainResources() { + mOutputView = nullptr; + mVideoSwapChain = nullptr; + mDecodeSwapChain = nullptr; + mDecodeResource = nullptr; + if (mSwapChainSurfaceHandle) { + ::CloseHandle(mSwapChainSurfaceHandle); + mSwapChainSurfaceHandle = 0; + } +} + +DCSurfaceHandle::DCSurfaceHandle(bool aIsOpaque, DCLayerTree* aDCLayerTree) + : DCSurface(wr::DeviceIntSize{}, wr::DeviceIntPoint{}, false, aIsOpaque, + aDCLayerTree) {} + +void DCSurfaceHandle::AttachExternalImage(wr::ExternalImageId aExternalImage) { + RenderTextureHost* texture = + RenderThread::Get()->GetRenderTexture(aExternalImage); + RenderDcompSurfaceTextureHost* renderTexture = + texture ? texture->AsRenderDcompSurfaceTextureHost() : nullptr; + if (!renderTexture) { + gfxCriticalNote << "Unsupported RenderTexture for DCSurfaceHandle: " + << gfx::hexa(texture); + return; + } + + const auto handle = renderTexture->GetDcompSurfaceHandle(); + if (GetSurfaceHandle() == handle) { + return; + } + + LOG_H("AttachExternalImage, ext-image=%" PRIu64 ", texture=%p, handle=%p", + wr::AsUint64(aExternalImage), renderTexture, handle); + mDcompTextureHost = renderTexture; +} + +HANDLE DCSurfaceHandle::GetSurfaceHandle() const { + if (mDcompTextureHost) { + return mDcompTextureHost->GetDcompSurfaceHandle(); + } + return nullptr; +} + +IDCompositionSurface* DCSurfaceHandle::EnsureSurface() { + if (auto* surface = mDcompTextureHost->GetSurface()) { + return surface; + } + + // Texture host hasn't created the surface yet, ask it to create a new one. + RefPtr device; + HRESULT hr = mDCLayerTree->GetCompositionDevice()->QueryInterface( + (IDCompositionDevice**)getter_AddRefs(device)); + if (FAILED(hr)) { + gfxCriticalNote + << "Failed to convert IDCompositionDevice2 to IDCompositionDevice: " + << gfx::hexa(hr); + return nullptr; + } + + return mDcompTextureHost->CreateSurfaceFromDevice(device); +} + +void DCSurfaceHandle::PresentSurfaceHandle() { + LOG_H("PresentSurfaceHandle"); + if (IDCompositionSurface* surface = EnsureSurface()) { + LOG_H("Set surface %p to visual", surface); + mVisual->SetContent(surface); + } else { + mVisual->SetContent(nullptr); + } +} + +DCTile::DCTile(DCLayerTree* aDCLayerTree) : mDCLayerTree(aDCLayerTree) {} + +DCTile::~DCTile() {} + +bool DCTile::Initialize(int aX, int aY, wr::DeviceIntSize aSize, + bool aIsVirtualSurface, bool aIsOpaque, + RefPtr mSurfaceVisual) { + if (aSize.width <= 0 || aSize.height <= 0) { + return false; + } + + mSize = aSize; + mIsOpaque = aIsOpaque; + mIsVirtualSurface = aIsVirtualSurface; + mNeedsFullDraw = !aIsVirtualSurface; + + if (aIsVirtualSurface) { + // Initially, the entire tile is considered valid, unless it is set by + // the SetTileProperties method. + mValidRect.x = 0; + mValidRect.y = 0; + mValidRect.width = aSize.width; + mValidRect.height = aSize.height; + } else { + HRESULT hr; + const auto dCompDevice = mDCLayerTree->GetCompositionDevice(); + // Create the visual and put it in the tree under the surface visual + hr = dCompDevice->CreateVisual(getter_AddRefs(mVisual)); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to CreateVisual for DCTile: " << gfx::hexa(hr); + return false; + } + mSurfaceVisual->AddVisual(mVisual, false, nullptr); + // Position the tile relative to the surface visual + mVisual->SetOffsetX(aX * aSize.width); + mVisual->SetOffsetY(aY * aSize.height); + // Clip the visual so it doesn't show anything until we update it + D2D_RECT_F clip = {0, 0, 0, 0}; + mVisual->SetClip(clip); + // Create the underlying pixel buffer. + mCompositionSurface = CreateCompositionSurface(aSize, aIsOpaque); + if (!mCompositionSurface) { + return false; + } + hr = mVisual->SetContent(mCompositionSurface); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to SetContent for DCTile: " << gfx::hexa(hr); + return false; + } + } + + return true; +} + +RefPtr DCTile::CreateCompositionSurface( + wr::DeviceIntSize aSize, bool aIsOpaque) { + HRESULT hr; + const auto dCompDevice = mDCLayerTree->GetCompositionDevice(); + const auto alphaMode = + aIsOpaque ? DXGI_ALPHA_MODE_IGNORE : DXGI_ALPHA_MODE_PREMULTIPLIED; + RefPtr compositionSurface; + + hr = dCompDevice->CreateSurface(aSize.width, aSize.height, + DXGI_FORMAT_R8G8B8A8_UNORM, alphaMode, + getter_AddRefs(compositionSurface)); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to CreateSurface for DCTile: " << gfx::hexa(hr); + return nullptr; + } + return compositionSurface; +} + +RefPtr DCTile::Bind(wr::DeviceIntRect aValidRect) { + if (mVisual != nullptr) { + // Tile owns a visual, set the size of the visual to match the portion we + // want to be visible. + D2D_RECT_F clip_rect; + clip_rect.left = aValidRect.min.x; + clip_rect.top = aValidRect.min.y; + clip_rect.right = aValidRect.max.x; + clip_rect.bottom = aValidRect.max.y; + mVisual->SetClip(clip_rect); + } + return mCompositionSurface; +} + +GLuint DCLayerTree::CreateEGLSurfaceForCompositionSurface( + wr::DeviceIntRect aDirtyRect, wr::DeviceIntPoint* aOffset, + RefPtr aCompositionSurface, + wr::DeviceIntPoint aSurfaceOffset) { + MOZ_ASSERT(aCompositionSurface.get()); + + HRESULT hr; + const auto gl = GetGLContext(); + RefPtr backBuf; + POINT offset; + + RECT update_rect; + update_rect.left = aSurfaceOffset.x + aDirtyRect.min.x; + update_rect.top = aSurfaceOffset.y + aDirtyRect.min.y; + update_rect.right = aSurfaceOffset.x + aDirtyRect.max.x; + update_rect.bottom = aSurfaceOffset.y + aDirtyRect.max.y; + hr = aCompositionSurface->BeginDraw(&update_rect, __uuidof(ID3D11Texture2D), + (void**)getter_AddRefs(backBuf), &offset); + + if (FAILED(hr)) { + LayoutDeviceIntRect rect = widget::WinUtils::ToIntRect(update_rect); + + gfxCriticalNote << "DCompositionSurface::BeginDraw failed: " + << gfx::hexa(hr) << " " << rect; + RenderThread::Get()->HandleWebRenderError(WebRenderError::BEGIN_DRAW); + return false; + } + + // DC includes the origin of the dirty / update rect in the draw offset, + // undo that here since WR expects it to be an absolute offset. + offset.x -= aDirtyRect.min.x; + offset.y -= aDirtyRect.min.y; + + D3D11_TEXTURE2D_DESC desc; + backBuf->GetDesc(&desc); + + const auto& gle = gl::GLContextEGL::Cast(gl); + const auto& egl = gle->mEgl; + + const auto buffer = reinterpret_cast(backBuf.get()); + + // Construct an EGLImage wrapper around the D3D texture for ANGLE. + const EGLint attribs[] = {LOCAL_EGL_NONE}; + mEGLImage = egl->fCreateImage(EGL_NO_CONTEXT, LOCAL_EGL_D3D11_TEXTURE_ANGLE, + buffer, attribs); + + // Get the current FBO and RBO id, so we can restore them later + GLint currentFboId, currentRboId; + gl->fGetIntegerv(LOCAL_GL_DRAW_FRAMEBUFFER_BINDING, ¤tFboId); + gl->fGetIntegerv(LOCAL_GL_RENDERBUFFER_BINDING, ¤tRboId); + + // Create a render buffer object that is backed by the EGL image. + gl->fGenRenderbuffers(1, &mColorRBO); + gl->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, mColorRBO); + gl->fEGLImageTargetRenderbufferStorage(LOCAL_GL_RENDERBUFFER, mEGLImage); + + // Get or create an FBO for the specified dimensions + GLuint fboId = GetOrCreateFbo(desc.Width, desc.Height); + + // Attach the new renderbuffer to the FBO + gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fboId); + gl->fFramebufferRenderbuffer(LOCAL_GL_DRAW_FRAMEBUFFER, + LOCAL_GL_COLOR_ATTACHMENT0, + LOCAL_GL_RENDERBUFFER, mColorRBO); + + // Restore previous FBO and RBO bindings + gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, currentFboId); + gl->fBindRenderbuffer(LOCAL_GL_RENDERBUFFER, currentRboId); + + aOffset->x = offset.x; + aOffset->y = offset.y; + + return fboId; +} + +void DCLayerTree::DestroyEGLSurface() { + const auto gl = GetGLContext(); + + if (mColorRBO) { + gl->fDeleteRenderbuffers(1, &mColorRBO); + mColorRBO = 0; + } + + if (mEGLImage) { + const auto& gle = gl::GLContextEGL::Cast(gl); + const auto& egl = gle->mEgl; + egl->fDestroyImage(mEGLImage); + mEGLImage = EGL_NO_IMAGE; + } +} + +// - + +color::ColorProfileDesc DCLayerTree::QueryOutputColorProfile() { + // GPU process can't simply init gfxPlatform, (and we don't need most of it) + // but we do need gfxPlatform::GetCMSOutputProfile(). + // So we steal what we need through the window: + const auto outputProfileData = + gfxWindowsPlatform::GetPlatformCMSOutputProfileData_Impl(); + + const auto qcmsProfile = qcms_profile_from_memory( + outputProfileData.Elements(), outputProfileData.Length()); + const auto release = MakeScopeExit([&]() { + if (qcmsProfile) { + qcms_profile_release(qcmsProfile); + } + }); + + const bool print = gfxEnv::MOZ_GL_SPEW(); + + const auto ret = [&]() { + if (qcmsProfile) { + return color::ColorProfileDesc::From(*qcmsProfile); + } + if (print) { + printf_stderr( + "Missing or failed to load display color profile, defaulting to " + "sRGB.\n"); + } + const auto MISSING_PROFILE_DEFAULT_SPACE = color::ColorspaceDesc{ + color::Chromaticities::Srgb(), + color::PiecewiseGammaDesc::Srgb(), + }; + return color::ColorProfileDesc::From(MISSING_PROFILE_DEFAULT_SPACE); + }(); + + if (print) { + const auto gammaGuess = color::GuessGamma(ret.linearFromTf.r); + printf_stderr( + "Display profile:\n" + " Approx Gamma: %f\n" + " XYZ-D65 Red : %f, %f, %f\n" + " XYZ-D65 Green: %f, %f, %f\n" + " XYZ-D65 Blue : %f, %f, %f\n", + gammaGuess, ret.xyzd65FromLinearRgb.at(0, 0), + ret.xyzd65FromLinearRgb.at(0, 1), ret.xyzd65FromLinearRgb.at(0, 2), + + ret.xyzd65FromLinearRgb.at(1, 0), ret.xyzd65FromLinearRgb.at(1, 1), + ret.xyzd65FromLinearRgb.at(1, 2), + + ret.xyzd65FromLinearRgb.at(2, 0), ret.xyzd65FromLinearRgb.at(2, 1), + ret.xyzd65FromLinearRgb.at(2, 2)); + } + + return ret; +} + +inline D2D1_MATRIX_5X4_F to_D2D1_MATRIX_5X4_F(const color::mat4& m) { + return D2D1_MATRIX_5X4_F{{{ + m.rows[0][0], + m.rows[1][0], + m.rows[2][0], + m.rows[3][0], + m.rows[0][1], + m.rows[1][1], + m.rows[2][1], + m.rows[3][1], + m.rows[0][2], + m.rows[1][2], + m.rows[2][2], + m.rows[3][2], + m.rows[0][3], + m.rows[1][3], + m.rows[2][3], + m.rows[3][3], + 0, + 0, + 0, + 0, + }}}; +} + +ColorManagementChain ColorManagementChain::From( + IDCompositionDevice3& dcomp, + const color::ColorProfileConversionDesc& conv) { + auto ret = ColorManagementChain{}; + +#if !defined(MOZ_MINGW_DCOMP_H_INCOMPLETE) + + const auto Append = [&](const RefPtr& afterLast) { + if (ret.last) { + afterLast->SetInput(0, ret.last, 0); + } + ret.last = afterLast; + }; + + const auto MaybeAppendColorMatrix = [&](const color::mat4& m) { + RefPtr e; + if (approx(m, color::mat4::Identity())) return e; + dcomp.CreateColorMatrixEffect(getter_AddRefs(e)); + MOZ_ASSERT(e); + if (!e) return e; + e->SetMatrix(to_D2D1_MATRIX_5X4_F(m)); + Append(e); + return e; + }; + const auto MaybeAppendTableTransfer = [&](const color::RgbTransferTables& t) { + RefPtr e; + if (!t.r.size() && !t.g.size() && !t.b.size()) return e; + dcomp.CreateTableTransferEffect(getter_AddRefs(e)); + MOZ_ASSERT(e); + if (!e) return e; + e->SetRedTable(t.r.data(), t.r.size()); + e->SetGreenTable(t.g.data(), t.g.size()); + e->SetBlueTable(t.b.data(), t.b.size()); + Append(e); + return e; + }; + + ret.srcRgbFromSrcYuv = MaybeAppendColorMatrix(conv.srcRgbFromSrcYuv); + ret.srcLinearFromSrcTf = MaybeAppendTableTransfer(conv.srcLinearFromSrcTf); + ret.dstLinearFromSrcLinear = + MaybeAppendColorMatrix(color::mat4(conv.dstLinearFromSrcLinear)); + ret.dstTfFromDstLinear = MaybeAppendTableTransfer(conv.dstTfFromDstLinear); + +#endif // !defined(MOZ_MINGW_DCOMP_H_INCOMPLETE) + + return ret; +} + +ColorManagementChain::~ColorManagementChain() = default; + +} // namespace wr +} // namespace mozilla + +#undef LOG_H diff --git a/gfx/webrender_bindings/DCLayerTree.h b/gfx/webrender_bindings/DCLayerTree.h new file mode 100644 index 0000000000..babd1112fb --- /dev/null +++ b/gfx/webrender_bindings/DCLayerTree.h @@ -0,0 +1,480 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_DCLAYER_TREE_H +#define MOZILLA_GFX_DCLAYER_TREE_H + +#include +#include +#include +#include + +#include "Colorspaces.h" +#include "GLTypes.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/layers/OverlayInfo.h" +#include "mozilla/Maybe.h" +#include "mozilla/RefPtr.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/webrender/WebRenderTypes.h" + +struct ID3D11Device; +struct ID3D11DeviceContext; +struct ID3D11VideoDevice; +struct ID3D11VideoContext; +struct ID3D11VideoProcessor; +struct ID3D11VideoProcessorEnumerator; +struct ID3D11VideoProcessorOutputView; +struct IDCompositionColorMatrixEffect; +struct IDCompositionFilterEffect; +struct IDCompositionTableTransferEffect; +struct IDCompositionDevice2; +struct IDCompositionDevice3; +struct IDCompositionSurface; +struct IDCompositionTarget; +struct IDCompositionVisual2; +struct IDXGIDecodeSwapChain; +struct IDXGIResource; +struct IDXGISwapChain1; +struct IDCompositionVirtualSurface; + +namespace mozilla { + +namespace gl { +class GLContext; +} + +namespace wr { + +// The size of the virtual surface. This is large enough such that we +// will never render a surface larger than this. +#define VIRTUAL_SURFACE_SIZE (1024 * 1024) + +class DCTile; +class DCSurface; +class DCSurfaceVideo; +class DCSurfaceHandle; +class RenderTextureHost; +class RenderDcompSurfaceTextureHost; + +struct GpuOverlayInfo { + bool mSupportsOverlays = false; + bool mSupportsHardwareOverlays = false; + DXGI_FORMAT mOverlayFormatUsed = DXGI_FORMAT_B8G8R8A8_UNORM; + DXGI_FORMAT mOverlayFormatUsedHdr = DXGI_FORMAT_R10G10B10A2_UNORM; + UINT mNv12OverlaySupportFlags = 0; + UINT mYuy2OverlaySupportFlags = 0; + UINT mBgra8OverlaySupportFlags = 0; + UINT mRgb10a2OverlaySupportFlags = 0; +}; + +// - + +struct ColorManagementChain { + RefPtr srcRgbFromSrcYuv; + RefPtr srcLinearFromSrcTf; + RefPtr dstLinearFromSrcLinear; + RefPtr dstTfFromDstLinear; + RefPtr last; + + static ColorManagementChain From(IDCompositionDevice3& dcomp, + const color::ColorProfileConversionDesc&); + + ~ColorManagementChain(); +}; + +// - + +enum class DCompOverlayTypes : uint8_t { + NO_OVERLAY = 0, + HARDWARE_DECODED_VIDEO = 1 << 0, + SOFTWARE_DECODED_VIDEO = 1 << 1, +}; +MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(DCompOverlayTypes) + +// - + +/** + * DCLayerTree manages direct composition layers. + * It does not manage gecko's layers::Layer. + */ +class DCLayerTree { + public: + static UniquePtr Create(gl::GLContext* aGL, EGLConfig aEGLConfig, + ID3D11Device* aDevice, + ID3D11DeviceContext* aCtx, HWND aHwnd, + nsACString& aError); + + static void Shutdown(); + + explicit DCLayerTree(gl::GLContext* aGL, EGLConfig aEGLConfig, + ID3D11Device* aDevice, ID3D11DeviceContext* aCtx, + IDCompositionDevice2* aCompositionDevice); + ~DCLayerTree(); + + void SetDefaultSwapChain(IDXGISwapChain1* aSwapChain); + void MaybeUpdateDebug(); + void MaybeCommit(); + void WaitForCommitCompletion(); + void DisableNativeCompositor(); + + // Interface for wr::Compositor + void CompositorBeginFrame(); + void CompositorEndFrame(); + void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect); + void Unbind(); + void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque); + void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque); + void DestroySurface(NativeSurfaceId aId); + void CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY); + void DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY); + void AttachExternalImage(wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage); + void AddSurface(wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering); + + gl::GLContext* GetGLContext() const { return mGL; } + EGLConfig GetEGLConfig() const { return mEGLConfig; } + ID3D11Device* GetDevice() const { return mDevice; } + ID3D11DeviceContext* GetDeviceContext() const { return mCtx; } + IDCompositionDevice2* GetCompositionDevice() const { + return mCompositionDevice; + } + ID3D11VideoDevice* GetVideoDevice() const { return mVideoDevice; } + ID3D11VideoContext* GetVideoContext() const { return mVideoContext; } + ID3D11VideoProcessor* GetVideoProcessor() const { return mVideoProcessor; } + ID3D11VideoProcessorEnumerator* GetVideoProcessorEnumerator() const { + return mVideoProcessorEnumerator; + } + bool EnsureVideoProcessor(const gfx::IntSize& aInputSize, + const gfx::IntSize& aOutputSize); + + DCSurface* GetSurface(wr::NativeSurfaceId aId) const; + + // Get or create an FBO with depth buffer suitable for specified dimensions + GLuint GetOrCreateFbo(int aWidth, int aHeight); + + bool SupportsHardwareOverlays(); + DXGI_FORMAT GetOverlayFormatForSDR(); + + bool SupportsSwapChainTearing(); + + void SetUsedOverlayTypeInFrame(DCompOverlayTypes aTypes); + + protected: + bool Initialize(HWND aHwnd, nsACString& aError); + bool InitializeVideoOverlaySupport(); + bool MaybeUpdateDebugCounter(); + bool MaybeUpdateDebugVisualRedrawRegions(); + void DestroyEGLSurface(); + GLuint CreateEGLSurfaceForCompositionSurface( + wr::DeviceIntRect aDirtyRect, wr::DeviceIntPoint* aOffset, + RefPtr aCompositionSurface, + wr::DeviceIntPoint aSurfaceOffset); + void ReleaseNativeCompositorResources(); + layers::OverlayInfo GetOverlayInfo(); + + RefPtr mGL; + EGLConfig mEGLConfig; + + RefPtr mDevice; + RefPtr mCtx; + + RefPtr mCompositionDevice; + RefPtr mCompositionTarget; + RefPtr mRootVisual; + RefPtr mDefaultSwapChainVisual; + + RefPtr mVideoDevice; + RefPtr mVideoContext; + RefPtr mVideoProcessor; + RefPtr mVideoProcessorEnumerator; + gfx::IntSize mVideoInputSize; + gfx::IntSize mVideoOutputSize; + + bool mDebugCounter; + bool mDebugVisualRedrawRegions; + + Maybe> mCurrentSurface; + + // The EGL image that is bound to the D3D texture provided by + // DirectComposition. + EGLImage mEGLImage; + + // The GL render buffer ID that maps the EGLImage to an RBO for attaching to + // an FBO. + GLuint mColorRBO; + + struct SurfaceIdHashFn { + std::size_t operator()(const wr::NativeSurfaceId& aId) const { + return HashGeneric(wr::AsUint64(aId)); + } + }; + + std::unordered_map, SurfaceIdHashFn> + mDCSurfaces; + + // A list of layer IDs as they are added to the visual tree this frame. + std::vector mCurrentLayers; + + // The previous frame's list of layer IDs in visual order. + std::vector mPrevLayers; + + // Information about a cached FBO that is retained between frames. + struct CachedFrameBuffer { + int width; + int height; + GLuint fboId; + GLuint depthRboId; + int lastFrameUsed; + }; + + // A cache of FBOs, containing a depth buffer allocated to a specific size. + // TODO(gw): Might be faster as a hashmap? The length is typically much less + // than 10. + nsTArray mFrameBuffers; + int mCurrentFrame = 0; + + bool mPendingCommit; + + static color::ColorProfileDesc QueryOutputColorProfile(); + + mutable Maybe mOutputColorProfile; + + DCompOverlayTypes mUsedOverlayTypesInFrame = DCompOverlayTypes::NO_OVERLAY; + int mSlowCommitCount = 0; + + public: + const color::ColorProfileDesc& OutputColorProfile() const { + if (!mOutputColorProfile) { + mOutputColorProfile = Some(QueryOutputColorProfile()); + } + return *mOutputColorProfile; + } + + protected: + static StaticAutoPtr sGpuOverlayInfo; +}; + +/** + Represents a single picture cache slice. Each surface contains some + number of tiles. An implementation may choose to allocate individual + tiles to render in to (as the current impl does), or allocate a large + single virtual surface to draw into (e.g. the DirectComposition virtual + surface API in future). + */ +class DCSurface { + public: + const bool mIsVirtualSurface; + + explicit DCSurface(wr::DeviceIntSize aTileSize, + wr::DeviceIntPoint aVirtualOffset, bool aIsVirtualSurface, + bool aIsOpaque, DCLayerTree* aDCLayerTree); + virtual ~DCSurface(); + + bool Initialize(); + void CreateTile(int32_t aX, int32_t aY); + void DestroyTile(int32_t aX, int32_t aY); + + IDCompositionVisual2* GetVisual() const { return mVisual; } + DCTile* GetTile(int32_t aX, int32_t aY) const; + + struct TileKey { + TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {} + + int32_t mX; + int32_t mY; + }; + + wr::DeviceIntSize GetTileSize() const { return mTileSize; } + wr::DeviceIntPoint GetVirtualOffset() const { return mVirtualOffset; } + + IDCompositionVirtualSurface* GetCompositionSurface() const { + return mVirtualSurface; + } + + void UpdateAllocatedRect(); + void DirtyAllocatedRect(); + + // Implement these if the inherited surface supports attaching external image. + virtual void AttachExternalImage(wr::ExternalImageId aExternalImage) { + MOZ_RELEASE_ASSERT(true, "Not support attaching external image"); + } + virtual void PresentExternalSurface(gfx::Matrix& aTransform) { + MOZ_RELEASE_ASSERT(true, "Not support presenting external surface"); + } + + virtual DCSurfaceVideo* AsDCSurfaceVideo() { return nullptr; } + virtual DCSurfaceHandle* AsDCSurfaceHandle() { return nullptr; } + + protected: + DCLayerTree* mDCLayerTree; + + struct TileKeyHashFn { + std::size_t operator()(const TileKey& aId) const { + return HashGeneric(aId.mX, aId.mY); + } + }; + + // The visual for this surface. No content is attached to here, but tiles + // that belong to this surface are added as children. In this way, we can + // set the clip and scroll offset once, on this visual, to affect all + // children. + // + // However when using a virtual surface, it is directly attached to this + // visual and the tiles do not own visuals. + // + // Whether mIsVirtualSurface is enabled is decided at DCSurface creation + // time based on the pref gfx.webrender.dcomp-use-virtual-surfaces + RefPtr mVisual; + + wr::DeviceIntSize mTileSize; + bool mIsOpaque; + bool mAllocatedRectDirty; + std::unordered_map, TileKeyHashFn> mDCTiles; + wr::DeviceIntPoint mVirtualOffset; + RefPtr mVirtualSurface; +}; + +/** + * A wrapper surface which can contain either a DCVideo or a DCSurfaceHandle. + */ +class DCExternalSurfaceWrapper : public DCSurface { + public: + DCExternalSurfaceWrapper(bool aIsOpaque, DCLayerTree* aDCLayerTree) + : DCSurface(wr::DeviceIntSize{}, wr::DeviceIntPoint{}, + false /* virtual surface */, false /* opaque */, + aDCLayerTree), + mIsOpaque(aIsOpaque) {} + ~DCExternalSurfaceWrapper() = default; + + void AttachExternalImage(wr::ExternalImageId aExternalImage) override; + + void PresentExternalSurface(gfx::Matrix& aTransform) override; + + DCSurfaceVideo* AsDCSurfaceVideo() override { + return mSurface ? mSurface->AsDCSurfaceVideo() : nullptr; + } + + DCSurfaceHandle* AsDCSurfaceHandle() override { + return mSurface ? mSurface->AsDCSurfaceHandle() : nullptr; + } + + private: + DCSurface* EnsureSurfaceForExternalImage(wr::ExternalImageId aExternalImage); + + UniquePtr mSurface; + const bool mIsOpaque; + Maybe mCManageChain; +}; + +class DCSurfaceVideo : public DCSurface { + public: + DCSurfaceVideo(bool aIsOpaque, DCLayerTree* aDCLayerTree); + + void AttachExternalImage(wr::ExternalImageId aExternalImage) override; + bool CalculateSwapChainSize(gfx::Matrix& aTransform); + void PresentVideo(); + + DCSurfaceVideo* AsDCSurfaceVideo() override { return this; } + + protected: + virtual ~DCSurfaceVideo(); + + DXGI_FORMAT GetSwapChainFormat(); + bool CreateVideoSwapChain(); + bool CallVideoProcessorBlt(); + void ReleaseDecodeSwapChainResources(); + + RefPtr mOutputView; + RefPtr mDecodeResource; + RefPtr mVideoSwapChain; + RefPtr mDecodeSwapChain; + HANDLE mSwapChainSurfaceHandle = 0; + gfx::IntSize mVideoSize; + gfx::IntSize mSwapChainSize; + DXGI_FORMAT mSwapChainFormat = DXGI_FORMAT_B8G8R8A8_UNORM; + bool mIsDRM = false; + bool mFailedYuvSwapChain = false; + RefPtr mRenderTextureHost; + RefPtr mPrevTexture; + int mSlowPresentCount = 0; + bool mFirstPresent = true; + const UINT mSwapChainBufferCount; +}; + +/** + * A DC surface contains a IDCompositionSurface that is directly constructed by + * a handle. This is used by the Media Foundataion media engine, which would + * store the decoded video content in the surface. + */ +class DCSurfaceHandle : public DCSurface { + public: + DCSurfaceHandle(bool aIsOpaque, DCLayerTree* aDCLayerTree); + ~DCSurfaceHandle() = default; + + void AttachExternalImage(wr::ExternalImageId aExternalImage) override; + void PresentSurfaceHandle(); + + DCSurfaceHandle* AsDCSurfaceHandle() override { return this; } + + protected: + HANDLE GetSurfaceHandle() const; + IDCompositionSurface* EnsureSurface(); + + RefPtr mDcompTextureHost; +}; + +class DCTile { + public: + gfx::IntRect mValidRect; + + DCLayerTree* mDCLayerTree; + // Indicates that when the first BeginDraw occurs on the surface it must be + // full size - required by dcomp on non-virtual surfaces. + bool mNeedsFullDraw; + + explicit DCTile(DCLayerTree* aDCLayerTree); + ~DCTile(); + bool Initialize(int aX, int aY, wr::DeviceIntSize aSize, + bool aIsVirtualSurface, bool aIsOpaque, + RefPtr mSurfaceVisual); + RefPtr Bind(wr::DeviceIntRect aValidRect); + IDCompositionVisual2* GetVisual() { return mVisual; } + + protected: + // Size in pixels of this tile, some may be unused. Set by Initialize. + wr::DeviceIntSize mSize; + // Whether the tile is composited as opaque (ignores alpha) or transparent. + // Set by Initialize. + bool mIsOpaque; + // Some code paths differ based on whether parent surface is virtual. + bool mIsVirtualSurface; + // Visual that displays the composition surface, or NULL if the tile belongs + // to a virtual surface. + RefPtr mVisual; + // Surface for the visual, or NULL if the tile has not had its first Bind or + // belongs to a virtual surface. + RefPtr mCompositionSurface; + + RefPtr CreateCompositionSurface(wr::DeviceIntSize aSize, + bool aIsOpaque); +}; + +static inline bool operator==(const DCSurface::TileKey& a0, + const DCSurface::TileKey& a1) { + return a0.mX == a1.mX && a0.mY == a1.mY; +} + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/Moz2DImageRenderer.cpp b/gfx/webrender_bindings/Moz2DImageRenderer.cpp new file mode 100644 index 0000000000..66f61d719e --- /dev/null +++ b/gfx/webrender_bindings/Moz2DImageRenderer.cpp @@ -0,0 +1,481 @@ +/* -*- 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 "mozilla/StaticPrefs_gfx.h" +#include "gfxUtils.h" +#include "mozilla/Mutex.h" +#include "mozilla/Range.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/RectAbsolute.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/RecordedEvent.h" +#include "mozilla/layers/WebRenderDrawEventRecorder.h" +#include "WebRenderTypes.h" +#include "webrender_ffi.h" +#include "GeckoProfiler.h" + +#include + +#ifdef XP_DARWIN +# include "mozilla/gfx/UnscaledFontMac.h" +#elif defined(XP_WIN) +# include "mozilla/gfx/UnscaledFontDWrite.h" +#else +# include "mozilla/gfx/UnscaledFontFreeType.h" +#endif + +namespace std { +template <> +struct hash { + size_t operator()(const mozilla::wr::FontKey& key) const { + return hash()(mozilla::wr::AsUint64(key)); + } +}; + +template <> +struct hash { + size_t operator()(const mozilla::wr::FontInstanceKey& key) const { + return hash()(mozilla::wr::AsUint64(key)); + } +}; +}; // namespace std + +namespace mozilla { + +using namespace gfx; + +namespace wr { + +struct FontTemplate { + const uint8_t* mData; + size_t mSize; + uint32_t mIndex; + const VecU8* mVec; + RefPtr mUnscaledFont; + + FontTemplate() : mData(nullptr), mSize(0), mIndex(0), mVec(nullptr) {} + + ~FontTemplate() { + if (mVec) { + wr_dec_ref_arc(mVec); + } + } +}; + +struct FontInstanceData { + WrFontKey mFontKey; + float mSize; + Maybe mOptions; + Maybe mPlatformOptions; + UniquePtr mVariations; + size_t mNumVariations; + RefPtr mScaledFont; + + FontInstanceData() : mSize(0), mNumVariations(0) {} +}; + +StaticMutex sFontDataTableLock; +std::unordered_map sFontDataTable; +std::unordered_map sBlobFontTable; + +// Fixed-size ring buffer logging font deletion events to aid debugging. +static struct FontDeleteLog { + static const size_t MAX_ENTRIES = 256; + + uint64_t mEntries[MAX_ENTRIES] = {0}; + size_t mNextEntry = 0; + + void AddEntry(uint64_t aEntry) { + mEntries[mNextEntry] = aEntry; + mNextEntry = (mNextEntry + 1) % MAX_ENTRIES; + } + + void Add(WrFontKey aKey) { AddEntry(AsUint64(aKey)); } + + // Store namespace clears as font id 0, since this will never be allocated. + void Add(WrIdNamespace aNamespace) { + AddEntry(AsUint64(WrFontKey{aNamespace, 0})); + } + + void AddAll() { AddEntry(~0); } + + // Find a matching entry in the log, searching backwards starting at the + // newest entry and finishing with the oldest entry. Returns a brief + // description of why the font was deleted, if known. + const char* Find(WrFontKey aKey) { + uint64_t keyEntry = AsUint64(aKey); + uint64_t namespaceEntry = AsUint64(WrFontKey{aKey.mNamespace, 0}); + size_t offset = mNextEntry; + do { + offset = (offset + MAX_ENTRIES - 1) % MAX_ENTRIES; + if (mEntries[offset] == keyEntry) { + return "deleted font"; + } else if (mEntries[offset] == namespaceEntry) { + return "cleared namespace"; + } else if (mEntries[offset] == (uint64_t)~0) { + return "cleared all"; + } + } while (offset != mNextEntry); + return "unknown font"; + } +} sFontDeleteLog; + +void ClearAllBlobImageResources() { + StaticMutexAutoLock lock(sFontDataTableLock); + sFontDeleteLog.AddAll(); + sBlobFontTable.clear(); + sFontDataTable.clear(); +} + +extern "C" { +void ClearBlobImageResources(WrIdNamespace aNamespace) { + StaticMutexAutoLock lock(sFontDataTableLock); + sFontDeleteLog.Add(aNamespace); + for (auto i = sBlobFontTable.begin(); i != sBlobFontTable.end();) { + if (i->first.mNamespace == aNamespace) { + i = sBlobFontTable.erase(i); + } else { + i++; + } + } + for (auto i = sFontDataTable.begin(); i != sFontDataTable.end();) { + if (i->first.mNamespace == aNamespace) { + i = sFontDataTable.erase(i); + } else { + i++; + } + } +} + +bool HasFontData(WrFontKey aKey) { + StaticMutexAutoLock lock(sFontDataTableLock); + return sFontDataTable.find(aKey) != sFontDataTable.end(); +} + +void AddFontData(WrFontKey aKey, const uint8_t* aData, size_t aSize, + uint32_t aIndex, const ArcVecU8* aVec) { + StaticMutexAutoLock lock(sFontDataTableLock); + auto i = sFontDataTable.find(aKey); + if (i == sFontDataTable.end()) { + FontTemplate& font = sFontDataTable[aKey]; + font.mData = aData; + font.mSize = aSize; + font.mIndex = aIndex; + font.mVec = wr_add_ref_arc(aVec); + } +} + +void AddNativeFontHandle(WrFontKey aKey, void* aHandle, uint32_t aIndex) { + StaticMutexAutoLock lock(sFontDataTableLock); + auto i = sFontDataTable.find(aKey); + if (i == sFontDataTable.end()) { + FontTemplate& font = sFontDataTable[aKey]; +#ifdef XP_DARWIN + font.mUnscaledFont = + new UnscaledFontMac(reinterpret_cast(aHandle), false); +#elif defined(XP_WIN) + font.mUnscaledFont = new UnscaledFontDWrite( + reinterpret_cast(aHandle), nullptr); +#elif defined(ANDROID) + font.mUnscaledFont = new UnscaledFontFreeType( + reinterpret_cast(aHandle), aIndex); +#else + font.mUnscaledFont = new UnscaledFontFontconfig( + reinterpret_cast(aHandle), aIndex); +#endif + } +} + +void DeleteFontData(WrFontKey aKey) { + StaticMutexAutoLock lock(sFontDataTableLock); + sFontDeleteLog.Add(aKey); + auto i = sFontDataTable.find(aKey); + if (i != sFontDataTable.end()) { + sFontDataTable.erase(i); + } +} + +void AddBlobFont(WrFontInstanceKey aInstanceKey, WrFontKey aFontKey, + float aSize, const FontInstanceOptions* aOptions, + const FontInstancePlatformOptions* aPlatformOptions, + const FontVariation* aVariations, size_t aNumVariations) { + StaticMutexAutoLock lock(sFontDataTableLock); + auto i = sBlobFontTable.find(aInstanceKey); + if (i == sBlobFontTable.end()) { + FontInstanceData& font = sBlobFontTable[aInstanceKey]; + font.mFontKey = aFontKey; + font.mSize = aSize; + if (aOptions) { + font.mOptions = Some(*aOptions); + } + if (aPlatformOptions) { + font.mPlatformOptions = Some(*aPlatformOptions); + } + if (aNumVariations) { + font.mNumVariations = aNumVariations; + font.mVariations.reset(new gfx::FontVariation[aNumVariations]); + PodCopy(font.mVariations.get(), + reinterpret_cast(aVariations), + aNumVariations); + } + } +} + +void DeleteBlobFont(WrFontInstanceKey aKey) { + StaticMutexAutoLock lock(sFontDataTableLock); + auto i = sBlobFontTable.find(aKey); + if (i != sBlobFontTable.end()) { + sBlobFontTable.erase(i); + } +} + +} // extern + +static RefPtr GetUnscaledFont(Translator* aTranslator, + WrFontKey aKey) { + auto i = sFontDataTable.find(aKey); + if (i == sFontDataTable.end()) { + gfxDevCrash(LogReason::UnscaledFontNotFound) + << "Failed to get UnscaledFont entry for FontKey " << aKey.mHandle + << " because " << sFontDeleteLog.Find(aKey); + return nullptr; + } + FontTemplate& data = i->second; + if (data.mUnscaledFont) { + return data.mUnscaledFont; + } + MOZ_ASSERT(data.mData); + FontType type = +#ifdef XP_DARWIN + FontType::MAC; +#elif defined(XP_WIN) + FontType::DWRITE; +#elif defined(ANDROID) + FontType::FREETYPE; +#else + FontType::FONTCONFIG; +#endif + // makes a copy of the data + RefPtr fontResource = Factory::CreateNativeFontResource( + (uint8_t*)data.mData, data.mSize, type, aTranslator->GetFontContext()); + RefPtr unscaledFont; + if (!fontResource) { + gfxDevCrash(LogReason::NativeFontResourceNotFound) + << "Failed to create NativeFontResource for FontKey " << aKey.mHandle; + } else { + // Instance data is only needed for GDI fonts which webrender does not + // support. + unscaledFont = fontResource->CreateUnscaledFont(data.mIndex, nullptr, 0); + if (!unscaledFont) { + gfxDevCrash(LogReason::UnscaledFontNotFound) + << "Failed to create UnscaledFont for FontKey " << aKey.mHandle; + } + } + data.mUnscaledFont = unscaledFont; + return unscaledFont; +} + +static RefPtr GetScaledFont(Translator* aTranslator, + WrFontInstanceKey aKey) { + StaticMutexAutoLock lock(sFontDataTableLock); + auto i = sBlobFontTable.find(aKey); + if (i == sBlobFontTable.end()) { + gfxDevCrash(LogReason::ScaledFontNotFound) + << "Failed to get ScaledFont entry for FontInstanceKey " + << aKey.mHandle; + return nullptr; + } + FontInstanceData& data = i->second; + if (data.mScaledFont) { + return data.mScaledFont; + } + RefPtr unscaled = GetUnscaledFont(aTranslator, data.mFontKey); + if (!unscaled) { + return nullptr; + } + RefPtr scaled = unscaled->CreateScaledFontFromWRFont( + data.mSize, data.mOptions.ptrOr(nullptr), + data.mPlatformOptions.ptrOr(nullptr), data.mVariations.get(), + data.mNumVariations); + if (!scaled) { + gfxDevCrash(LogReason::ScaledFontNotFound) + << "Failed to create ScaledFont for FontKey " << aKey.mHandle; + } + data.mScaledFont = scaled; + return data.mScaledFont; +} + +template +T ConvertFromBytes(const uint8_t* bytes) { + T t; + memcpy(&t, bytes, sizeof(T)); + return t; +} + +struct Reader { + const uint8_t* buf; + size_t len; + size_t pos; + + Reader(const uint8_t* buf, size_t len) : buf(buf), len(len), pos(0) {} + + template + T Read() { + MOZ_RELEASE_ASSERT(pos + sizeof(T) <= len); + T ret = ConvertFromBytes(buf + pos); + pos += sizeof(T); + return ret; + } + + size_t ReadSize() { return Read(); } + int ReadInt() { return Read(); } + + IntRectAbsolute ReadBounds() { return Read(); } + + layers::BlobFont ReadBlobFont() { return Read(); } +}; + +static bool Moz2DRenderCallback(const Range aBlob, + gfx::SurfaceFormat aFormat, + const mozilla::wr::DeviceIntRect* aVisibleRect, + const mozilla::wr::LayoutIntRect* aRenderRect, + const uint16_t aTileSize, + const mozilla::wr::TileOffset* aTileOffset, + const mozilla::wr::LayoutIntRect* aDirtyRect, + Range aOutput) { + IntSize size(aRenderRect->width(), aRenderRect->height()); + AUTO_PROFILER_TRACING_MARKER("WebRender", "RasterizeSingleBlob", GRAPHICS); + MOZ_RELEASE_ASSERT(size.width > 0 && size.height > 0); + if (size.width <= 0 || size.height <= 0) { + return false; + } + + auto stride = size.width * gfx::BytesPerPixel(aFormat); + + if (aOutput.length() < static_cast(size.height * stride)) { + return false; + } + + // In bindings.rs we allocate a buffer filled with opaque white. + bool uninitialized = false; + + RefPtr dt = gfx::Factory::CreateDrawTargetForData( + gfx::BackendType::SKIA, aOutput.begin().get(), size, stride, aFormat, + uninitialized); + + if (!dt) { + return false; + } + + // aRenderRect is the part of the blob that we are currently rendering + // (for example a tile) in the same coordinate space as aVisibleRect. + IntPoint origin = gfx::IntPoint(aRenderRect->min.x, aRenderRect->min.y); + + dt = gfx::Factory::CreateOffsetDrawTarget(dt, origin); + if (!dt) { + return false; + } + + // We try hard to not have empty blobs but we can end up with + // them because of CompositorHitTestInfo and merging. + size_t footerSize = sizeof(size_t); + MOZ_RELEASE_ASSERT(aBlob.length() >= footerSize); + size_t indexOffset = ConvertFromBytes(aBlob.end().get() - footerSize); + + MOZ_RELEASE_ASSERT(indexOffset <= aBlob.length() - footerSize); + Reader reader(aBlob.begin().get() + indexOffset, + aBlob.length() - footerSize - indexOffset); + + auto bounds = gfx::IntRect(origin, size); + + if (aDirtyRect) { + gfx::Rect dirty(aDirtyRect->min.x, aDirtyRect->min.y, aDirtyRect->width(), + aDirtyRect->height()); + dt->PushClipRect(dirty); + bounds = + bounds.Intersect(IntRect(aDirtyRect->min.x, aDirtyRect->min.y, + aDirtyRect->width(), aDirtyRect->height())); + } + + bool ret = true; + size_t offset = 0; + auto absBounds = IntRectAbsolute::FromRect(bounds); + while (reader.pos < reader.len) { + size_t end = reader.ReadSize(); + size_t extra_end = reader.ReadSize(); + MOZ_RELEASE_ASSERT(extra_end >= end); + MOZ_RELEASE_ASSERT(extra_end < aBlob.length()); + + auto combinedBounds = absBounds.Intersect(reader.ReadBounds()); + if (combinedBounds.IsEmpty()) { + offset = extra_end; + continue; + } + + layers::WebRenderTranslator translator(dt); + Reader fontReader(aBlob.begin().get() + end, extra_end - end); + size_t count = fontReader.ReadSize(); + for (size_t i = 0; i < count; i++) { + layers::BlobFont blobFont = fontReader.ReadBlobFont(); + RefPtr scaledFont = + GetScaledFont(&translator, blobFont.mFontInstanceKey); + translator.AddScaledFont(blobFont.mScaledFontPtr, scaledFont); + } + + Range blob(aBlob.begin() + offset, aBlob.begin() + end); + ret = + translator.TranslateRecording((char*)blob.begin().get(), blob.length()); + if (!ret) { + gfxCriticalNote << "Replay failure: " << translator.GetError(); + MOZ_RELEASE_ASSERT(false); + } + offset = extra_end; + } + + if (StaticPrefs::gfx_webrender_debug_blob_paint_flashing()) { + dt->SetTransform(gfx::Matrix()); + float r = float(rand()) / float(RAND_MAX); + float g = float(rand()) / float(RAND_MAX); + float b = float(rand()) / float(RAND_MAX); + dt->FillRect(gfx::Rect(origin.x, origin.y, size.width, size.height), + gfx::ColorPattern(gfx::DeviceColor(r, g, b, 0.5))); + } + + if (aDirtyRect) { + dt->PopClip(); + } + +#if 0 + static int i = 0; + char filename[40]; + sprintf(filename, "out%d.png", i++); + gfxUtils::WriteAsPNG(dt, filename); +#endif + + return ret; +} + +} // namespace wr +} // namespace mozilla + +extern "C" { + +bool wr_moz2d_render_cb(const mozilla::wr::ByteSlice blob, + mozilla::wr::ImageFormat aFormat, + const mozilla::wr::LayoutIntRect* aRenderRect, + const mozilla::wr::DeviceIntRect* aVisibleRect, + const uint16_t aTileSize, + const mozilla::wr::TileOffset* aTileOffset, + const mozilla::wr::LayoutIntRect* aDirtyRect, + mozilla::wr::MutByteSlice output) { + return mozilla::wr::Moz2DRenderCallback( + mozilla::wr::ByteSliceToRange(blob), + mozilla::wr::ImageFormatToSurfaceFormat(aFormat), aVisibleRect, + aRenderRect, aTileSize, aTileOffset, aDirtyRect, + mozilla::wr::MutByteSliceToRange(output)); +} + +} // extern diff --git a/gfx/webrender_bindings/README.webrender b/gfx/webrender_bindings/README.webrender new file mode 100644 index 0000000000..e4c0d5f60b --- /dev/null +++ b/gfx/webrender_bindings/README.webrender @@ -0,0 +1,23 @@ +To build and run WebRender in Gecko: +1. Install Rust if you don't have it already + If you are doing gecko builds already, you should already have Rust as it is a build requirement. + If not, you can install it using |mach bootstrap| (recommended) or from https://www.rust-lang.org/ + Note: If installing manually, use the stable 64-bit release - on Windows make sure to use the MSVC ABI installer. + Ensure that rustc and cargo are in your $PATH (adding $HOME/.cargo/bin/ should be sufficient) +2. Build using |mach build|. + You don't need anything special in your mozconfig for local builds; webrender will be built by default. +3. Run with |MOZ_WEBRENDER=1| in your environment. e.g. |MOZ_WEBRENDER=1 ./mach run|. + Alternatively, you can set the gfx.webrender.all pref to true (browser restart required). + Note that on Linux, acceleration is disabled by default and it needs to be enabled for WebRender to work. + On Linux you can enable acceleration by putting |MOZ_ACCELERATED=1| in your environment, or setting layers.acceleration.force-enabled to true in about:config. +4. Verify WebRender is enabled. You can do this by going to about:support and checking the "Compositing" line in the Graphics section. It should say "WebRender". + There should also be a WebRender section under "Decision Log" in about:support, which will provide some more detail on what caused it to be enabled/disabled. + +When making changes: + - Make the changes you want. + - Run |mach build| or |mach build binaries| as desired. + +For a debug webrender build: + Use a debug mozconfig (ac_add_options --enable-debug) + You can also use an opt build but make webrender less optimized by putting opt-level=0 in the [profile.release] section of your toolkit/library/rust/Cargo.toml file + See also https://groups.google.com/forum/#!topic/mozilla.dev.servo/MbeMcqqO1fs diff --git a/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp new file mode 100644 index 0000000000..779b376290 --- /dev/null +++ b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.cpp @@ -0,0 +1,248 @@ +/* -*- 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 "RenderAndroidHardwareBufferTextureHost.h" + +#include "mozilla/layers/AndroidHardwareBuffer.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/gfx/2D.h" +#include "GLContextEGL.h" +#include "GLLibraryEGL.h" +#include "GLReadTexImageHelper.h" +#include "OGLShaderConfig.h" + +namespace mozilla { +namespace wr { + +RenderAndroidHardwareBufferTextureHost::RenderAndroidHardwareBufferTextureHost( + layers::AndroidHardwareBuffer* aAndroidHardwareBuffer) + : mAndroidHardwareBuffer(aAndroidHardwareBuffer), + mEGLImage(EGL_NO_IMAGE), + mTextureHandle(0) { + MOZ_ASSERT(mAndroidHardwareBuffer); + MOZ_COUNT_CTOR_INHERITED(RenderAndroidHardwareBufferTextureHost, + RenderTextureHost); +} + +RenderAndroidHardwareBufferTextureHost:: + ~RenderAndroidHardwareBufferTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderAndroidHardwareBufferTextureHost, + RenderTextureHost); + DeleteTextureHandle(); + DestroyEGLImage(); +} + +gfx::IntSize RenderAndroidHardwareBufferTextureHost::GetSize() const { + if (mAndroidHardwareBuffer) { + return mAndroidHardwareBuffer->mSize; + } + return gfx::IntSize(); +} + +bool RenderAndroidHardwareBufferTextureHost::EnsureLockable() { + if (!mAndroidHardwareBuffer) { + return false; + } + + auto fenceFd = mAndroidHardwareBuffer->GetAndResetAcquireFence(); + if (fenceFd.IsValid()) { + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + + auto rawFD = fenceFd.TakePlatformHandle(); + const EGLint attribs[] = {LOCAL_EGL_SYNC_NATIVE_FENCE_FD_ANDROID, + rawFD.get(), LOCAL_EGL_NONE}; + + EGLSync sync = + egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, attribs); + if (sync) { + // Release fd here, since it is owned by EGLSync + Unused << rawFD.release(); + + if (egl->IsExtensionSupported(gl::EGLExtension::KHR_wait_sync)) { + egl->fWaitSync(sync, 0); + } else { + egl->fClientWaitSync(sync, 0, LOCAL_EGL_FOREVER); + } + egl->fDestroySync(sync); + } else { + gfxCriticalNote << "Failed to create EGLSync from acquire fence fd"; + } + } + + if (mTextureHandle) { + return true; + } + + if (!mEGLImage) { + // XXX add crop handling for video + // Should only happen the first time. + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + + const EGLint attrs[] = { + LOCAL_EGL_IMAGE_PRESERVED, + LOCAL_EGL_TRUE, + LOCAL_EGL_NONE, + LOCAL_EGL_NONE, + }; + + EGLClientBuffer clientBuffer = egl->mLib->fGetNativeClientBufferANDROID( + mAndroidHardwareBuffer->GetNativeBuffer()); + mEGLImage = egl->fCreateImage( + EGL_NO_CONTEXT, LOCAL_EGL_NATIVE_BUFFER_ANDROID, clientBuffer, attrs); + } + MOZ_ASSERT(mEGLImage); + + mGL->fGenTextures(1, &mTextureHandle); + mGL->fBindTexture(LOCAL_GL_TEXTURE_EXTERNAL, mTextureHandle); + mGL->fTexParameteri(LOCAL_GL_TEXTURE_EXTERNAL, LOCAL_GL_TEXTURE_WRAP_T, + LOCAL_GL_CLAMP_TO_EDGE); + mGL->fTexParameteri(LOCAL_GL_TEXTURE_EXTERNAL, LOCAL_GL_TEXTURE_WRAP_S, + LOCAL_GL_CLAMP_TO_EDGE); + mGL->fEGLImageTargetTexture2D(LOCAL_GL_TEXTURE_EXTERNAL, mEGLImage); + + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, + LOCAL_GL_TEXTURE_EXTERNAL_OES, mTextureHandle); + return true; +} + +wr::WrExternalImage RenderAndroidHardwareBufferTextureHost::Lock( + uint8_t aChannelIndex, gl::GLContext* aGL) { + MOZ_ASSERT(aChannelIndex == 0); + + if (mGL.get() != aGL) { + if (mGL) { + // This should not happen. + MOZ_ASSERT_UNREACHABLE("Unexpected GL context"); + return InvalidToWrExternalImage(); + } + mGL = aGL; + } + + if (!mGL || !mGL->MakeCurrent()) { + return InvalidToWrExternalImage(); + } + + if (!EnsureLockable()) { + return InvalidToWrExternalImage(); + } + + const auto uvs = GetUvCoords(GetSize()); + return NativeTextureToWrExternalImage( + mTextureHandle, uvs.first.x, uvs.first.y, uvs.second.x, uvs.second.y); +} + +void RenderAndroidHardwareBufferTextureHost::Unlock() {} + +size_t RenderAndroidHardwareBufferTextureHost::Bytes() { + return GetSize().width * GetSize().height * + BytesPerPixel(mAndroidHardwareBuffer->mFormat); +} + +void RenderAndroidHardwareBufferTextureHost::DeleteTextureHandle() { + if (!mTextureHandle) { + return; + } + MOZ_ASSERT(mGL); + mGL->fDeleteTextures(1, &mTextureHandle); + mTextureHandle = 0; +} + +void RenderAndroidHardwareBufferTextureHost::DestroyEGLImage() { + if (!mEGLImage) { + return; + } + MOZ_ASSERT(mGL); + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + egl->fDestroyImage(mEGLImage); + mEGLImage = EGL_NO_IMAGE; +} + +gfx::SurfaceFormat RenderAndroidHardwareBufferTextureHost::GetFormat() const { + MOZ_ASSERT(mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8A8 || + mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8X8); + + if (mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8A8) { + return gfx::SurfaceFormat::B8G8R8A8; + } + + if (mAndroidHardwareBuffer->mFormat == gfx::SurfaceFormat::R8G8B8X8) { + return gfx::SurfaceFormat::B8G8R8X8; + } + + gfxCriticalNoteOnce + << "Unexpected color format of RenderAndroidSurfaceTextureHost"; + + return gfx::SurfaceFormat::UNKNOWN; +} + +already_AddRefed +RenderAndroidHardwareBufferTextureHost::ReadTexImage() { + if (!mGL) { + mGL = RenderThread::Get()->SingletonGL(); + if (!mGL) { + return nullptr; + } + } + + if (!EnsureLockable()) { + return nullptr; + } + + /* Allocate resulting image surface */ + int32_t stride = GetSize().width * BytesPerPixel(GetFormat()); + RefPtr surf = + gfx::Factory::CreateDataSourceSurfaceWithStride(GetSize(), GetFormat(), + stride); + if (!surf) { + return nullptr; + } + + layers::ShaderConfigOGL config = layers::ShaderConfigFromTargetAndFormat( + LOCAL_GL_TEXTURE_EXTERNAL, mAndroidHardwareBuffer->mFormat); + int shaderConfig = config.mFeatures; + + bool ret = mGL->ReadTexImageHelper()->ReadTexImage( + surf, mTextureHandle, LOCAL_GL_TEXTURE_EXTERNAL, GetSize(), shaderConfig, + /* aYInvert */ false); + if (!ret) { + return nullptr; + } + + return surf.forget(); +} + +bool RenderAndroidHardwareBufferTextureHost::MapPlane( + RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + RefPtr readback = ReadTexImage(); + if (!readback) { + return false; + } + + gfx::DataSourceSurface::MappedSurface map; + if (!readback->Map(gfx::DataSourceSurface::MapType::READ, &map)) { + return false; + } + + mReadback = readback; + aPlaneInfo.mSize = GetSize(); + aPlaneInfo.mStride = map.mStride; + aPlaneInfo.mData = map.mData; + return true; +} + +void RenderAndroidHardwareBufferTextureHost::UnmapPlanes() { + if (mReadback) { + mReadback->Unmap(); + mReadback = nullptr; + } +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h new file mode 100644 index 0000000000..cd79c791ed --- /dev/null +++ b/gfx/webrender_bindings/RenderAndroidHardwareBufferTextureHost.h @@ -0,0 +1,73 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RenderAndroidHardwareBufferTextureHost_H +#define MOZILLA_GFX_RenderAndroidHardwareBufferTextureHost_H + +#include "GLContextTypes.h" +#include "GLTypes.h" +#include "RenderTextureHostSWGL.h" + +namespace mozilla { + +namespace layers { +class AndroidHardwareBuffer; +} + +namespace wr { + +class RenderAndroidHardwareBufferTextureHost final + : public RenderTextureHostSWGL { + public: + explicit RenderAndroidHardwareBufferTextureHost( + layers::AndroidHardwareBuffer* aAndroidHardwareBuffer); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + + size_t Bytes() override; + + RenderAndroidHardwareBufferTextureHost* + AsRenderAndroidHardwareBufferTextureHost() override { + return this; + } + + // RenderTextureHostSWGL + gfx::SurfaceFormat GetFormat() const override; + gfx::ColorDepth GetColorDepth() const override { + return gfx::ColorDepth::COLOR_8; + } + size_t GetPlaneCount() const override { return 1; } + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + void UnmapPlanes() override; + + layers::AndroidHardwareBuffer* GetAndroidHardwareBuffer() { + return mAndroidHardwareBuffer; + } + + gfx::IntSize GetSize() const; + + private: + virtual ~RenderAndroidHardwareBufferTextureHost(); + bool EnsureLockable(); + void DestroyEGLImage(); + void DeleteTextureHandle(); + already_AddRefed ReadTexImage(); + + const RefPtr mAndroidHardwareBuffer; + + RefPtr mGL; + EGLImage mEGLImage; + GLuint mTextureHandle; + + RefPtr mReadback; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RenderAndroidHardwareBufferTextureHost_H diff --git a/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp new file mode 100644 index 0000000000..2293babf2e --- /dev/null +++ b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp @@ -0,0 +1,326 @@ +/* -*- 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 "RenderAndroidSurfaceTextureHost.h" + +#include "GLReadTexImageHelper.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/webrender/RenderThread.h" +#include "GLContext.h" +#include "AndroidSurfaceTexture.h" + +namespace mozilla { +namespace wr { + +RenderAndroidSurfaceTextureHost::RenderAndroidSurfaceTextureHost( + const java::GeckoSurfaceTexture::GlobalRef& aSurfTex, gfx::IntSize aSize, + gfx::SurfaceFormat aFormat, bool aContinuousUpdate, + Maybe aTransformOverride, bool aIsRemoteTexture) + : mSurfTex(aSurfTex), + mSize(aSize), + mFormat(aFormat), + mContinuousUpdate(aContinuousUpdate), + mTransformOverride(aTransformOverride), + mPrepareStatus(STATUS_NONE), + mAttachedToGLContext(false), + mIsRemoteTexture(aIsRemoteTexture) { + MOZ_COUNT_CTOR_INHERITED(RenderAndroidSurfaceTextureHost, RenderTextureHost); + + if (mSurfTex) { + mSurfTex->IncrementUse(); + } +} + +RenderAndroidSurfaceTextureHost::~RenderAndroidSurfaceTextureHost() { + MOZ_ASSERT(RenderThread::IsInRenderThread()); + MOZ_COUNT_DTOR_INHERITED(RenderAndroidSurfaceTextureHost, RenderTextureHost); + // The SurfaceTexture gets destroyed when its use count reaches zero. + if (mSurfTex) { + mSurfTex->DecrementUse(); + } +} + +wr::WrExternalImage RenderAndroidSurfaceTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + MOZ_ASSERT(aChannelIndex == 0); + MOZ_ASSERT((mPrepareStatus == STATUS_PREPARED) || + (!mSurfTex->IsSingleBuffer() && + mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) || + mIsRemoteTexture); + + if (mIsRemoteTexture) { + EnsureAttachedToGLContext(); + } + + if (mGL.get() != aGL) { + // This should not happen. On android, SingletonGL is used. + MOZ_ASSERT_UNREACHABLE("Unexpected GL context"); + return InvalidToWrExternalImage(); + } + + if (!mSurfTex || !mGL || !mGL->MakeCurrent()) { + return InvalidToWrExternalImage(); + } + + MOZ_ASSERT(mAttachedToGLContext); + if (!mAttachedToGLContext) { + return InvalidToWrExternalImage(); + } + + UpdateTexImageIfNecessary(); + + const auto uvs = GetUvCoords(mSize); + return NativeTextureToWrExternalImage(mSurfTex->GetTexName(), uvs.first.x, + uvs.first.y, uvs.second.x, + uvs.second.y); +} + +void RenderAndroidSurfaceTextureHost::Unlock() {} + +bool RenderAndroidSurfaceTextureHost::EnsureAttachedToGLContext() { + // During handling WebRenderError, GeckoSurfaceTexture should not be attached + // to GLContext. + if (RenderThread::Get()->IsHandlingWebRenderError()) { + return false; + } + + if (mAttachedToGLContext) { + return true; + } + + if (!mGL) { + mGL = RenderThread::Get()->SingletonGL(); + } + + if (!mSurfTex || !mGL || !mGL->MakeCurrent()) { + return false; + } + + if (!mSurfTex->IsAttachedToGLContext((int64_t)mGL.get())) { + GLuint texName; + mGL->fGenTextures(1, &texName); + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, + LOCAL_GL_TEXTURE_EXTERNAL_OES, texName); + + if (NS_FAILED(mSurfTex->AttachToGLContext((int64_t)mGL.get(), texName))) { + MOZ_ASSERT(0); + mGL->fDeleteTextures(1, &texName); + return false; + } + } + + mAttachedToGLContext = true; + return true; +} + +void RenderAndroidSurfaceTextureHost::PrepareForUse() { + // When SurfaceTexture is single buffer mode, UpdateTexImage needs to be + // called only once for each publish. If UpdateTexImage is called more + // than once, it causes hang on puglish side. And UpdateTexImage needs to + // be called on render thread, since the SurfaceTexture is consumed on render + // thread. + MOZ_ASSERT(RenderThread::IsInRenderThread()); + MOZ_ASSERT(mPrepareStatus == STATUS_NONE); + + if (mContinuousUpdate || !mSurfTex) { + return; + } + + mPrepareStatus = STATUS_MIGHT_BE_USED_BY_WR; + + if (mSurfTex->IsSingleBuffer()) { + EnsureAttachedToGLContext(); + // When SurfaceTexture is single buffer mode, it is OK to call + // UpdateTexImage() here. + mSurfTex->UpdateTexImage(); + mPrepareStatus = STATUS_PREPARED; + } +} + +void RenderAndroidSurfaceTextureHost::NotifyForUse() { + MOZ_ASSERT(RenderThread::IsInRenderThread()); + + if (mPrepareStatus == STATUS_MIGHT_BE_USED_BY_WR) { + // This happens when SurfaceTexture of video is rendered on WebRender. + // There is a case that SurfaceTexture is not rendered on WebRender, instead + // it is rendered to WebGL and the SurfaceTexture should not be attached to + // gl context of WebRender. It is ugly. But it is same as Compositor + // rendering. + MOZ_ASSERT(!mSurfTex->IsSingleBuffer()); + if (!EnsureAttachedToGLContext()) { + return; + } + mPrepareStatus = STATUS_UPDATE_TEX_IMAGE_NEEDED; + } +} + +void RenderAndroidSurfaceTextureHost::NotifyNotUsed() { + MOZ_ASSERT(RenderThread::IsInRenderThread()); + + if (!mSurfTex) { + MOZ_ASSERT(mPrepareStatus == STATUS_NONE); + return; + } + + if (mIsRemoteTexture) { + UpdateTexImageIfNecessary(); + } + + if (mSurfTex->IsSingleBuffer()) { + MOZ_ASSERT(mPrepareStatus == STATUS_PREPARED); + MOZ_ASSERT(mAttachedToGLContext); + // Release SurfaceTexture's buffer to client side. + mGL->MakeCurrent(); + mSurfTex->ReleaseTexImage(); + } else if (mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) { + MOZ_ASSERT(mAttachedToGLContext); + // This could happen when video frame was skipped. UpdateTexImage() neeeds + // to be called for adjusting SurfaceTexture's buffer status. + mSurfTex->UpdateTexImage(); + } + + mPrepareStatus = STATUS_NONE; +} + +void RenderAndroidSurfaceTextureHost::UpdateTexImageIfNecessary() { + if (mIsRemoteTexture) { + EnsureAttachedToGLContext(); + if (mPrepareStatus == STATUS_NONE) { + PrepareForUse(); + } + if (mPrepareStatus == STATUS_MIGHT_BE_USED_BY_WR) { + NotifyForUse(); + } + } + + if (mContinuousUpdate) { + MOZ_ASSERT(!mSurfTex->IsSingleBuffer()); + mSurfTex->UpdateTexImage(); + } else if (mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) { + MOZ_ASSERT(!mSurfTex->IsSingleBuffer()); + // When SurfaceTexture is not single buffer mode, call UpdateTexImage() once + // just before rendering. During playing video, one SurfaceTexture is used + // for all RenderAndroidSurfaceTextureHosts of video. + mSurfTex->UpdateTexImage(); + mPrepareStatus = STATUS_PREPARED; + } +} + +gfx::SurfaceFormat RenderAndroidSurfaceTextureHost::GetFormat() const { + MOZ_ASSERT(mFormat == gfx::SurfaceFormat::R8G8B8A8 || + mFormat == gfx::SurfaceFormat::R8G8B8X8); + + if (mFormat == gfx::SurfaceFormat::R8G8B8A8) { + return gfx::SurfaceFormat::B8G8R8A8; + } + + if (mFormat == gfx::SurfaceFormat::R8G8B8X8) { + return gfx::SurfaceFormat::B8G8R8X8; + } + + gfxCriticalNoteOnce + << "Unexpected color format of RenderAndroidSurfaceTextureHost"; + + return gfx::SurfaceFormat::UNKNOWN; +} + +already_AddRefed +RenderAndroidSurfaceTextureHost::ReadTexImage() { + if (!mGL) { + mGL = RenderThread::Get()->SingletonGL(); + if (!mGL) { + return nullptr; + } + } + + /* Allocate resulting image surface */ + int32_t stride = mSize.width * BytesPerPixel(GetFormat()); + RefPtr surf = + gfx::Factory::CreateDataSourceSurfaceWithStride(mSize, GetFormat(), + stride); + if (!surf) { + return nullptr; + } + + layers::ShaderConfigOGL config = layers::ShaderConfigFromTargetAndFormat( + LOCAL_GL_TEXTURE_EXTERNAL, mFormat); + int shaderConfig = config.mFeatures; + + bool ret = mGL->ReadTexImageHelper()->ReadTexImage( + surf, mSurfTex->GetTexName(), LOCAL_GL_TEXTURE_EXTERNAL, mSize, + shaderConfig, /* aYInvert */ false); + if (!ret) { + return nullptr; + } + + return surf.forget(); +} + +bool RenderAndroidSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + UpdateTexImageIfNecessary(); + + RefPtr readback = ReadTexImage(); + if (!readback) { + return false; + } + + gfx::DataSourceSurface::MappedSurface map; + if (!readback->Map(gfx::DataSourceSurface::MapType::READ, &map)) { + return false; + } + + mReadback = readback; + aPlaneInfo.mSize = mSize; + aPlaneInfo.mStride = map.mStride; + aPlaneInfo.mData = map.mData; + return true; +} + +void RenderAndroidSurfaceTextureHost::UnmapPlanes() { + if (mReadback) { + mReadback->Unmap(); + mReadback = nullptr; + } +} + +std::pair RenderAndroidSurfaceTextureHost::GetUvCoords( + gfx::IntSize aTextureSize) const { + gfx::Matrix4x4 transform; + + // GetTransformMatrix() returns the transform set by the producer side of the + // SurfaceTexture that must be applied to texture coordinates when + // sampling. In some cases we may have set an override value, such as in + // AndroidNativeWindowTextureData where we own the producer side, or for + // MediaCodec output on devices where where we know the value is incorrect. + if (mTransformOverride) { + transform = *mTransformOverride; + } else if (mSurfTex) { + const auto& surf = java::sdk::SurfaceTexture::LocalRef( + java::sdk::SurfaceTexture::Ref::From(mSurfTex)); + gl::AndroidSurfaceTexture::GetTransformMatrix(surf, &transform); + } + + // We expect this transform to always be rectilinear, usually just a + // y-flip and sometimes an x and y scale. This allows this function + // to simply transform and return 2 points here instead of 4. + MOZ_ASSERT(transform.IsRectilinear(), + "Unexpected non-rectilinear transform returned from " + "SurfaceTexture.GetTransformMatrix()"); + + transform.PostScale(aTextureSize.width, aTextureSize.height, 0.0); + + gfx::Point uv0 = gfx::Point(0.0, 0.0); + gfx::Point uv1 = gfx::Point(1.0, 1.0); + uv0 = transform.TransformPoint(uv0); + uv1 = transform.TransformPoint(uv1); + + return std::make_pair(uv0, uv1); +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h new file mode 100644 index 0000000000..1a6238a72f --- /dev/null +++ b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.h @@ -0,0 +1,96 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERANDROIDSURFACETEXTUREHOST_H +#define MOZILLA_GFX_RENDERANDROIDSURFACETEXTUREHOST_H + +#include "mozilla/java/GeckoSurfaceTextureWrappers.h" +#include "mozilla/layers/TextureHostOGL.h" +#include "RenderTextureHostSWGL.h" + +namespace mozilla { + +namespace gfx { +class DataSourceSurface; +} + +namespace wr { + +class RenderAndroidSurfaceTextureHost final : public RenderTextureHostSWGL { + public: + explicit RenderAndroidSurfaceTextureHost( + const java::GeckoSurfaceTexture::GlobalRef& aSurfTex, gfx::IntSize aSize, + gfx::SurfaceFormat aFormat, bool aContinuousUpdate, + Maybe aTransformOverride, bool aIsRemoteTexture); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + + size_t Bytes() override { + return mSize.width * mSize.height * BytesPerPixel(mFormat); + } + + void PrepareForUse() override; + void NotifyForUse() override; + void NotifyNotUsed() override; + + // RenderTextureHostSWGL + gfx::SurfaceFormat GetFormat() const override; + gfx::ColorDepth GetColorDepth() const override { + return gfx::ColorDepth::COLOR_8; + } + size_t GetPlaneCount() const override { return 1; } + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + void UnmapPlanes() override; + + RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost() + override { + return this; + } + + void UpdateTexImageIfNecessary(); + + mozilla::java::GeckoSurfaceTexture::GlobalRef mSurfTex; + const gfx::IntSize mSize; + const gfx::SurfaceFormat mFormat; + // mContinuousUpdate was used for rendering video in the past. + // It is not used on current gecko. + const bool mContinuousUpdate; + const Maybe mTransformOverride; + + private: + virtual ~RenderAndroidSurfaceTextureHost(); + bool EnsureAttachedToGLContext(); + + already_AddRefed ReadTexImage(); + + // Returns the UV coordinates to be used when sampling the texture, taking in + // to account the SurfaceTexture's transform if applicable. + std::pair GetUvCoords( + gfx::IntSize aTextureSize) const override; + + enum PrepareStatus { + STATUS_NONE, + STATUS_MIGHT_BE_USED_BY_WR, + STATUS_UPDATE_TEX_IMAGE_NEEDED, + STATUS_PREPARED + }; + + PrepareStatus mPrepareStatus; + bool mAttachedToGLContext; + + RefPtr mGL; + + RefPtr mReadback; + + bool mIsRemoteTexture; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERANDROIDSURFACETEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderBufferTextureHost.cpp b/gfx/webrender_bindings/RenderBufferTextureHost.cpp new file mode 100644 index 0000000000..920556c7ef --- /dev/null +++ b/gfx/webrender_bindings/RenderBufferTextureHost.cpp @@ -0,0 +1,254 @@ +/* -*- 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 "RenderBufferTextureHost.h" + +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/ImageDataSerializer.h" + +namespace mozilla { +namespace wr { + +RenderBufferTextureHost::RenderBufferTextureHost( + uint8_t* aBuffer, const layers::BufferDescriptor& aDescriptor) + : mBuffer(aBuffer), + mDescriptor(aDescriptor), + mMap(), + mYMap(), + mCbMap(), + mCrMap(), + mLocked(false) { + MOZ_COUNT_CTOR_INHERITED(RenderBufferTextureHost, RenderTextureHost); + + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: { + const layers::YCbCrDescriptor& ycbcr = mDescriptor.get_YCbCrDescriptor(); + mSize = ycbcr.display().Size(); + mFormat = gfx::SurfaceFormat::YUV; + break; + } + case layers::BufferDescriptor::TRGBDescriptor: { + const layers::RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor(); + mSize = rgb.size(); + mFormat = rgb.format(); + break; + } + default: + gfxCriticalError() << "Bad buffer host descriptor " + << (int)mDescriptor.type(); + MOZ_CRASH("GFX: Bad descriptor"); + } +} + +RenderBufferTextureHost::~RenderBufferTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderBufferTextureHost, RenderTextureHost); +} + +wr::WrExternalImage RenderBufferTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (!mLocked) { + if (!GetBuffer()) { + if (!mDestroyed) { + // We hit some problems to get the shmem. + gfxCriticalNote << "GetBuffer Failed"; + } + return InvalidToWrExternalImage(); + } + if (mFormat != gfx::SurfaceFormat::YUV) { + mSurface = gfx::Factory::CreateWrappingDataSourceSurface( + GetBuffer(), + layers::ImageDataSerializer::GetRGBStride( + mDescriptor.get_RGBDescriptor()), + mSize, mFormat); + if (NS_WARN_IF(!mSurface)) { + gfxCriticalNote << "DataSourceSurface is null"; + return InvalidToWrExternalImage(); + } + if (NS_WARN_IF( + !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) { + mSurface = nullptr; + gfxCriticalNote << "Failed to map Surface"; + return InvalidToWrExternalImage(); + } + } else { + const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + auto cbcrSize = layers::ImageDataSerializer::GetCroppedCbCrSize(desc); + + mYSurface = gfx::Factory::CreateWrappingDataSourceSurface( + layers::ImageDataSerializer::GetYChannel(GetBuffer(), desc), + desc.yStride(), desc.display().Size(), gfx::SurfaceFormat::A8); + mCbSurface = gfx::Factory::CreateWrappingDataSourceSurface( + layers::ImageDataSerializer::GetCbChannel(GetBuffer(), desc), + desc.cbCrStride(), cbcrSize, gfx::SurfaceFormat::A8); + mCrSurface = gfx::Factory::CreateWrappingDataSourceSurface( + layers::ImageDataSerializer::GetCrChannel(GetBuffer(), desc), + desc.cbCrStride(), cbcrSize, gfx::SurfaceFormat::A8); + if (NS_WARN_IF(!mYSurface || !mCbSurface || !mCrSurface)) { + mYSurface = mCbSurface = mCrSurface = nullptr; + gfxCriticalNote << "YCbCr Surface is null"; + return InvalidToWrExternalImage(); + } + if (NS_WARN_IF( + !mYSurface->Map(gfx::DataSourceSurface::MapType::READ, &mYMap) || + !mCbSurface->Map(gfx::DataSourceSurface::MapType::READ, + &mCbMap) || + !mCrSurface->Map(gfx::DataSourceSurface::MapType::READ, + &mCrMap))) { + mYSurface = mCbSurface = mCrSurface = nullptr; + gfxCriticalNote << "Failed to map YCbCr Surface"; + return InvalidToWrExternalImage(); + } + } + mLocked = true; + } + + RenderBufferData data = GetBufferDataForRender(aChannelIndex); + return RawDataToWrExternalImage(data.mData, data.mBufferSize); +} + +void RenderBufferTextureHost::Unlock() { + if (mLocked) { + if (mSurface) { + mSurface->Unmap(); + mSurface = nullptr; + } else if (mYSurface) { + mYSurface->Unmap(); + mCbSurface->Unmap(); + mCrSurface->Unmap(); + mYSurface = mCbSurface = mCrSurface = nullptr; + } + mLocked = false; + } +} + +RenderBufferTextureHost::RenderBufferData +RenderBufferTextureHost::GetBufferDataForRender(uint8_t aChannelIndex) { + MOZ_ASSERT(mFormat != gfx::SurfaceFormat::YUV || aChannelIndex < 3); + MOZ_ASSERT(mFormat == gfx::SurfaceFormat::YUV || aChannelIndex < 1); + MOZ_ASSERT(mLocked); + + if (mFormat != gfx::SurfaceFormat::YUV) { + MOZ_ASSERT(mSurface); + + return RenderBufferData(mMap.mData, + mMap.mStride * mSurface->GetSize().height); + } else { + MOZ_ASSERT(mYSurface && mCbSurface && mCrSurface); + + switch (aChannelIndex) { + case 0: + return RenderBufferData(mYMap.mData, + mYMap.mStride * mYSurface->GetSize().height); + break; + case 1: + return RenderBufferData(mCbMap.mData, + mCbMap.mStride * mCbSurface->GetSize().height); + break; + case 2: + return RenderBufferData(mCrMap.mData, + mCrMap.mStride * mCrSurface->GetSize().height); + break; + default: + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return RenderBufferData(nullptr, 0); + } + } +} + +size_t RenderBufferTextureHost::GetPlaneCount() const { + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: + return 3; + default: + return 1; + } +} + +gfx::SurfaceFormat RenderBufferTextureHost::GetFormat() const { + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: + return gfx::SurfaceFormat::YUV; + default: + return mDescriptor.get_RGBDescriptor().format(); + } +} + +gfx::ColorDepth RenderBufferTextureHost::GetColorDepth() const { + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: + return mDescriptor.get_YCbCrDescriptor().colorDepth(); + default: + return gfx::ColorDepth::COLOR_8; + } +} + +gfx::YUVRangedColorSpace RenderBufferTextureHost::GetYUVColorSpace() const { + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: + return gfx::GetYUVRangedColorSpace(mDescriptor.get_YCbCrDescriptor()); + default: + return gfx::YUVRangedColorSpace::Default; + } +} + +bool RenderBufferTextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + if (!mBuffer) { + if (!mDestroyed) { + // We hit some problems to get the shmem. + gfxCriticalNote << "GetBuffer Failed"; + } + return false; + } + + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: { + const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + switch (aChannelIndex) { + case 0: + aPlaneInfo.mData = + layers::ImageDataSerializer::GetYChannel(mBuffer, desc); + aPlaneInfo.mStride = desc.yStride(); + aPlaneInfo.mSize = desc.display().Size(); + break; + case 1: + aPlaneInfo.mData = + layers::ImageDataSerializer::GetCbChannel(mBuffer, desc); + aPlaneInfo.mStride = desc.cbCrStride(); + aPlaneInfo.mSize = + layers::ImageDataSerializer::GetCroppedCbCrSize(desc); + break; + case 2: + aPlaneInfo.mData = + layers::ImageDataSerializer::GetCrChannel(mBuffer, desc); + aPlaneInfo.mStride = desc.cbCrStride(); + aPlaneInfo.mSize = + layers::ImageDataSerializer::GetCroppedCbCrSize(desc); + break; + } + break; + } + default: { + const layers::RGBDescriptor& desc = mDescriptor.get_RGBDescriptor(); + aPlaneInfo.mData = mBuffer; + aPlaneInfo.mStride = layers::ImageDataSerializer::GetRGBStride(desc); + aPlaneInfo.mSize = desc.size(); + break; + } + } + return true; +} + +void RenderBufferTextureHost::UnmapPlanes() {} + +void RenderBufferTextureHost::Destroy() { + mBuffer = nullptr; + mDestroyed = true; +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderBufferTextureHost.h b/gfx/webrender_bindings/RenderBufferTextureHost.h new file mode 100644 index 0000000000..0fd2ef26b7 --- /dev/null +++ b/gfx/webrender_bindings/RenderBufferTextureHost.h @@ -0,0 +1,81 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H +#define MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H + +#include "RenderTextureHostSWGL.h" + +namespace mozilla { +namespace wr { + +class RenderBufferTextureHost final : public RenderTextureHostSWGL { + public: + RenderBufferTextureHost(uint8_t* aBuffer, + const layers::BufferDescriptor& aDescriptor); + + // RenderTextureHost + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + + size_t Bytes() override { + return mSize.width * mSize.height * BytesPerPixel(mFormat); + } + class RenderBufferData { + public: + RenderBufferData(uint8_t* aData, size_t aBufferSize) + : mData(aData), mBufferSize(aBufferSize) {} + const uint8_t* mData; + size_t mBufferSize; + }; + + RenderBufferData GetBufferDataForRender(uint8_t aChannelIndex); + + // RenderTextureHostSWGL + size_t GetPlaneCount() const override; + + gfx::SurfaceFormat GetFormat() const override; + + gfx::ColorDepth GetColorDepth() const override; + + gfx::YUVRangedColorSpace GetYUVColorSpace() const override; + + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + + void UnmapPlanes() override; + + void Destroy() override; + + private: + virtual ~RenderBufferTextureHost(); + + uint8_t* GetBuffer() const { return mBuffer; } + + uint8_t* mBuffer; + layers::BufferDescriptor mDescriptor; + gfx::IntSize mSize; + gfx::SurfaceFormat mFormat; + + RefPtr mSurface; + gfx::DataSourceSurface::MappedSurface mMap; + + RefPtr mYSurface; + RefPtr mCbSurface; + RefPtr mCrSurface; + gfx::DataSourceSurface::MappedSurface mYMap; + gfx::DataSourceSurface::MappedSurface mCbMap; + gfx::DataSourceSurface::MappedSurface mCrMap; + + bool mLocked; + + bool mDestroyed = false; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERBUFFERTEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderCompositor.cpp b/gfx/webrender_bindings/RenderCompositor.cpp new file mode 100644 index 0000000000..8dd6e8ff00 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositor.cpp @@ -0,0 +1,286 @@ +/* -*- 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 "RenderCompositor.h" + +#include "gfxConfig.h" +#include "gfxPlatform.h" +#include "GLContext.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/layers/SyncObject.h" +#include "mozilla/webrender/RenderCompositorLayersSWGL.h" +#include "mozilla/webrender/RenderCompositorOGL.h" +#include "mozilla/webrender/RenderCompositorSWGL.h" +#include "mozilla/widget/CompositorWidget.h" + +#ifdef XP_WIN +# include "mozilla/webrender/RenderCompositorANGLE.h" +# include "mozilla/widget/WinCompositorWidget.h" +#endif + +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK) +# include "mozilla/webrender/RenderCompositorEGL.h" +#endif + +#ifdef MOZ_WAYLAND +# include "mozilla/webrender/RenderCompositorNative.h" +#endif + +#ifdef XP_MACOSX +# include "mozilla/webrender/RenderCompositorNative.h" +#endif + +namespace mozilla::wr { + +void wr_compositor_add_surface(void* aCompositor, wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform* aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->AddSurface(aId, *aTransform, aClipRect, aImageRendering); +} + +void wr_compositor_begin_frame(void* aCompositor) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->CompositorBeginFrame(); +} + +void wr_compositor_bind(void* aCompositor, wr::NativeTileId aId, + wr::DeviceIntPoint* aOffset, uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->Bind(aId, aOffset, aFboId, aDirtyRect, aValidRect); +} + +void wr_compositor_create_surface(void* aCompositor, wr::NativeSurfaceId aId, + wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->CreateSurface(aId, aVirtualOffset, aTileSize, aIsOpaque); +} + +void wr_compositor_create_external_surface(void* aCompositor, + wr::NativeSurfaceId aId, + bool aIsOpaque) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->CreateExternalSurface(aId, aIsOpaque); +} + +void wr_compositor_create_backdrop_surface(void* aCompositor, + wr::NativeSurfaceId aId, + wr::ColorF aColor) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->CreateBackdropSurface(aId, aColor); +} + +void wr_compositor_create_tile(void* aCompositor, wr::NativeSurfaceId aId, + int32_t aX, int32_t aY) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->CreateTile(aId, aX, aY); +} + +void wr_compositor_destroy_tile(void* aCompositor, wr::NativeSurfaceId aId, + int32_t aX, int32_t aY) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->DestroyTile(aId, aX, aY); +} + +void wr_compositor_destroy_surface(void* aCompositor, NativeSurfaceId aId) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->DestroySurface(aId); +} + +void wr_compositor_attach_external_image(void* aCompositor, + wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->AttachExternalImage(aId, aExternalImage); +} + +void wr_compositor_start_compositing(void* aCompositor, wr::ColorF aClearColor, + const wr::DeviceIntRect* aDirtyRects, + size_t aNumDirtyRects, + const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->StartCompositing(aClearColor, aDirtyRects, aNumDirtyRects, + aOpaqueRects, aNumOpaqueRects); +} + +void wr_compositor_end_frame(void* aCompositor) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->CompositorEndFrame(); +} + +void wr_compositor_enable_native_compositor(void* aCompositor, bool aEnable) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->EnableNativeCompositor(aEnable); +} + +void wr_compositor_get_capabilities(void* aCompositor, + CompositorCapabilities* aCaps) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->GetCompositorCapabilities(aCaps); +} + +void wr_compositor_get_window_visibility(void* aCompositor, + WindowVisibility* aVisibility) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->GetWindowVisibility(aVisibility); +} + +void wr_compositor_unbind(void* aCompositor) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->Unbind(); +} + +void wr_compositor_deinit(void* aCompositor) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->DeInit(); +} + +void wr_compositor_map_tile(void* aCompositor, wr::NativeTileId aId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, void** aData, + int32_t* aStride) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->MapTile(aId, aDirtyRect, aValidRect, aData, aStride); +} + +void wr_compositor_unmap_tile(void* aCompositor) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->UnmapTile(); +} + +void wr_partial_present_compositor_set_buffer_damage_region( + void* aCompositor, const wr::DeviceIntRect* aRects, size_t aNRects) { + RenderCompositor* compositor = static_cast(aCompositor); + compositor->SetBufferDamageRegion(aRects, aNRects); +} + +/* static */ +UniquePtr RenderCompositor::Create( + const RefPtr& aWidget, nsACString& aError) { + if (aWidget->GetCompositorOptions().UseSoftwareWebRender()) { +#ifdef XP_MACOSX + // Mac uses NativeLayerCA + if (!gfxPlatform::IsHeadless()) { + return RenderCompositorNativeSWGL::Create(aWidget, aError); + } +#elif defined(MOZ_WAYLAND) + if (gfx::gfxVars::UseWebRenderCompositor()) { + return RenderCompositorNativeSWGL::Create(aWidget, aError); + } +#endif + UniquePtr comp = + RenderCompositorLayersSWGL::Create(aWidget, aError); + if (comp) { + return comp; + } +#if defined(MOZ_WIDGET_ANDROID) + // On Android, we do not want to fallback from RenderCompositorOGLSWGL to + // RenderCompositorSWGL. + if (aWidget->GetCompositorOptions().AllowSoftwareWebRenderOGL()) { + return nullptr; + } +#endif + return RenderCompositorSWGL::Create(aWidget, aError); + } + +#ifdef XP_WIN + if (gfx::gfxVars::UseWebRenderANGLE()) { + return RenderCompositorANGLE::Create(aWidget, aError); + } +#endif + +#if defined(MOZ_WAYLAND) + if (gfx::gfxVars::UseWebRenderCompositor()) { + return RenderCompositorNativeOGL::Create(aWidget, aError); + } +#endif + +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK) + UniquePtr eglCompositor = + RenderCompositorEGL::Create(aWidget, aError); + if (eglCompositor) { + return eglCompositor; + } +#endif + +#if defined(MOZ_WIDGET_ANDROID) + // RenderCompositorOGL is not used on android + return nullptr; +#elif defined(XP_MACOSX) + // Mac uses NativeLayerCA + return RenderCompositorNativeOGL::Create(aWidget, aError); +#else + return RenderCompositorOGL::Create(aWidget, aError); +#endif +} + +RenderCompositor::RenderCompositor( + const RefPtr& aWidget) + : mWidget(aWidget) {} + +RenderCompositor::~RenderCompositor() = default; + +bool RenderCompositor::MakeCurrent() { return gl()->MakeCurrent(); } + +void RenderCompositor::GetCompositorCapabilities( + CompositorCapabilities* aCaps) { + if (StaticPrefs::gfx_webrender_compositor_max_update_rects_AtStartup() > 0) { + aCaps->max_update_rects = 1; + } else { + aCaps->max_update_rects = 0; + } +} + +void RenderCompositor::GetWindowVisibility(WindowVisibility* aVisibility) { +#ifdef XP_WIN + auto* widget = mWidget->AsWindows(); + if (!widget) { + return; + } + aVisibility->size_mode = ToWrWindowSizeMode(widget->GetWindowSizeMode()); + aVisibility->is_fully_occluded = widget->GetWindowIsFullyOccluded(); +#endif +} + +GLenum RenderCompositor::IsContextLost(bool aForce) { + auto* glc = gl(); + // GetGraphicsResetStatus may trigger an implicit MakeCurrent if robustness + // is not supported, so unless we are forcing, pass on the check. + if (!glc || (!aForce && !glc->IsSupported(gl::GLFeature::robustness))) { + return LOCAL_GL_NO_ERROR; + } + auto resetStatus = glc->fGetGraphicsResetStatus(); + switch (resetStatus) { + case LOCAL_GL_NO_ERROR: + break; + case LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB: + NS_WARNING("Device reset due to system / different context"); + break; + case LOCAL_GL_PURGED_CONTEXT_RESET_NV: + NS_WARNING("Device reset due to NV video memory purged"); + break; + case LOCAL_GL_GUILTY_CONTEXT_RESET_ARB: + gfxCriticalError() << "Device reset due to WR context"; + break; + case LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB: + gfxCriticalNote << "Device reset may be due to WR context"; + break; + default: + gfxCriticalError() << "Device reset with WR context unexpected status: " + << gfx::hexa(resetStatus); + break; + } + return resetStatus; +} + +} // namespace mozilla::wr diff --git a/gfx/webrender_bindings/RenderCompositor.h b/gfx/webrender_bindings/RenderCompositor.h new file mode 100644 index 0000000000..89b06395c1 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositor.h @@ -0,0 +1,222 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_H + +#include "mozilla/ipc/FileDescriptor.h" +#include "mozilla/RefPtr.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/webrender/WebRenderTypes.h" +#include "Units.h" + +#include "GLTypes.h" + +namespace mozilla { + +namespace gl { +class GLContext; +} + +namespace layers { +class CompositionRecorder; +class SyncObjectHost; +} // namespace layers + +namespace widget { +class CompositorWidget; +} + +namespace wr { + +class RenderCompositorLayersSWGL; +class RenderCompositorD3D11SWGL; + +class RenderCompositor { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositor(const RefPtr& aWidget); + virtual ~RenderCompositor(); + + virtual bool BeginFrame() = 0; + + // Optional handler in case the frame was aborted allowing the compositor + // to clean up relevant resources if required. + virtual void CancelFrame() {} + + // Called to notify the RenderCompositor that all of the commands for a frame + // have been pushed to the queue. + // @return a RenderedFrameId for the frame + virtual RenderedFrameId EndFrame( + const nsTArray& aDirtyRects) = 0; + // Returns false when waiting gpu tasks is failed. + // It might happen when rendering context is lost. + virtual bool WaitForGPU() { return true; } + + // Check for and return the last completed frame. + // @return the last (highest) completed RenderedFrameId + virtual RenderedFrameId GetLastCompletedFrameId() { + return mLatestRenderFrameId.Prev(); + } + + // Update FrameId when WR rendering does not happen. + virtual RenderedFrameId UpdateFrameId() { return GetNextRenderFrameId(); } + + virtual void Pause() = 0; + virtual bool Resume() = 0; + // Called when WR rendering is skipped + virtual void Update() {} + + virtual gl::GLContext* gl() const { return nullptr; } + virtual void* swgl() const { return nullptr; } + + virtual bool MakeCurrent(); + + virtual bool UseANGLE() const { return false; } + + virtual bool UseDComp() const { return false; } + + virtual bool UseTripleBuffering() const { return false; } + + virtual layers::WebRenderBackend BackendType() const { + return layers::WebRenderBackend::HARDWARE; + } + virtual layers::WebRenderCompositor CompositorType() const { + return layers::WebRenderCompositor::DRAW; + } + + virtual RenderCompositorD3D11SWGL* AsRenderCompositorD3D11SWGL() { + return nullptr; + } + + virtual RenderCompositorLayersSWGL* AsRenderCompositorLayersSWGL() { + return nullptr; + } + + // True if AttachExternalImage supports being used with an external + // image that maps to a RenderBufferTextureHost + virtual bool SupportsExternalBufferTextures() const { return false; } + + virtual LayoutDeviceIntSize GetBufferSize() = 0; + + widget::CompositorWidget* GetWidget() const { return mWidget; } + + layers::SyncObjectHost* GetSyncObject() const { return mSyncObject.get(); } + + virtual GLenum IsContextLost(bool aForce); + + virtual bool SupportAsyncScreenshot() { return true; } + + virtual bool ShouldUseNativeCompositor() { return false; } + + // Interface for wr::Compositor + virtual void CompositorBeginFrame() {} + virtual void CompositorEndFrame() {} + virtual void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, + uint32_t* aFboId, wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) {} + virtual void Unbind() {} + virtual bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, void** aData, + int32_t* aStride) { + return false; + } + virtual void UnmapTile() {} + virtual void CreateSurface(wr::NativeSurfaceId aId, + wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) {} + virtual void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) {} + virtual void CreateBackdropSurface(wr::NativeSurfaceId aId, + wr::ColorF aColor) {} + virtual void DestroySurface(NativeSurfaceId aId) {} + virtual void CreateTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) {} + virtual void DestroyTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) {} + virtual void AttachExternalImage(wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage) {} + virtual void AddSurface(wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering) {} + // Called in the middle of a frame after all surfaces have been added but + // before tiles are updated to signal that early compositing can start + virtual void StartCompositing(wr::ColorF aClearColor, + const wr::DeviceIntRect* aDirtyRects, + size_t aNumDirtyRects, + const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects) {} + virtual void EnableNativeCompositor(bool aEnable) {} + virtual void DeInit() {} + // Overrides any of the default compositor capabilities for behavior this + // compositor might require. + virtual void GetCompositorCapabilities(CompositorCapabilities* aCaps); + + virtual void GetWindowVisibility(WindowVisibility* aVisibility); + + // Interface for partial present + virtual bool UsePartialPresent() { return false; } + virtual bool RequestFullRender() { return false; } + virtual uint32_t GetMaxPartialPresentRects() { return 0; } + virtual bool ShouldDrawPreviousPartialPresentRegions() { return false; } + // Returns the age of the current backbuffer., This should be used, if + // ShouldDrawPreviousPartialPresentRegions() returns true, to determine the + // region which must be rendered in addition to the current frame's dirty + // rect. + virtual size_t GetBufferAge() const { return 0; } + // Allows webrender to specify the total region that will be rendered to this + // frame, ie the frame's dirty region and some previous frames' dirty regions, + // if applicable (calculated using the buffer age). Must be called before + // anything has been rendered to the main framebuffer. + virtual void SetBufferDamageRegion(const wr::DeviceIntRect* aRects, + size_t aNumRects) {} + + // Whether the surface origin is top-left. + virtual bool SurfaceOriginIsTopLeft() { return false; } + + // Does readback if wr_renderer_readback() could not get correct WR rendered + // result. It could happen when WebRender renders to multiple overlay layers. + virtual bool MaybeReadback(const gfx::IntSize& aReadbackSize, + const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, + bool* aNeedsYFlip) { + return false; + } + virtual void MaybeRequestAllowFrameRecording(bool aWillRecord) {} + virtual bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) { + return false; + } + virtual bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) { + return false; + } + virtual bool MaybeProcessScreenshotQueue() { return false; } + + // Returns FileDescriptor of release fence. + // Release fence is a fence that is used for waiting until usage/composite of + // AHardwareBuffer is ended. The fence is delivered to client side via + // ImageBridge. It is used only on android. + virtual ipc::FileDescriptor GetAndResetReleaseFence() { + return ipc::FileDescriptor(); + } + + virtual bool IsPaused() { return false; } + + protected: + // We default this to 2, so that mLatestRenderFrameId.Prev() is always valid. + RenderedFrameId mLatestRenderFrameId = RenderedFrameId{2}; + RenderedFrameId GetNextRenderFrameId() { + mLatestRenderFrameId = mLatestRenderFrameId.Next(); + return mLatestRenderFrameId; + } + + RefPtr mWidget; + RefPtr mSyncObject; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorANGLE.cpp b/gfx/webrender_bindings/RenderCompositorANGLE.cpp new file mode 100644 index 0000000000..e01ac6a187 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorANGLE.cpp @@ -0,0 +1,1025 @@ +/* -*- 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 "RenderCompositorANGLE.h" + +#include "GLContext.h" +#include "GLContextEGL.h" +#include "GLContextProvider.h" +#include "mozilla/gfx/DeviceManagerDx.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/StackArray.h" +#include "mozilla/layers/HelpersD3D11.h" +#include "mozilla/layers/SyncObject.h" +#include "mozilla/ProfilerMarkers.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/webrender/DCLayerTree.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/widget/CompositorWidget.h" +#include "mozilla/widget/WinCompositorWidget.h" +#include "mozilla/WindowsVersion.h" +#include "mozilla/Telemetry.h" +#include "nsPrintfCString.h" +#include "FxROutputHandler.h" + +#include +#include +#include + +// Flag for PrintWindow() that is defined in Winuser.h. It is defined since +// Windows 8.1. This allows PrintWindow to capture window content that is +// rendered with DirectComposition. +#undef PW_RENDERFULLCONTENT +#define PW_RENDERFULLCONTENT 0x00000002 + +namespace mozilla { +namespace wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +/* static */ +UniquePtr RenderCompositorANGLE::Create( + const RefPtr& aWidget, nsACString& aError) { + RefPtr gl = RenderThread::Get()->SingletonGL(aError); + if (!gl) { + if (aError.IsEmpty()) { + aError.Assign("RcANGLE(no shared GL)"_ns); + } else { + aError.Append("(Create)"_ns); + } + return nullptr; + } + + UniquePtr compositor = + MakeUnique(aWidget, std::move(gl)); + if (!compositor->Initialize(aError)) { + return nullptr; + } + return compositor; +} + +RenderCompositorANGLE::RenderCompositorANGLE( + const RefPtr& aWidget, + RefPtr&& aGL) + : RenderCompositor(aWidget), mGL(aGL) { + MOZ_ASSERT(mGL); + LOG("RenderCompositorANGLE::RenderCompositorANGLE()"); +} + +RenderCompositorANGLE::~RenderCompositorANGLE() { + LOG("RenderCompositorANGLE::~RenderCompositorANGLE()"); + + DestroyEGLSurface(); + MOZ_ASSERT(!mEGLSurface); +} + +ID3D11Device* RenderCompositorANGLE::GetDeviceOfEGLDisplay(nsACString& aError) { + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + MOZ_ASSERT(egl); + if (!egl || + !egl->mLib->IsExtensionSupported(gl::EGLLibExtension::EXT_device_query)) { + aError.Assign("RcANGLE(no EXT_device_query support)"_ns); + return nullptr; + } + + // Fetch the D3D11 device. + EGLDeviceEXT eglDevice = nullptr; + egl->fQueryDisplayAttribEXT(LOCAL_EGL_DEVICE_EXT, (EGLAttrib*)&eglDevice); + MOZ_ASSERT(eglDevice); + ID3D11Device* device = nullptr; + egl->mLib->fQueryDeviceAttribEXT(eglDevice, LOCAL_EGL_D3D11_DEVICE_ANGLE, + (EGLAttrib*)&device); + if (!device) { + aError.Assign("RcANGLE(get D3D11Device from EGLDisplay failed)"_ns); + return nullptr; + } + return device; +} + +bool RenderCompositorANGLE::Initialize(nsACString& aError) { + // TODO(aosmond): This causes us to lose WebRender because it is unable to + // distinguish why we failed and retry once the reset is complete. This does + // appear to happen in the wild, so we really should try to do something + // differently here. + if (RenderThread::Get()->IsHandlingDeviceReset()) { + aError.Assign("RcANGLE(waiting device reset)"_ns); + return false; + } + + // Force enable alpha channel to make sure ANGLE use correct framebuffer + // formart + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + if (!gl::CreateConfig(*egl, &mEGLConfig, /* bpp */ 32, + /* enableDepthBuffer */ false, mGL->IsGLES())) { + aError.Assign("RcANGLE(create EGLConfig failed)"_ns); + return false; + } + MOZ_ASSERT(mEGLConfig); + + mDevice = GetDeviceOfEGLDisplay(aError); + + if (!mDevice) { + return false; + } + + mDevice->GetImmediateContext(getter_AddRefs(mCtx)); + if (!mCtx) { + aError.Assign("RcANGLE(get immediate context failed)"_ns); + return false; + } + + // Disable native compositor when fast snapshot is needed. + // Taking snapshot of native compositor is very slow on Windows. + if (mWidget->GetCompositorOptions().NeedFastSnaphot()) { + mUseNativeCompositor = false; + } + + // Create DCLayerTree when DirectComposition is used. + if (gfx::gfxVars::UseWebRenderDCompWin()) { + HWND compositorHwnd = GetCompositorHwnd(); + if (compositorHwnd) { + mDCLayerTree = DCLayerTree::Create(mGL, mEGLConfig, mDevice, mCtx, + compositorHwnd, aError); + if (!mDCLayerTree) { + return false; + } + } else { + aError.Assign("RcANGLE(no compositor window)"_ns); + return false; + } + } + + // Create SwapChain when compositor is not used + if (!UseCompositor()) { + if (!CreateSwapChain(aError)) { + // SwapChain creation failed. + return false; + } + } + + mSyncObject = layers::SyncObjectHost::CreateSyncObjectHost(mDevice); + if (!mSyncObject->Init()) { + // Some errors occur. Clear the mSyncObject here. + // Then, there will be no texture synchronization. + aError.Assign("RcANGLE(create SyncObject failed)"_ns); + return false; + } + + InitializeUsePartialPresent(); + + return true; +} + +HWND RenderCompositorANGLE::GetCompositorHwnd() { + HWND hwnd = 0; + + if (XRE_IsGPUProcess()) { + hwnd = mWidget->AsWindows()->GetCompositorHwnd(); + } else if ( + StaticPrefs:: + gfx_webrender_enabled_no_gpu_process_with_angle_win_AtStartup()) { + MOZ_ASSERT(XRE_IsParentProcess()); + + // When GPU process does not exist, we do not need to use compositor window. + hwnd = mWidget->AsWindows()->GetHwnd(); + } + + return hwnd; +} + +bool RenderCompositorANGLE::CreateSwapChain(nsACString& aError) { + MOZ_ASSERT(!UseCompositor()); + + mFirstPresent = true; + HWND hwnd = mWidget->AsWindows()->GetHwnd(); + + RefPtr dxgiDevice; + mDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice)); + + RefPtr dxgiFactory; + { + RefPtr adapter; + dxgiDevice->GetAdapter(getter_AddRefs(adapter)); + + adapter->GetParent( + IID_PPV_ARGS((IDXGIFactory**)getter_AddRefs(dxgiFactory))); + } + + RefPtr dxgiFactory2; + HRESULT hr = dxgiFactory->QueryInterface( + (IDXGIFactory2**)getter_AddRefs(dxgiFactory2)); + if (FAILED(hr)) { + dxgiFactory2 = nullptr; + } + + CreateSwapChainForDCompIfPossible(dxgiFactory2); + if (gfx::gfxVars::UseWebRenderDCompWin() && !mSwapChain) { + MOZ_ASSERT(GetCompositorHwnd()); + aError.Assign("RcANGLE(create swapchain for dcomp failed)"_ns); + return false; + } + + if (!mSwapChain && dxgiFactory2) { + RefPtr swapChain1; + bool useTripleBuffering = false; + + DXGI_SWAP_CHAIN_DESC1 desc{}; + desc.Width = 0; + desc.Height = 0; + desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + + bool useFlipSequential = gfx::gfxVars::UseWebRenderFlipSequentialWin(); + if (useFlipSequential && !mWidget->AsWindows()->GetCompositorHwnd()) { + useFlipSequential = false; + gfxCriticalNoteOnce << "FLIP_SEQUENTIAL needs CompositorHwnd. Fallback"; + } + + if (useFlipSequential) { + useTripleBuffering = gfx::gfxVars::UseWebRenderTripleBufferingWin(); + if (useTripleBuffering) { + desc.BufferCount = 3; + } else { + desc.BufferCount = 2; + } + desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + desc.Scaling = DXGI_SCALING_NONE; + } else { + desc.BufferCount = 1; + desc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; + desc.Scaling = DXGI_SCALING_STRETCH; + } + desc.Flags = 0; + + hr = dxgiFactory2->CreateSwapChainForHwnd( + mDevice, hwnd, &desc, nullptr, nullptr, getter_AddRefs(swapChain1)); + if (SUCCEEDED(hr) && swapChain1) { + DXGI_RGBA color = {1.0f, 1.0f, 1.0f, 1.0f}; + swapChain1->SetBackgroundColor(&color); + mSwapChain = swapChain1; + mSwapChain1 = swapChain1; + mUseTripleBuffering = useTripleBuffering; + } else if (useFlipSequential) { + gfxCriticalNoteOnce << "FLIP_SEQUENTIAL is not supported. Fallback"; + } + } + + if (!mSwapChain) { + if (mWidget->AsWindows()->GetCompositorHwnd()) { + // Destroy compositor window. + mWidget->AsWindows()->DestroyCompositorWindow(); + hwnd = mWidget->AsWindows()->GetHwnd(); + } + + DXGI_SWAP_CHAIN_DESC swapDesc{}; + swapDesc.BufferDesc.Width = 0; + swapDesc.BufferDesc.Height = 0; + swapDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + swapDesc.BufferDesc.RefreshRate.Numerator = 60; + swapDesc.BufferDesc.RefreshRate.Denominator = 1; + swapDesc.SampleDesc.Count = 1; + swapDesc.SampleDesc.Quality = 0; + swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapDesc.BufferCount = 1; + swapDesc.OutputWindow = hwnd; + swapDesc.Windowed = TRUE; + swapDesc.Flags = 0; + swapDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; + + HRESULT hr = dxgiFactory->CreateSwapChain(dxgiDevice, &swapDesc, + getter_AddRefs(mSwapChain)); + if (FAILED(hr)) { + aError.Assign( + nsPrintfCString("RcANGLE(swap chain create failed %lx)", hr)); + return false; + } + + RefPtr swapChain1; + hr = mSwapChain->QueryInterface( + (IDXGISwapChain1**)getter_AddRefs(swapChain1)); + if (SUCCEEDED(hr)) { + mSwapChain1 = swapChain1; + } + } + + // We need this because we don't want DXGI to respond to Alt+Enter. + dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_WINDOW_CHANGES); + + if (!ResizeBufferIfNeeded()) { + aError.Assign("RcANGLE(resize buffer failed)"_ns); + return false; + } + + return true; +} + +void RenderCompositorANGLE::CreateSwapChainForDCompIfPossible( + IDXGIFactory2* aDXGIFactory2) { + if (!aDXGIFactory2 || !mDCLayerTree) { + return; + } + + HWND hwnd = GetCompositorHwnd(); + if (!hwnd) { + // When DirectComposition or DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL is used, + // compositor window needs to exist. + if (gfx::gfxVars::UseWebRenderDCompWin() || + gfx::gfxVars::UseWebRenderFlipSequentialWin()) { + gfxCriticalNote << "Compositor window was not created"; + } + return; + } + + // When compositor is enabled, CompositionSurface is used for rendering. + // It does not support triple buffering. + bool useTripleBuffering = + gfx::gfxVars::UseWebRenderTripleBufferingWin() && !UseCompositor(); + RefPtr swapChain1 = + CreateSwapChainForDComp(useTripleBuffering); + if (swapChain1) { + mSwapChain = swapChain1; + mSwapChain1 = swapChain1; + mUseTripleBuffering = useTripleBuffering; + mDCLayerTree->SetDefaultSwapChain(swapChain1); + } else { + // Clear CLayerTree on falire + mDCLayerTree = nullptr; + } +} + +RefPtr RenderCompositorANGLE::CreateSwapChainForDComp( + bool aUseTripleBuffering) { + HRESULT hr; + RefPtr dxgiDevice; + mDevice->QueryInterface((IDXGIDevice**)getter_AddRefs(dxgiDevice)); + + RefPtr dxgiFactory; + { + RefPtr adapter; + dxgiDevice->GetAdapter(getter_AddRefs(adapter)); + + adapter->GetParent( + IID_PPV_ARGS((IDXGIFactory**)getter_AddRefs(dxgiFactory))); + } + + RefPtr dxgiFactory2; + hr = dxgiFactory->QueryInterface( + (IDXGIFactory2**)getter_AddRefs(dxgiFactory2)); + if (FAILED(hr)) { + return nullptr; + } + + RefPtr swapChain1; + DXGI_SWAP_CHAIN_DESC1 desc{}; + // DXGI does not like 0x0 swapchains. Swap chain creation failed when 0x0 was + // set. + desc.Width = 1; + desc.Height = 1; + desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + if (aUseTripleBuffering) { + desc.BufferCount = 3; + } else { + desc.BufferCount = 2; + } + // DXGI_SCALING_NONE caused swap chain creation failure. + desc.Scaling = DXGI_SCALING_STRETCH; + desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; + desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE; + desc.Flags = 0; + + hr = dxgiFactory2->CreateSwapChainForComposition(mDevice, &desc, nullptr, + getter_AddRefs(swapChain1)); + if (SUCCEEDED(hr) && swapChain1) { + DXGI_RGBA color = {1.0f, 1.0f, 1.0f, 1.0f}; + swapChain1->SetBackgroundColor(&color); + return swapChain1; + } + + return nullptr; +} + +bool RenderCompositorANGLE::BeginFrame() { + mWidget->AsWindows()->UpdateCompositorWndSizeIfNecessary(); + + if (!UseCompositor() && !ResizeBufferIfNeeded()) { + return false; + } + + if (!MakeCurrent()) { + gfxCriticalNote << "Failed to make render context current, can't draw."; + return false; + } + + if (RenderThread::Get()->SyncObjectNeeded() && mSyncObject) { + if (!mSyncObject->Synchronize(/* aFallible */ true)) { + // It's timeout or other error. Handle the device-reset here. + RenderThread::Get()->HandleDeviceReset( + "SyncObject", LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB); + return false; + } + } + return true; +} + +RenderedFrameId RenderCompositorANGLE::EndFrame( + const nsTArray& aDirtyRects) { + RenderedFrameId frameId = GetNextRenderFrameId(); + InsertGraphicsCommandsFinishedWaitQuery(frameId); + + if (!UseCompositor()) { + auto start = TimeStamp::Now(); + if (mWidget->AsWindows()->HasFxrOutputHandler()) { + // There is a Firefox Reality handler for this swapchain. Update this + // window's contents to the VR window. + FxROutputHandler* fxrHandler = + mWidget->AsWindows()->GetFxrOutputHandler(); + if (fxrHandler->TryInitialize(mSwapChain, mDevice)) { + fxrHandler->UpdateOutput(mCtx); + } + } + + const UINT interval = + mFirstPresent || + StaticPrefs:: + gfx_webrender_dcomp_video_swap_chain_present_interval_0() + ? 0 + : 1; + const UINT flags = 0; + + const LayoutDeviceIntSize& bufferSize = mBufferSize.ref(); + if (mUsePartialPresent && mSwapChain1) { + // Clear full render flag. + mFullRender = false; + // If there is no diry rect, we skip SwapChain present. + if (!aDirtyRects.IsEmpty()) { + int rectsCount = 0; + StackArray rects(aDirtyRects.Length()); + + for (size_t i = 0; i < aDirtyRects.Length(); ++i) { + const DeviceIntRect& rect = aDirtyRects[i]; + // Clip rect to bufferSize + int left = std::max(0, std::min(rect.min.x, bufferSize.width)); + int top = std::max(0, std::min(rect.min.y, bufferSize.height)); + int right = std::max(0, std::min(rect.max.x, bufferSize.width)); + int bottom = std::max(0, std::min(rect.max.y, bufferSize.height)); + + // When rect is not empty, the rect could be passed to Present1(). + if (left < right && top < bottom) { + rects[rectsCount].left = left; + rects[rectsCount].top = top; + rects[rectsCount].right = right; + rects[rectsCount].bottom = bottom; + rectsCount++; + } + } + + if (rectsCount > 0) { + DXGI_PRESENT_PARAMETERS params; + PodZero(¶ms); + params.DirtyRectsCount = rectsCount; + params.pDirtyRects = rects.data(); + + HRESULT hr; + hr = mSwapChain1->Present1(interval, flags, ¶ms); + if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) { + gfxCriticalNote << "Present1 failed: " << gfx::hexa(hr); + mFullRender = true; + } + } + } + } else { + mSwapChain->Present(interval, flags); + } + auto end = TimeStamp::Now(); + mozilla::Telemetry::Accumulate(mozilla::Telemetry::COMPOSITE_SWAP_TIME, + (end - start).ToMilliseconds() * 10.); + + if (mFirstPresent && mDCLayerTree) { + // Wait for the GPU to finish executing its commands before + // committing the DirectComposition tree, or else the swapchain + // may flicker black when it's first presented. + RefPtr dxgiDevice2; + mDevice->QueryInterface((IDXGIDevice2**)getter_AddRefs(dxgiDevice2)); + MOZ_ASSERT(dxgiDevice2); + + HANDLE event = ::CreateEvent(nullptr, false, false, nullptr); + HRESULT hr = dxgiDevice2->EnqueueSetEvent(event); + if (SUCCEEDED(hr)) { + DebugOnly result = ::WaitForSingleObject(event, INFINITE); + MOZ_ASSERT(result == WAIT_OBJECT_0); + } else { + gfxCriticalNoteOnce << "EnqueueSetEvent failed: " << gfx::hexa(hr); + } + ::CloseHandle(event); + } + mFirstPresent = false; + } + + if (mDisablingNativeCompositor) { + // During disabling native compositor, we need to wait all gpu tasks + // complete. Otherwise, rendering window could cause white flash. + WaitForPreviousGraphicsCommandsFinishedQuery(/* aWaitAll */ true); + mDisablingNativeCompositor = false; + } + + if (mDCLayerTree) { + mDCLayerTree->MaybeUpdateDebug(); + mDCLayerTree->MaybeCommit(); + } + + return frameId; +} + +bool RenderCompositorANGLE::WaitForGPU() { + // Note: this waits on the query we inserted in the previous frame, + // not the one we just inserted now. Example: + // Insert query #1 + // Present #1 + // (first frame, no wait) + // Insert query #2 + // Present #2 + // Wait for query #1. + // Insert query #3 + // Present #3 + // Wait for query #2. + // + // This ensures we're done reading textures before swapping buffers. + if (!StaticPrefs::gfx_webrender_wait_gpu_finished_disabled_AtStartup()) { + return WaitForPreviousGraphicsCommandsFinishedQuery(); + } + return true; +} + +bool RenderCompositorANGLE::ResizeBufferIfNeeded() { + MOZ_ASSERT(mSwapChain); + + LayoutDeviceIntSize size = mWidget->GetClientSize(); + + // DXGI does not like 0x0 swapchains. ResizeBuffers() failed when 0x0 was set + // when DComp is used. + size.width = std::max(size.width, 1); + size.height = std::max(size.height, 1); + + if (mBufferSize.isSome() && mBufferSize.ref() == size) { + MOZ_ASSERT(mEGLSurface); + return true; + } + + // Release EGLSurface of back buffer before calling ResizeBuffers(). + DestroyEGLSurface(); + + mBufferSize = Some(size); + + if (!CreateEGLSurface()) { + mBufferSize.reset(); + return false; + } + + if (mUsePartialPresent) { + mFullRender = true; + } + return true; +} + +bool RenderCompositorANGLE::CreateEGLSurface() { + MOZ_ASSERT(mBufferSize.isSome()); + MOZ_ASSERT(mEGLSurface == EGL_NO_SURFACE); + + HRESULT hr; + RefPtr backBuf; + + if (mBufferSize.isNothing()) { + gfxCriticalNote << "Buffer size is invalid"; + return false; + } + + const LayoutDeviceIntSize& size = mBufferSize.ref(); + + // Resize swap chain + DXGI_SWAP_CHAIN_DESC desc; + hr = mSwapChain->GetDesc(&desc); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to read swap chain description: " + << gfx::hexa(hr) << " Size : " << size; + return false; + } + hr = mSwapChain->ResizeBuffers(desc.BufferCount, size.width, size.height, + DXGI_FORMAT_B8G8R8A8_UNORM, 0); + if (FAILED(hr)) { + gfxCriticalNote << "Failed to resize swap chain buffers: " << gfx::hexa(hr) + << " Size : " << size; + return false; + } + + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), + (void**)getter_AddRefs(backBuf)); + if (hr == DXGI_ERROR_INVALID_CALL) { + // This happens on some GPUs/drivers when there's a TDR. + if (mDevice->GetDeviceRemovedReason() != S_OK) { + gfxCriticalError() << "GetBuffer returned invalid call: " << gfx::hexa(hr) + << " Size : " << size; + return false; + } + } + + const EGLint pbuffer_attribs[]{LOCAL_EGL_WIDTH, size.width, LOCAL_EGL_HEIGHT, + size.height, LOCAL_EGL_NONE}; + + const auto buffer = reinterpret_cast(backBuf.get()); + + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + const EGLSurface surface = egl->fCreatePbufferFromClientBuffer( + LOCAL_EGL_D3D_TEXTURE_ANGLE, buffer, mEGLConfig, pbuffer_attribs); + + if (!surface) { + EGLint err = egl->mLib->fGetError(); + gfxCriticalError() << "Failed to create Pbuffer of back buffer error: " + << gfx::hexa(err) << " Size : " << size; + return false; + } + + mEGLSurface = surface; + + return true; +} + +void RenderCompositorANGLE::DestroyEGLSurface() { + // Release EGLSurface of back buffer before calling ResizeBuffers(). + if (mEGLSurface) { + const auto& gle = gl::GLContextEGL::Cast(gl()); + const auto& egl = gle->mEgl; + gle->SetEGLSurfaceOverride(EGL_NO_SURFACE); + egl->fDestroySurface(mEGLSurface); + mEGLSurface = nullptr; + } +} + +void RenderCompositorANGLE::Pause() {} + +bool RenderCompositorANGLE::Resume() { return true; } + +void RenderCompositorANGLE::Update() { + // Update compositor window's size if it exists. + // It needs to be called here, since OS might update compositor + // window's size at unexpected timing. + mWidget->AsWindows()->UpdateCompositorWndSizeIfNecessary(); +} + +bool RenderCompositorANGLE::MakeCurrent() { + gl::GLContextEGL::Cast(gl())->SetEGLSurfaceOverride(mEGLSurface); + return gl()->MakeCurrent(); +} + +LayoutDeviceIntSize RenderCompositorANGLE::GetBufferSize() { + if (!UseCompositor()) { + MOZ_ASSERT(mBufferSize.isSome()); + if (mBufferSize.isNothing()) { + return LayoutDeviceIntSize(); + } + return mBufferSize.ref(); + } else { + auto size = mWidget->GetClientSize(); + // This size is used for WR DEBUG_OVERLAY. Its DCTile does not like 0. + size.width = std::max(size.width, 1); + size.height = std::max(size.height, 1); + return size; + } +} + +RefPtr RenderCompositorANGLE::GetD3D11Query() { + RefPtr query; + + if (mRecycledQuery) { + query = mRecycledQuery.forget(); + return query; + } + + CD3D11_QUERY_DESC desc(D3D11_QUERY_EVENT); + HRESULT hr = mDevice->CreateQuery(&desc, getter_AddRefs(query)); + if (FAILED(hr) || !query) { + gfxWarning() << "Could not create D3D11_QUERY_EVENT: " << gfx::hexa(hr); + return nullptr; + } + return query; +} + +void RenderCompositorANGLE::InsertGraphicsCommandsFinishedWaitQuery( + RenderedFrameId aFrameId) { + RefPtr query; + query = GetD3D11Query(); + if (!query) { + return; + } + + mCtx->End(query); + mCtx->Flush(); + mWaitForPresentQueries.emplace(aFrameId, query); +} + +bool RenderCompositorANGLE::WaitForPreviousGraphicsCommandsFinishedQuery( + bool aWaitAll) { + size_t waitLatency = mUseTripleBuffering ? 3 : 2; + if (aWaitAll) { + waitLatency = 1; + } + + while (mWaitForPresentQueries.size() >= waitLatency) { + auto queryPair = mWaitForPresentQueries.front(); + BOOL result; + bool ret = + layers::WaitForFrameGPUQuery(mDevice, mCtx, queryPair.second, &result); + + if (!ret) { + mWaitForPresentQueries.pop(); + return false; + } + + // Recycle query for later use. + mRecycledQuery = queryPair.second; + mLastCompletedFrameId = queryPair.first; + mWaitForPresentQueries.pop(); + } + return true; +} + +RenderedFrameId RenderCompositorANGLE::GetLastCompletedFrameId() { + while (!mWaitForPresentQueries.empty()) { + auto queryPair = mWaitForPresentQueries.front(); + if (mCtx->GetData(queryPair.second, nullptr, 0, + D3D11_ASYNC_GETDATA_DONOTFLUSH) != S_OK) { + break; + } + + mRecycledQuery = queryPair.second; + mLastCompletedFrameId = queryPair.first; + mWaitForPresentQueries.pop(); + } + + nsPrintfCString marker("Pending frames %u", + (uint32_t)mWaitForPresentQueries.size()); + PROFILER_MARKER_TEXT("GetLastCompletedFrameId", GRAPHICS, {}, marker); + + return mLastCompletedFrameId; +} + +RenderedFrameId RenderCompositorANGLE::UpdateFrameId() { + RenderedFrameId frameId = GetNextRenderFrameId(); + InsertGraphicsCommandsFinishedWaitQuery(frameId); + return frameId; +} + +GLenum RenderCompositorANGLE::IsContextLost(bool aForce) { + // glGetGraphicsResetStatus does not always work to detect timeout detection + // and recovery (TDR). On Windows, ANGLE itself is just relying upon the same + // API, so we should not need to check it separately. + auto reason = mDevice->GetDeviceRemovedReason(); + switch (reason) { + case S_OK: + return LOCAL_GL_NO_ERROR; + case DXGI_ERROR_DEVICE_REMOVED: + case DXGI_ERROR_DRIVER_INTERNAL_ERROR: + NS_WARNING("Device reset due to system / different device"); + return LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB; + case DXGI_ERROR_DEVICE_HUNG: + case DXGI_ERROR_DEVICE_RESET: + case DXGI_ERROR_INVALID_CALL: + gfxCriticalError() << "Device reset due to WR device: " + << gfx::hexa(reason); + return LOCAL_GL_GUILTY_CONTEXT_RESET_ARB; + default: + gfxCriticalError() << "Device reset with WR device unexpected reason: " + << gfx::hexa(reason); + return LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB; + } +} + +bool RenderCompositorANGLE::UseCompositor() { + if (!mUseNativeCompositor) { + return false; + } + + if (!mDCLayerTree || !gfx::gfxVars::UseWebRenderCompositor()) { + return false; + } + return true; +} + +bool RenderCompositorANGLE::SupportAsyncScreenshot() { + return !UseCompositor() && !mDisablingNativeCompositor; +} + +bool RenderCompositorANGLE::ShouldUseNativeCompositor() { + return UseCompositor(); +} + +void RenderCompositorANGLE::CompositorBeginFrame() { + mDCLayerTree->CompositorBeginFrame(); +} + +void RenderCompositorANGLE::CompositorEndFrame() { + mDCLayerTree->CompositorEndFrame(); +} + +void RenderCompositorANGLE::Bind(wr::NativeTileId aId, + wr::DeviceIntPoint* aOffset, uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) { + mDCLayerTree->Bind(aId, aOffset, aFboId, aDirtyRect, aValidRect); +} + +void RenderCompositorANGLE::Unbind() { mDCLayerTree->Unbind(); } + +void RenderCompositorANGLE::CreateSurface(wr::NativeSurfaceId aId, + wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, + bool aIsOpaque) { + mDCLayerTree->CreateSurface(aId, aVirtualOffset, aTileSize, aIsOpaque); +} + +void RenderCompositorANGLE::CreateExternalSurface(wr::NativeSurfaceId aId, + bool aIsOpaque) { + mDCLayerTree->CreateExternalSurface(aId, aIsOpaque); +} + +void RenderCompositorANGLE::DestroySurface(NativeSurfaceId aId) { + mDCLayerTree->DestroySurface(aId); +} + +void RenderCompositorANGLE::CreateTile(wr::NativeSurfaceId aId, int aX, + int aY) { + mDCLayerTree->CreateTile(aId, aX, aY); +} + +void RenderCompositorANGLE::DestroyTile(wr::NativeSurfaceId aId, int aX, + int aY) { + mDCLayerTree->DestroyTile(aId, aX, aY); +} + +void RenderCompositorANGLE::AttachExternalImage( + wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) { + mDCLayerTree->AttachExternalImage(aId, aExternalImage); +} + +void RenderCompositorANGLE::AddSurface( + wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) { + mDCLayerTree->AddSurface(aId, aTransform, aClipRect, aImageRendering); +} + +void RenderCompositorANGLE::GetCompositorCapabilities( + CompositorCapabilities* aCaps) { + RenderCompositor::GetCompositorCapabilities(aCaps); + + if (StaticPrefs::gfx_webrender_dcomp_use_virtual_surfaces_AtStartup()) { + aCaps->virtual_surface_size = VIRTUAL_SURFACE_SIZE; + } else { + aCaps->virtual_surface_size = 0; + } + // DComp video overlay does not support negative scaling. See Bug 1831820 + aCaps->supports_external_compositor_surface_negative_scaling = false; +} + +void RenderCompositorANGLE::EnableNativeCompositor(bool aEnable) { + // XXX Re-enable native compositor is not handled yet. + MOZ_RELEASE_ASSERT(!mDisablingNativeCompositor); + MOZ_RELEASE_ASSERT(!aEnable); + LOG("RenderCompositorANGLE::EnableNativeCompositor() aEnable %d", aEnable); + + if (!UseCompositor()) { + return; + } + + mUseNativeCompositor = false; + mDCLayerTree->DisableNativeCompositor(); + + DestroyEGLSurface(); + mBufferSize.reset(); + + RefPtr swapChain1 = + CreateSwapChainForDComp(mUseTripleBuffering); + if (swapChain1) { + mSwapChain = swapChain1; + mDCLayerTree->SetDefaultSwapChain(swapChain1); + ResizeBufferIfNeeded(); + } else { + gfxCriticalNote << "Failed to re-create SwapChain"; + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + return; + } + mDisablingNativeCompositor = true; +} + +void RenderCompositorANGLE::InitializeUsePartialPresent() { + // Even when mSwapChain1 is null, we could enable WR partial present, since + // when mSwapChain1 is null, SwapChain is blit model swap chain with one + // buffer. + if (UseCompositor() || mWidget->AsWindows()->HasFxrOutputHandler() || + gfx::gfxVars::WebRenderMaxPartialPresentRects() <= 0) { + mUsePartialPresent = false; + } else { + mUsePartialPresent = true; + } +} + +bool RenderCompositorANGLE::UsePartialPresent() { return mUsePartialPresent; } + +bool RenderCompositorANGLE::RequestFullRender() { return mFullRender; } + +uint32_t RenderCompositorANGLE::GetMaxPartialPresentRects() { + if (!mUsePartialPresent) { + return 0; + } + return gfx::gfxVars::WebRenderMaxPartialPresentRects(); +} + +bool RenderCompositorANGLE::MaybeReadback( + const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, bool* aNeedsYFlip) { + MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8); + + if (!UseCompositor()) { + return false; + } + + auto start = TimeStamp::Now(); + + HDC nulldc = ::GetDC(NULL); + HDC dc = ::CreateCompatibleDC(nulldc); + ::ReleaseDC(nullptr, nulldc); + if (!dc) { + gfxCriticalError() << "CreateCompatibleDC failed"; + return false; + } + + BITMAPV4HEADER header; + memset(&header, 0, sizeof(BITMAPV4HEADER)); + header.bV4Size = sizeof(BITMAPV4HEADER); + header.bV4Width = aReadbackSize.width; + header.bV4Height = -LONG(aReadbackSize.height); // top-to-buttom DIB + header.bV4Planes = 1; + header.bV4BitCount = 32; + header.bV4V4Compression = BI_BITFIELDS; + header.bV4RedMask = 0x00FF0000; + header.bV4GreenMask = 0x0000FF00; + header.bV4BlueMask = 0x000000FF; + header.bV4AlphaMask = 0xFF000000; + + void* readbackBits = nullptr; + HBITMAP bitmap = + ::CreateDIBSection(dc, reinterpret_cast(&header), + DIB_RGB_COLORS, &readbackBits, nullptr, 0); + if (!bitmap) { + ::DeleteDC(dc); + gfxCriticalError() << "CreateDIBSection failed"; + return false; + } + + ::SelectObject(dc, bitmap); + + UINT flags = PW_CLIENTONLY | PW_RENDERFULLCONTENT; + HWND hwnd = mWidget->AsWindows()->GetHwnd(); + + mDCLayerTree->WaitForCommitCompletion(); + + BOOL result = ::PrintWindow(hwnd, dc, flags); + if (!result) { + ::DeleteObject(bitmap); + ::DeleteDC(dc); + gfxCriticalError() << "PrintWindow failed"; + return false; + } + + ::GdiFlush(); + + memcpy(&aReadbackBuffer[0], readbackBits, aReadbackBuffer.length()); + + ::DeleteObject(bitmap); + ::DeleteDC(dc); + + uint32_t latencyMs = round((TimeStamp::Now() - start).ToMilliseconds()); + if (latencyMs > 500) { + gfxCriticalNote << "Readback took too long: " << latencyMs << " ms"; + } + + if (aNeedsYFlip) { + *aNeedsYFlip = false; + } + + return true; +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderCompositorANGLE.h b/gfx/webrender_bindings/RenderCompositorANGLE.h new file mode 100644 index 0000000000..29f5652b3e --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorANGLE.h @@ -0,0 +1,160 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_ANGLE_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_ANGLE_H + +#include + +#include "GLTypes.h" +#include "mozilla/Maybe.h" +#include "mozilla/webrender/RenderCompositor.h" +#include "mozilla/webrender/RenderThread.h" + +struct ID3D11DeviceContext; +struct ID3D11Device; +struct ID3D11Query; +struct IDXGIFactory2; +struct IDXGISwapChain; +struct IDXGISwapChain1; + +namespace mozilla { +namespace gl { +class GLLibraryEGL; +} // namespace gl + +namespace wr { + +class DCLayerTree; + +class RenderCompositorANGLE : public RenderCompositor { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + explicit RenderCompositorANGLE( + const RefPtr& aWidget, + RefPtr&& aGL); + virtual ~RenderCompositorANGLE(); + bool Initialize(nsACString& aError); + + bool BeginFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) final; + bool WaitForGPU() override; + RenderedFrameId GetLastCompletedFrameId() final; + RenderedFrameId UpdateFrameId() final; + void Pause() override; + bool Resume() override; + void Update() override; + + gl::GLContext* gl() const override { return mGL; } + + bool MakeCurrent() override; + + bool UseANGLE() const override { return true; } + + bool UseDComp() const override { return !!mDCLayerTree; } + + 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; + + GLenum IsContextLost(bool aForce) override; + + bool SurfaceOriginIsTopLeft() override { return true; } + + bool SupportAsyncScreenshot() override; + + bool ShouldUseNativeCompositor() override; + + // Interface for wr::Compositor + void CompositorBeginFrame() override; + void CompositorEndFrame() override; + void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) override; + void Unbind() override; + void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) override; + void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override; + void DestroySurface(NativeSurfaceId aId) override; + void CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override; + void DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override; + void AttachExternalImage(wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage) override; + void AddSurface(wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering) override; + void EnableNativeCompositor(bool aEnable) override; + void GetCompositorCapabilities(CompositorCapabilities* aCaps) override; + + // Interface for partial present + bool UsePartialPresent() override; + bool RequestFullRender() override; + uint32_t GetMaxPartialPresentRects() override; + + bool MaybeReadback(const gfx::IntSize& aReadbackSize, + const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, + bool* aNeedsYFlip) override; + + protected: + bool UseCompositor(); + void InitializeUsePartialPresent(); + void InsertGraphicsCommandsFinishedWaitQuery( + RenderedFrameId aRenderedFrameId); + bool WaitForPreviousGraphicsCommandsFinishedQuery(bool aWaitAll = false); + bool ResizeBufferIfNeeded(); + bool CreateEGLSurface(); + void DestroyEGLSurface(); + ID3D11Device* GetDeviceOfEGLDisplay(nsACString& aError); + bool CreateSwapChain(nsACString& aError); + void CreateSwapChainForDCompIfPossible(IDXGIFactory2* aDXGIFactory2); + RefPtr CreateSwapChainForDComp(bool aUseTripleBuffering); + RefPtr GetD3D11Query(); + void ReleaseNativeCompositorResources(); + HWND GetCompositorHwnd(); + + RefPtr mGL; + + EGLConfig mEGLConfig = nullptr; + EGLSurface mEGLSurface = nullptr; + + bool mUseTripleBuffering = false; + + RefPtr mDevice; + RefPtr mCtx; + RefPtr mSwapChain; + RefPtr mSwapChain1; + + UniquePtr mDCLayerTree; + + std::queue>> + mWaitForPresentQueries; + RefPtr mRecycledQuery; + RenderedFrameId mLastCompletedFrameId; + + Maybe mBufferSize; + bool mUseNativeCompositor = true; + bool mUsePartialPresent = false; + bool mFullRender = false; + // Used to know a timing of disabling native compositor. + bool mDisablingNativeCompositor = false; + bool mFirstPresent = true; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp new file mode 100644 index 0000000000..d95074e901 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.cpp @@ -0,0 +1,488 @@ +/* -*- 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 "RenderCompositorD3D11SWGL.h" + +#include "gfxConfig.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/widget/CompositorWidget.h" +#include "mozilla/layers/Effects.h" +#include "mozilla/webrender/RenderD3D11TextureHost.h" +#include "RenderCompositorRecordedFrame.h" +#include "RenderThread.h" + +namespace mozilla { +using namespace layers; + +namespace wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +RenderCompositorD3D11SWGL::UploadMode +RenderCompositorD3D11SWGL::GetUploadMode() { + int mode = StaticPrefs::gfx_webrender_software_d3d11_upload_mode(); + switch (mode) { + case 1: + return Upload_Immediate; + case 2: + return Upload_Staging; + case 3: + return Upload_StagingNoBlock; + case 4: + return Upload_StagingPooled; + default: + return Upload_Staging; + } +} + +UniquePtr RenderCompositorD3D11SWGL::Create( + const RefPtr& aWidget, nsACString& aError) { + if (!aWidget->GetCompositorOptions().AllowSoftwareWebRenderD3D11() || + !gfx::gfxConfig::IsEnabled(gfx::Feature::D3D11_COMPOSITING)) { + return nullptr; + } + + void* ctx = wr_swgl_create_context(); + if (!ctx) { + gfxCriticalNote << "Failed SWGL context creation for WebRender"; + return nullptr; + } + + RefPtr compositor = MakeAndAddRef(aWidget); + nsCString log; + if (!compositor->Initialize(&log)) { + gfxCriticalNote << "Failed to initialize CompositorD3D11 for SWGL: " + << log.get(); + return nullptr; + } + return MakeUnique(compositor, aWidget, ctx); +} + +RenderCompositorD3D11SWGL::RenderCompositorD3D11SWGL( + CompositorD3D11* aCompositor, + const RefPtr& aWidget, void* aContext) + : RenderCompositorLayersSWGL(aCompositor, aWidget, aContext) { + LOG("RenderCompositorD3D11SWGL::RenderCompositorD3D11SWGL()"); + + mSyncObject = GetCompositorD3D11()->GetSyncObject(); +} + +RenderCompositorD3D11SWGL::~RenderCompositorD3D11SWGL() { + LOG("RenderCompositorD3D11SWGL::~RenderCompositorD3D11SWGL()"); +} + +bool RenderCompositorD3D11SWGL::BeginFrame() { + if (!RenderCompositorLayersSWGL::BeginFrame()) { + return false; + } + + mUploadMode = GetUploadMode(); + return true; +} + +void RenderCompositorD3D11SWGL::HandleExternalImage( + RenderTextureHost* aExternalImage, FrameSurface& aFrameSurface) { + // We need to hold the texture source separately from the effect, + // since the effect doesn't hold a strong reference. + RefPtr layer; + RefPtr texturedEffect; + gfx::IntSize size; + if (auto* host = aExternalImage->AsRenderDXGITextureHost()) { + if (!host->EnsureD3D11Texture2D(GetDevice())) { + return; + } + + layer = new DataTextureSourceD3D11(GetDevice(), host->GetFormat(), + host->GetD3D11Texture2D()); + if (host->GetFormat() == gfx::SurfaceFormat::NV12 || + host->GetFormat() == gfx::SurfaceFormat::P010 || + host->GetFormat() == gfx::SurfaceFormat::P016) { + const auto yuv = FromYUVRangedColorSpace(host->GetYUVColorSpace()); + texturedEffect = + new EffectNV12(layer, yuv.space, yuv.range, host->GetColorDepth(), + aFrameSurface.mFilter); + } else { + MOZ_ASSERT(host->GetFormat() == gfx::SurfaceFormat::B8G8R8X8 || + host->GetFormat() == gfx::SurfaceFormat::B8G8R8A8); + texturedEffect = CreateTexturedEffect(host->GetFormat(), layer, + aFrameSurface.mFilter, true); + } + size = host->GetSize(0); + host->LockInternal(); + } else if (auto* host = aExternalImage->AsRenderDXGIYCbCrTextureHost()) { + if (!host->EnsureD3D11Texture2D(GetDevice())) { + return; + } + + layer = new DataTextureSourceD3D11(GetDevice(), gfx::SurfaceFormat::A8, + host->GetD3D11Texture2D(0)); + RefPtr u = new DataTextureSourceD3D11( + GetDevice(), gfx::SurfaceFormat::A8, host->GetD3D11Texture2D(1)); + layer->SetNextSibling(u); + RefPtr v = new DataTextureSourceD3D11( + GetDevice(), gfx::SurfaceFormat::A8, host->GetD3D11Texture2D(2)); + u->SetNextSibling(v); + + const auto yuv = FromYUVRangedColorSpace(host->GetYUVColorSpace()); + texturedEffect = + new EffectYCbCr(layer, yuv.space, yuv.range, host->GetColorDepth(), + aFrameSurface.mFilter); + size = host->GetSize(0); + host->LockInternal(); + } + + gfx::Rect drawRect(0, 0, size.width, size.height); + + EffectChain effect; + effect.mPrimaryEffect = texturedEffect; + mCompositor->DrawQuad(drawRect, aFrameSurface.mClipRect, effect, 1.0, + aFrameSurface.mTransform, drawRect); + + if (auto* host = aExternalImage->AsRenderDXGITextureHost()) { + host->Unlock(); + } else if (auto* host = aExternalImage->AsRenderDXGIYCbCrTextureHost()) { + host->Unlock(); + } +} + +void RenderCompositorD3D11SWGL::Pause() {} + +bool RenderCompositorD3D11SWGL::Resume() { return true; } + +GLenum RenderCompositorD3D11SWGL::IsContextLost(bool aForce) { + // CompositorD3D11 uses ID3D11Device for composite. The device status needs to + // be checked. + auto reason = GetDevice()->GetDeviceRemovedReason(); + switch (reason) { + case S_OK: + return LOCAL_GL_NO_ERROR; + case DXGI_ERROR_DEVICE_REMOVED: + case DXGI_ERROR_DRIVER_INTERNAL_ERROR: + NS_WARNING("Device reset due to system / different device"); + return LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB; + case DXGI_ERROR_DEVICE_HUNG: + case DXGI_ERROR_DEVICE_RESET: + case DXGI_ERROR_INVALID_CALL: + gfxCriticalError() << "Device reset due to WR device: " + << gfx::hexa(reason); + return LOCAL_GL_GUILTY_CONTEXT_RESET_ARB; + default: + gfxCriticalError() << "Device reset with WR device unexpected reason: " + << gfx::hexa(reason); + return LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB; + } +} + +UniquePtr +RenderCompositorD3D11SWGL::DoCreateSurface(wr::DeviceIntSize aTileSize, + bool aIsOpaque) { + return MakeUnique(aTileSize, aIsOpaque); +} + +SurfaceD3D11SWGL::SurfaceD3D11SWGL(wr::DeviceIntSize aTileSize, bool aIsOpaque) + : Surface(aTileSize, aIsOpaque) {} + +RenderCompositorD3D11SWGL::TileD3D11::TileD3D11( + layers::DataTextureSourceD3D11* aTexture, ID3D11Texture2D* aStagingTexture, + gfx::DataSourceSurface* aDataSourceSurface, Surface* aOwner, + RenderCompositorD3D11SWGL* aRenderCompositor) + : Tile(), + mTexture(aTexture), + mStagingTexture(aStagingTexture), + mSurface(aDataSourceSurface), + mOwner(aOwner->AsSurfaceD3D11SWGL()), + mRenderCompositor(aRenderCompositor) {} + +bool RenderCompositorD3D11SWGL::TileD3D11::Map(wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) { + const UploadMode uploadMode = mRenderCompositor->GetUploadMode(); + const gfx::IntSize tileSize = mOwner->TileSize(); + + if (!IsValid()) { + return false; + } + + // Check if this tile's upload method matches what we're using for this frame, + // and if not then reallocate to fix it. Do this before we copy the struct + // into mCurrentTile. + if (uploadMode == Upload_Immediate) { + if (mStagingTexture) { + MOZ_ASSERT(!mSurface); + mStagingTexture = nullptr; + mSurface = mRenderCompositor->CreateStagingSurface(tileSize); + } + } else { + if (mSurface) { + MOZ_ASSERT(!mStagingTexture); + mSurface = nullptr; + mStagingTexture = mRenderCompositor->CreateStagingTexture(tileSize); + } + } + + mRenderCompositor->mCurrentStagingTexture = mStagingTexture; + mRenderCompositor->mCurrentStagingTextureIsTemp = false; + + if (uploadMode == Upload_Immediate) { + gfx::DataSourceSurface::MappedSurface map; + if (!mSurface->Map(gfx::DataSourceSurface::READ_WRITE, &map)) { + return false; + } + + *aData = map.mData + aValidRect.min.y * map.mStride + aValidRect.min.x * 4; + *aStride = map.mStride; + // Ensure our mapped data is accessible by writing to the beginning and end + // of the dirty region. See bug 1717519 + if (aDirtyRect.width() > 0 && aDirtyRect.height() > 0) { + uint32_t* probeData = (uint32_t*)map.mData + + aDirtyRect.min.y * (map.mStride / 4) + + aDirtyRect.min.x; + *probeData = 0; + uint32_t* probeDataEnd = (uint32_t*)map.mData + + (aDirtyRect.max.y - 1) * (map.mStride / 4) + + (aDirtyRect.max.x - 1); + *probeDataEnd = 0; + } + + mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y, + aValidRect.width(), aValidRect.height()); + return true; + } + + if (!mRenderCompositor->mCurrentStagingTexture) { + return false; + } + + RefPtr context; + mRenderCompositor->GetDevice()->GetImmediateContext(getter_AddRefs(context)); + + D3D11_MAPPED_SUBRESOURCE mappedSubresource; + + bool shouldBlock = uploadMode == Upload_Staging; + + HRESULT hr = context->Map( + mRenderCompositor->mCurrentStagingTexture, 0, D3D11_MAP_READ_WRITE, + shouldBlock ? 0 : D3D11_MAP_FLAG_DO_NOT_WAIT, &mappedSubresource); + if (hr == DXGI_ERROR_WAS_STILL_DRAWING) { + // mCurrentTile is a copy of the real tile data, so we can just replace the + // staging one with a temporary for this draw. The staging texture for the + // real tile remains untouched, so we'll go back to using that for future + // frames and discard the new one. In the future we could improve this by + // having a pool of shared staging textures for all the tiles. + + // Mark the tile as having a temporary staging texture. + mRenderCompositor->mCurrentStagingTextureIsTemp = true; + + // Try grabbing a texture from the staging pool and see if we can use that. + if (uploadMode == Upload_StagingPooled && mOwner->mStagingPool.Length()) { + mRenderCompositor->mCurrentStagingTexture = + mOwner->mStagingPool.ElementAt(0); + mOwner->mStagingPool.RemoveElementAt(0); + hr = context->Map(mRenderCompositor->mCurrentStagingTexture, 0, + D3D11_MAP_READ_WRITE, D3D11_MAP_FLAG_DO_NOT_WAIT, + &mappedSubresource); + + // If that failed, put it back into the pool (but at the end). + if (hr == DXGI_ERROR_WAS_STILL_DRAWING) { + mOwner->mStagingPool.AppendElement( + mRenderCompositor->mCurrentStagingTexture); + } + } + + // No staging textures, or we tried one and it was busy. Allocate a brand + // new one instead. + if (hr == DXGI_ERROR_WAS_STILL_DRAWING) { + mRenderCompositor->mCurrentStagingTexture = + mRenderCompositor->CreateStagingTexture(tileSize); + if (!mRenderCompositor->mCurrentStagingTexture) { + return false; + } + hr = context->Map(mRenderCompositor->mCurrentStagingTexture, 0, + D3D11_MAP_READ_WRITE, 0, &mappedSubresource); + } + } + if (!SUCCEEDED(hr)) { + gfxCriticalError() << "Failed to map tile: " << gfx::hexa(hr); + // This is only expected to fail if we hit a device reset. + MOZ_RELEASE_ASSERT( + mRenderCompositor->GetDevice()->GetDeviceRemovedReason() != S_OK); + return false; + } + + // aData is expected to contain a pointer to the first pixel within the valid + // rect, so take the mapped resource's data (which covers the full tile size) + // and offset it by the top/left of the valid rect. + *aData = (uint8_t*)mappedSubresource.pData + + aValidRect.min.y * mappedSubresource.RowPitch + aValidRect.min.x * 4; + *aStride = mappedSubresource.RowPitch; + + // Ensure our mapped data is accessible by writing to the beginning and end + // of the dirty region. See bug 1717519 + if (aDirtyRect.width() > 0 && aDirtyRect.height() > 0) { + uint32_t* probeData = (uint32_t*)mappedSubresource.pData + + aDirtyRect.min.y * (mappedSubresource.RowPitch / 4) + + aDirtyRect.min.x; + *probeData = 0; + uint32_t* probeDataEnd = + (uint32_t*)mappedSubresource.pData + + (aDirtyRect.max.y - 1) * (mappedSubresource.RowPitch / 4) + + (aDirtyRect.max.x - 1); + *probeDataEnd = 0; + } + + // Store the new valid rect, so that we can composite only those pixels + mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y, aValidRect.width(), + aValidRect.height()); + + return true; +} + +void RenderCompositorD3D11SWGL::TileD3D11::Unmap( + const gfx::IntRect& aDirtyRect) { + const UploadMode uploadMode = mRenderCompositor->GetUploadMode(); + + if (!IsValid()) { + return; + } + + if (mSurface) { + MOZ_ASSERT(uploadMode == Upload_Immediate); + mSurface->Unmap(); + nsIntRegion dirty(aDirtyRect); + // This uses UpdateSubresource, which blocks, so is likely implemented as a + // memcpy into driver owned memory, followed by an async upload. The staging + // method should avoid this extra copy, and is likely to be faster usually. + // We could possible do this call on a background thread so that sw-wr can + // start drawing the next tile while the memcpy is in progress. + mTexture->Update(mSurface, &dirty); + return; + } + + if (!mRenderCompositor->mCurrentStagingTexture) { + return; + } + + RefPtr context; + mRenderCompositor->GetDevice()->GetImmediateContext(getter_AddRefs(context)); + + context->Unmap(mRenderCompositor->mCurrentStagingTexture, 0); + + D3D11_BOX box; + box.front = 0; + box.back = 1; + box.left = aDirtyRect.X(); + box.top = aDirtyRect.Y(); + box.right = aDirtyRect.XMost(); + box.bottom = aDirtyRect.YMost(); + + context->CopySubresourceRegion( + mTexture->GetD3D11Texture(), 0, aDirtyRect.x, aDirtyRect.y, 0, + mRenderCompositor->mCurrentStagingTexture, 0, &box); + + // If we allocated a temp staging texture for this tile, and we're running + // in pooled mode, then consider adding it to the pool for later. + if (mRenderCompositor->mCurrentStagingTextureIsTemp && + uploadMode == Upload_StagingPooled) { + static const uint32_t kMaxPoolSize = 5; + if (mOwner->mStagingPool.Length() < kMaxPoolSize) { + mOwner->mStagingPool.AppendElement( + mRenderCompositor->mCurrentStagingTexture); + } + } + + mRenderCompositor->mCurrentStagingTexture = nullptr; + mRenderCompositor->mCurrentStagingTextureIsTemp = false; +} + +bool RenderCompositorD3D11SWGL::TileD3D11::IsValid() { return !!mTexture; } + +already_AddRefed +RenderCompositorD3D11SWGL::CreateStagingTexture(const gfx::IntSize aSize) { + CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, aSize.width, + aSize.height, 1, 1); + + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ; + desc.Usage = D3D11_USAGE_STAGING; + desc.BindFlags = 0; + + RefPtr cpuTexture; + DebugOnly hr = + GetDevice()->CreateTexture2D(&desc, nullptr, getter_AddRefs(cpuTexture)); + MOZ_ASSERT(SUCCEEDED(hr)); + if (!cpuTexture) { + gfxCriticalNote << "Failed to create StagingTexture: " << aSize; + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + } + return cpuTexture.forget(); +} + +already_AddRefed +RenderCompositorD3D11SWGL::CreateStagingSurface(const gfx::IntSize aSize) { + return gfx::Factory::CreateDataSourceSurface(aSize, + gfx::SurfaceFormat::B8G8R8A8); +} + +UniquePtr +RenderCompositorD3D11SWGL::DoCreateTile(Surface* aSurface) { + MOZ_RELEASE_ASSERT(aSurface); + + const auto tileSize = aSurface->TileSize(); + + if (mUploadMode == Upload_Immediate) { + RefPtr source = + new DataTextureSourceD3D11(gfx::SurfaceFormat::B8G8R8A8, mCompositor, + layers::TextureFlags::NO_FLAGS); + RefPtr surf = CreateStagingSurface(tileSize); + return MakeUnique(source, nullptr, surf, aSurface, this); + } + + MOZ_ASSERT(mUploadMode == Upload_Staging || + mUploadMode == Upload_StagingNoBlock || + mUploadMode == Upload_StagingPooled); + + CD3D11_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, tileSize.width, + tileSize.height, 1, 1); + + RefPtr texture; + DebugOnly hr = + GetDevice()->CreateTexture2D(&desc, nullptr, getter_AddRefs(texture)); + MOZ_ASSERT(SUCCEEDED(hr)); + if (!texture) { + gfxCriticalNote << "Failed to allocate Texture2D: " << aSurface->TileSize(); + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + return MakeUnique(nullptr, nullptr, nullptr, aSurface, this); + } + + RefPtr source = new DataTextureSourceD3D11( + GetDevice(), gfx::SurfaceFormat::B8G8R8A8, texture); + + RefPtr cpuTexture = CreateStagingTexture(tileSize); + return MakeUnique(source, cpuTexture, nullptr, aSurface, this); +} + +bool RenderCompositorD3D11SWGL::MaybeReadback( + const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, bool* aNeedsYFlip) { + MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8); + + auto stride = + aReadbackSize.width * gfx::BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8); + RefPtr dt = gfx::Factory::CreateDrawTargetForData( + gfx::BackendType::SKIA, &aReadbackBuffer[0], aReadbackSize, stride, + gfx::SurfaceFormat::B8G8R8A8, false); + if (!dt) { + return false; + } + + GetCompositorD3D11()->Readback(dt); + return true; +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderCompositorD3D11SWGL.h b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.h new file mode 100644 index 0000000000..2365230f66 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorD3D11SWGL.h @@ -0,0 +1,118 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_D3D11_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_D3D11_H + +#include "mozilla/gfx/2D.h" +#include "mozilla/layers/ScreenshotGrabber.h" +#include "mozilla/layers/TextureD3D11.h" +#include "mozilla/layers/CompositorD3D11.h" +#include "mozilla/webrender/RenderCompositorLayersSWGL.h" + +namespace mozilla { + +namespace wr { + +class SurfaceD3D11SWGL; + +class RenderCompositorD3D11SWGL : public RenderCompositorLayersSWGL { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorD3D11SWGL(layers::CompositorD3D11* aCompositor, + const RefPtr& aWidget, + void* aContext); + virtual ~RenderCompositorD3D11SWGL(); + + void Pause() override; + bool Resume() override; + + GLenum IsContextLost(bool aForce) override; + + layers::WebRenderCompositor CompositorType() const override { + return layers::WebRenderCompositor::D3D11; + } + RenderCompositorD3D11SWGL* AsRenderCompositorD3D11SWGL() override { + return this; + } + + bool BeginFrame() override; + + bool MaybeReadback(const gfx::IntSize& aReadbackSize, + const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, + bool* aNeedsYFlip) override; + + layers::CompositorD3D11* GetCompositorD3D11() { + return mCompositor->AsCompositorD3D11(); + } + + ID3D11Device* GetDevice() { return GetCompositorD3D11()->GetDevice(); } + + private: + already_AddRefed CreateStagingTexture( + const gfx::IntSize aSize); + already_AddRefed CreateStagingSurface( + const gfx::IntSize aSize); + + void HandleExternalImage(RenderTextureHost* aExternalImage, + FrameSurface& aFrameSurface) override; + UniquePtr DoCreateSurface( + wr::DeviceIntSize aTileSize, bool aIsOpaque) override; + UniquePtr DoCreateTile( + Surface* aSurface) override; + + class TileD3D11 : public RenderCompositorLayersSWGL::Tile { + public: + TileD3D11(layers::DataTextureSourceD3D11* aTexture, + ID3D11Texture2D* aStagingTexture, + gfx::DataSourceSurface* aDataSourceSurface, Surface* aOwner, + RenderCompositorD3D11SWGL* aRenderCompositor); + virtual ~TileD3D11() {} + + bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) override; + void Unmap(const gfx::IntRect& aDirtyRect) override; + layers::DataTextureSource* GetTextureSource() override { return mTexture; } + bool IsValid() override; + + private: + RefPtr mTexture; + RefPtr mStagingTexture; + RefPtr mSurface; + SurfaceD3D11SWGL* mOwner; + RenderCompositorD3D11SWGL* mRenderCompositor; + }; + + enum UploadMode { + Upload_Immediate, + Upload_Staging, + Upload_StagingNoBlock, + Upload_StagingPooled + }; + UploadMode GetUploadMode(); + UploadMode mUploadMode = Upload_Staging; + + RefPtr mCurrentStagingTexture; + bool mCurrentStagingTextureIsTemp = false; +}; + +class SurfaceD3D11SWGL : public RenderCompositorLayersSWGL::Surface { + public: + SurfaceD3D11SWGL(wr::DeviceIntSize aTileSize, bool aIsOpaque); + virtual ~SurfaceD3D11SWGL() {} + + SurfaceD3D11SWGL* AsSurfaceD3D11SWGL() override { return this; } + + nsTArray> mStagingPool; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorEGL.cpp b/gfx/webrender_bindings/RenderCompositorEGL.cpp new file mode 100644 index 0000000000..ccabfd375f --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorEGL.cpp @@ -0,0 +1,325 @@ +/* -*- 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 "RenderCompositorEGL.h" + +#include "GLContext.h" +#include "GLContextEGL.h" +#include "GLContextProvider.h" +#include "GLLibraryEGL.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/layers/BuildConstants.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/widget/CompositorWidget.h" + +#ifdef MOZ_WIDGET_GTK +# include "mozilla/WidgetUtilsGtk.h" +# include "mozilla/widget/GtkCompositorWidget.h" +#endif + +#ifdef MOZ_WIDGET_ANDROID +# include "mozilla/java/GeckoSurfaceTextureWrappers.h" +# include "mozilla/layers/AndroidHardwareBuffer.h" +# include "mozilla/widget/AndroidCompositorWidget.h" +# include +# include +#endif + +namespace mozilla::wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +/* static */ +UniquePtr RenderCompositorEGL::Create( + const RefPtr& aWidget, nsACString& aError) { + if (kIsLinux && !gfx::gfxVars::UseEGL()) { + return nullptr; + } + RefPtr gl = RenderThread::Get()->SingletonGL(aError); + if (!gl) { + if (aError.IsEmpty()) { + aError.Assign("RcANGLE(no shared GL)"_ns); + } else { + aError.Append("(Create)"_ns); + } + return nullptr; + } + return MakeUnique(aWidget, std::move(gl)); +} + +EGLSurface RenderCompositorEGL::CreateEGLSurface() { + EGLSurface surface = EGL_NO_SURFACE; + surface = gl::GLContextEGL::CreateEGLSurfaceForCompositorWidget( + mWidget, gl::GLContextEGL::Cast(gl())->mSurfaceConfig); + if (surface == EGL_NO_SURFACE) { + const auto* renderThread = RenderThread::Get(); + gfxCriticalNote << "Failed to create EGLSurface. " + << renderThread->RendererCount() << " renderers, " + << renderThread->ActiveRendererCount() << " active."; + } + return surface; +} + +RenderCompositorEGL::RenderCompositorEGL( + const RefPtr& aWidget, + RefPtr&& aGL) + : RenderCompositor(aWidget), mGL(aGL), mEGLSurface(EGL_NO_SURFACE) { + MOZ_ASSERT(mGL); + LOG("RenderCompositorEGL::RenderCompositorEGL()"); +} + +RenderCompositorEGL::~RenderCompositorEGL() { + LOG("RenderCompositorEGL::~RenderCompositorEGL()"); +#ifdef MOZ_WIDGET_ANDROID + java::GeckoSurfaceTexture::DestroyUnused((int64_t)gl()); +#endif + DestroyEGLSurface(); +} + +bool RenderCompositorEGL::BeginFrame() { + if (kIsLinux && mEGLSurface == EGL_NO_SURFACE) { + gfxCriticalNote + << "We don't have EGLSurface to draw into. Called too early?"; + return false; + } +#ifdef MOZ_WIDGET_GTK + if (mWidget->AsGTK()) { + if (!mWidget->AsGTK()->SetEGLNativeWindowSize(GetBufferSize())) { + // It's possible that GtkWidget is hidden on Wayland; e.g. maybe it's + // just been closed. So, we can't draw into it right now. + return false; + } + } +#endif + if (!MakeCurrent()) { + gfxCriticalNote << "Failed to make render context current, can't draw."; + return false; + } + +#ifdef MOZ_WIDGET_ANDROID + java::GeckoSurfaceTexture::DestroyUnused((int64_t)gl()); + gl()->MakeCurrent(); // DestroyUnused can change the current context! +#endif + + return true; +} + +RenderedFrameId RenderCompositorEGL::EndFrame( + const nsTArray& aDirtyRects) { +#ifdef MOZ_WIDGET_ANDROID + const auto& gle = gl::GLContextEGL::Cast(gl()); + const auto& egl = gle->mEgl; + + EGLSync sync = nullptr; + if (layers::AndroidHardwareBufferApi::Get()) { + sync = egl->fCreateSync(LOCAL_EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr); + } + if (sync) { + int fenceFd = egl->fDupNativeFenceFDANDROID(sync); + if (fenceFd >= 0) { + mReleaseFenceFd = ipc::FileDescriptor(UniqueFileHandle(fenceFd)); + } + egl->fDestroySync(sync); + sync = nullptr; + } +#endif + + RenderedFrameId frameId = GetNextRenderFrameId(); +#ifdef MOZ_WIDGET_GTK + if (mWidget->IsHidden()) { + return frameId; + } +#endif + if (mEGLSurface != EGL_NO_SURFACE && aDirtyRects.Length() > 0) { + gfx::IntRegion bufferInvalid; + const auto bufferSize = GetBufferSize(); + for (const DeviceIntRect& rect : aDirtyRects) { + const auto left = std::max(0, std::min(bufferSize.width, rect.min.x)); + const auto top = std::max(0, std::min(bufferSize.height, rect.min.y)); + + const auto right = std::min(bufferSize.width, std::max(0, rect.max.x)); + const auto bottom = std::min(bufferSize.height, std::max(0, rect.max.y)); + + const auto width = right - left; + const auto height = bottom - top; + + bufferInvalid.OrWith( + gfx::IntRect(left, (GetBufferSize().height - bottom), width, height)); + } + gl()->SetDamage(bufferInvalid); + } + gl()->SwapBuffers(); + return frameId; +} + +void RenderCompositorEGL::Pause() { DestroyEGLSurface(); } + +bool RenderCompositorEGL::Resume() { + if (kIsAndroid) { + // Destroy EGLSurface if it exists. + DestroyEGLSurface(); + + auto size = GetBufferSize(); + GLint maxTextureSize = 0; + gl()->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, (GLint*)&maxTextureSize); + + // When window size is too big, hardware buffer allocation could fail. + if (maxTextureSize < size.width || maxTextureSize < size.height) { + gfxCriticalNote << "Too big ANativeWindow size(" << size.width << ", " + << size.height << ") MaxTextureSize " << maxTextureSize; + return false; + } + + mEGLSurface = CreateEGLSurface(); + if (mEGLSurface == EGL_NO_SURFACE) { + // Often when we fail to create an EGL surface it is because the Java + // Surface we have been provided is invalid. Therefore the on the first + // occurence we don't raise a WebRenderError and instead just return + // failure. This allows the widget a chance to request a new Java + // Surface. On subsequent failures, raising the WebRenderError will + // result in the compositor being recreated, falling back through + // webrender configurations, and eventually crashing if we still do not + // succeed. + if (!mHandlingNewSurfaceError) { + mHandlingNewSurfaceError = true; + } else { + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + } + return false; + } + mHandlingNewSurfaceError = false; + + gl::GLContextEGL::Cast(gl())->SetEGLSurfaceOverride(mEGLSurface); + } else if (kIsLinux) { + // Destroy EGLSurface if it exists and create a new one. We will set the + // swap interval after MakeCurrent() has been called. + DestroyEGLSurface(); + mEGLSurface = CreateEGLSurface(); + if (mEGLSurface != EGL_NO_SURFACE) { + // We have a new EGL surface, which on wayland needs to be configured for + // non-blocking buffer swaps. We need MakeCurrent() to set our current EGL + // context before we call eglSwapInterval, which is why we do it here + // rather than where the surface was created. + const auto& gle = gl::GLContextEGL::Cast(gl()); + const auto& egl = gle->mEgl; + MakeCurrent(); + + const int interval = gfx::gfxVars::SwapIntervalEGL() ? 1 : 0; + egl->fSwapInterval(interval); + } else { + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + return false; + } + } + return true; +} + +bool RenderCompositorEGL::IsPaused() { return mEGLSurface == EGL_NO_SURFACE; } + +bool RenderCompositorEGL::MakeCurrent() { + const auto& gle = gl::GLContextEGL::Cast(gl()); + + gle->SetEGLSurfaceOverride(mEGLSurface); + bool ok = gl()->MakeCurrent(); + if (!gl()->IsGLES() && ok && mEGLSurface != EGL_NO_SURFACE) { + // If we successfully made a surface current, set the draw buffer + // appropriately. It's not well-defined by the EGL spec whether + // eglMakeCurrent should do this automatically. See bug 1646135. + gl()->fDrawBuffer(gl()->IsDoubleBuffered() ? LOCAL_GL_BACK + : LOCAL_GL_FRONT); + } + return ok; +} + +void RenderCompositorEGL::DestroyEGLSurface() { + const auto& gle = gl::GLContextEGL::Cast(gl()); + const auto& egl = gle->mEgl; + + // Release EGLSurface of back buffer before calling ResizeBuffers(). + if (mEGLSurface) { + gle->SetEGLSurfaceOverride(EGL_NO_SURFACE); + gl::GLContextEGL::DestroySurface(*egl, mEGLSurface); + mEGLSurface = nullptr; + } +} + +ipc::FileDescriptor RenderCompositorEGL::GetAndResetReleaseFence() { +#ifdef MOZ_WIDGET_ANDROID + MOZ_ASSERT(!layers::AndroidHardwareBufferApi::Get() || + mReleaseFenceFd.IsValid()); + return std::move(mReleaseFenceFd); +#else + return ipc::FileDescriptor(); +#endif +} + +LayoutDeviceIntSize RenderCompositorEGL::GetBufferSize() { + return mWidget->GetClientSize(); +} + +bool RenderCompositorEGL::UsePartialPresent() { + return gfx::gfxVars::WebRenderMaxPartialPresentRects() > 0; +} + +bool RenderCompositorEGL::RequestFullRender() { return false; } + +uint32_t RenderCompositorEGL::GetMaxPartialPresentRects() { + return gfx::gfxVars::WebRenderMaxPartialPresentRects(); +} + +bool RenderCompositorEGL::ShouldDrawPreviousPartialPresentRegions() { + return true; +} + +size_t RenderCompositorEGL::GetBufferAge() const { + if (!StaticPrefs:: + gfx_webrender_allow_partial_present_buffer_age_AtStartup()) { + return 0; + } + return gl()->GetBufferAge(); +} + +void RenderCompositorEGL::SetBufferDamageRegion(const wr::DeviceIntRect* aRects, + size_t aNumRects) { + const auto& gle = gl::GLContextEGL::Cast(gl()); + const auto& egl = gle->mEgl; + if (gle->HasKhrPartialUpdate() && + StaticPrefs::gfx_webrender_allow_partial_present_buffer_age_AtStartup()) { + std::vector rects; + rects.reserve(4 * aNumRects); + const auto bufferSize = GetBufferSize(); + for (size_t i = 0; i < aNumRects; i++) { + const auto left = + std::max(0, std::min(bufferSize.width, aRects[i].min.x)); + const auto top = + std::max(0, std::min(bufferSize.height, aRects[i].min.y)); + + const auto right = + std::min(bufferSize.width, std::max(0, aRects[i].max.x)); + const auto bottom = + std::min(bufferSize.height, std::max(0, aRects[i].max.y)); + + const auto width = right - left; + const auto height = bottom - top; + + rects.push_back(left); + rects.push_back(bufferSize.height - bottom); + rects.push_back(width); + rects.push_back(height); + } + const auto ret = + egl->fSetDamageRegion(mEGLSurface, rects.data(), rects.size() / 4); + if (ret == LOCAL_EGL_FALSE) { + const auto err = egl->mLib->fGetError(); + gfxCriticalError() << "Error in eglSetDamageRegion: " << gfx::hexa(err); + } + } +} + +} // namespace mozilla::wr diff --git a/gfx/webrender_bindings/RenderCompositorEGL.h b/gfx/webrender_bindings/RenderCompositorEGL.h new file mode 100644 index 0000000000..8e851b2fc0 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorEGL.h @@ -0,0 +1,75 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_EGL_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_EGL_H + +#include "GLTypes.h" +#include "mozilla/webrender/RenderCompositor.h" + +namespace mozilla { + +namespace wr { + +class RenderCompositorEGL : public RenderCompositor { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + explicit RenderCompositorEGL(const RefPtr& aWidget, + RefPtr&& aGL); + virtual ~RenderCompositorEGL(); + + bool BeginFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) final; + void Pause() override; + bool Resume() override; + bool IsPaused() override; + + gl::GLContext* gl() const override { return mGL; } + + bool MakeCurrent() override; + + bool UseANGLE() const override { return false; } + + LayoutDeviceIntSize GetBufferSize() override; + + // Interface for partial present + bool UsePartialPresent() override; + bool RequestFullRender() override; + uint32_t GetMaxPartialPresentRects() override; + bool ShouldDrawPreviousPartialPresentRegions() override; + size_t GetBufferAge() const override; + void SetBufferDamageRegion(const wr::DeviceIntRect* aRects, + size_t aNumRects) override; + + ipc::FileDescriptor GetAndResetReleaseFence() override; + + protected: + EGLSurface CreateEGLSurface(); + + void DestroyEGLSurface(); + + RefPtr mGL; + + EGLSurface mEGLSurface; + + // Whether we are in the process of handling a NEW_SURFACE error. On Android + // this is used to allow the widget an opportunity to recover from the first + // instance, before raising a WebRenderError on subsequent occurences. + bool mHandlingNewSurfaceError = false; + + // FileDescriptor of release fence. + // Release fence is a fence that is used for waiting until usage/composite of + // AHardwareBuffer is ended. The fence is delivered to client side via + // ImageBridge. It is used only on android. + ipc::FileDescriptor mReleaseFenceFd; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERCOMPOSITOR_EGL_H diff --git a/gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp b/gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp new file mode 100644 index 0000000000..cdda1b0d0d --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorLayersSWGL.cpp @@ -0,0 +1,481 @@ +/* -*- 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 "RenderCompositorLayersSWGL.h" + +#include "GLContext.h" +#include "GLContextEGL.h" +#include "mozilla/layers/BuildConstants.h" +#include "mozilla/layers/Effects.h" +#include "mozilla/layers/TextureHostOGL.h" +#include "mozilla/widget/CompositorWidget.h" +#include "RenderCompositorRecordedFrame.h" + +#if defined(XP_WIN) +# include "mozilla/webrender/RenderCompositorD3D11SWGL.h" +#else +# include "mozilla/webrender/RenderCompositorOGLSWGL.h" +#endif + +namespace mozilla { +using namespace layers; +using namespace gfx; + +namespace wr { + +UniquePtr RenderCompositorLayersSWGL::Create( + const RefPtr& aWidget, nsACString& aError) { +#ifdef XP_WIN + return RenderCompositorD3D11SWGL::Create(aWidget, aError); +#else + return RenderCompositorOGLSWGL::Create(aWidget, aError); +#endif +} + +RenderCompositorLayersSWGL::RenderCompositorLayersSWGL( + Compositor* aCompositor, const RefPtr& aWidget, + void* aContext) + : RenderCompositor(aWidget), + mCompositor(aCompositor), + mContext(aContext), + mCurrentTileId(wr::NativeTileId()) { + MOZ_ASSERT(mCompositor); + MOZ_ASSERT(mContext); +} + +RenderCompositorLayersSWGL::~RenderCompositorLayersSWGL() { + wr_swgl_destroy_context(mContext); +} + +bool RenderCompositorLayersSWGL::MakeCurrent() { + wr_swgl_make_current(mContext); + return true; +} + +bool RenderCompositorLayersSWGL::BeginFrame() { + MOZ_ASSERT(!mInFrame); + MakeCurrent(); + mInFrame = true; + return true; +} + +void RenderCompositorLayersSWGL::CancelFrame() { + MOZ_ASSERT(mInFrame); + mInFrame = false; + if (mCompositingStarted) { + mCompositor->CancelFrame(); + mCompositingStarted = false; + } +} + +void RenderCompositorLayersSWGL::StartCompositing( + wr::ColorF aClearColor, const wr::DeviceIntRect* aDirtyRects, + size_t aNumDirtyRects, const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects) { + MOZ_RELEASE_ASSERT(!mCompositingStarted); + + if (!mInFrame || aNumDirtyRects == 0) { + return; + } + + gfx::IntRect bounds(gfx::IntPoint(0, 0), GetBufferSize().ToUnknownSize()); + nsIntRegion dirty; + + MOZ_RELEASE_ASSERT(aNumDirtyRects > 0); + for (size_t i = 0; i < aNumDirtyRects; i++) { + const auto& rect = aDirtyRects[i]; + dirty.OrWith( + gfx::IntRect(rect.min.x, rect.min.y, rect.width(), rect.height())); + } + dirty.AndWith(bounds); + + nsIntRegion opaque(bounds); + opaque.SubOut(mWidget->GetTransparentRegion().ToUnknownRegion()); + for (size_t i = 0; i < aNumOpaqueRects; i++) { + const auto& rect = aOpaqueRects[i]; + opaque.OrWith( + gfx::IntRect(rect.min.x, rect.min.y, rect.width(), rect.height())); + } + + mCompositor->SetClearColor(gfx::DeviceColor(aClearColor.r, aClearColor.g, + aClearColor.b, aClearColor.a)); + + if (!mCompositor->BeginFrameForWindow(dirty, Nothing(), bounds, opaque)) { + return; + } + mCompositingStarted = true; +} + +void RenderCompositorLayersSWGL::CompositorEndFrame() { + nsTArray frameSurfaces = std::move(mFrameSurfaces); + + if (!mCompositingStarted) { + return; + } + + for (auto& frameSurface : frameSurfaces) { + auto surfaceCursor = mSurfaces.find(frameSurface.mId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface* surface = surfaceCursor->second.get(); + + for (auto it = surface->mTiles.begin(); it != surface->mTiles.end(); ++it) { + if (!it->second->IsValid()) { + continue; + } + + gfx::Point tileOffset(it->first.mX * surface->mTileSize.width, + it->first.mY * surface->mTileSize.height); + gfx::Rect drawRect = it->second->mValidRect + tileOffset; + + RefPtr texturedEffect = + new EffectRGB(it->second->GetTextureSource(), + /* aPremultiplied */ true, frameSurface.mFilter); + if (surface->mIsOpaque) { + texturedEffect->mPremultipliedCopy = true; + } + + texturedEffect->mTextureCoords = + gfx::Rect(it->second->mValidRect.x / surface->mTileSize.width, + it->second->mValidRect.y / surface->mTileSize.height, + it->second->mValidRect.width / surface->mTileSize.width, + it->second->mValidRect.height / surface->mTileSize.height); + + EffectChain effect; + effect.mPrimaryEffect = texturedEffect; + mCompositor->DrawQuad(drawRect, frameSurface.mClipRect, effect, 1.0, + frameSurface.mTransform, drawRect); + } + + if (surface->mExternalImage) { + HandleExternalImage(surface->mExternalImage, frameSurface); + } + } +} + +RenderedFrameId RenderCompositorLayersSWGL::EndFrame( + const nsTArray& aDirtyRects) { + MOZ_ASSERT(mInFrame); + mInFrame = false; + if (mCompositingStarted) { + mCompositor->EndFrame(); + mCompositingStarted = false; + } + return GetNextRenderFrameId(); +} + +LayoutDeviceIntSize RenderCompositorLayersSWGL::GetBufferSize() { + return mWidget->GetClientSize(); +} + +void RenderCompositorLayersSWGL::Bind(wr::NativeTileId aId, + wr::DeviceIntPoint* aOffset, + uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) { + MOZ_RELEASE_ASSERT(false); +} + +void RenderCompositorLayersSWGL::Unbind() { MOZ_RELEASE_ASSERT(false); } + +bool RenderCompositorLayersSWGL::MapTile(wr::NativeTileId aId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) { + auto surfaceCursor = mSurfaces.find(aId.surface_id); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface* surface = surfaceCursor->second.get(); + + auto layerCursor = surface->mTiles.find(TileKey(aId.x, aId.y)); + MOZ_RELEASE_ASSERT(layerCursor != surface->mTiles.end()); + + mCurrentTile = layerCursor->second.get(); + mCurrentTileId = aId; + mCurrentTileDirty = gfx::IntRect(aDirtyRect.min.x, aDirtyRect.min.y, + aDirtyRect.width(), aDirtyRect.height()); + + if (!mCurrentTile->Map(aDirtyRect, aValidRect, aData, aStride)) { + gfxCriticalNote << "MapTile failed aValidRect: " + << gfx::Rect(aValidRect.min.x, aValidRect.min.y, + aValidRect.width(), aValidRect.height()); + return false; + } + + // Store the new valid rect, so that we can composite only those pixels + mCurrentTile->mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y, + aValidRect.width(), aValidRect.height()); + return true; +} + +void RenderCompositorLayersSWGL::UnmapTile() { + mCurrentTile->Unmap(mCurrentTileDirty); + mCurrentTile = nullptr; +} + +void RenderCompositorLayersSWGL::CreateSurface( + wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) { + MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end()); + auto surface = DoCreateSurface(aTileSize, aIsOpaque); + mSurfaces.insert({aId, std::move(surface)}); +} + +UniquePtr +RenderCompositorLayersSWGL::DoCreateSurface(wr::DeviceIntSize aTileSize, + bool aIsOpaque) { + return MakeUnique(aTileSize, aIsOpaque); +} + +void RenderCompositorLayersSWGL::CreateExternalSurface(wr::NativeSurfaceId aId, + bool aIsOpaque) { + MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end()); + auto surface = MakeUnique(wr::DeviceIntSize{}, aIsOpaque); + surface->mIsExternal = true; + mSurfaces.insert({aId, std::move(surface)}); +} + +void RenderCompositorLayersSWGL::DestroySurface(NativeSurfaceId aId) { + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + mSurfaces.erase(surfaceCursor); +} + +void RenderCompositorLayersSWGL::CreateTile(wr::NativeSurfaceId aId, int32_t aX, + int32_t aY) { + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface* surface = surfaceCursor->second.get(); + MOZ_RELEASE_ASSERT(!surface->mIsExternal); + + auto tile = DoCreateTile(surface); + surface->mTiles.insert({TileKey(aX, aY), std::move(tile)}); +} + +void RenderCompositorLayersSWGL::DestroyTile(wr::NativeSurfaceId aId, + int32_t aX, int32_t aY) { + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface* surface = surfaceCursor->second.get(); + MOZ_RELEASE_ASSERT(!surface->mIsExternal); + + auto layerCursor = surface->mTiles.find(TileKey(aX, aY)); + MOZ_RELEASE_ASSERT(layerCursor != surface->mTiles.end()); + surface->mTiles.erase(layerCursor); +} + +void RenderCompositorLayersSWGL::AttachExternalImage( + wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) { + RenderTextureHost* image = + RenderThread::Get()->GetRenderTexture(aExternalImage); + MOZ_ASSERT(image); + if (!image) { + gfxCriticalNoteOnce + << "Failed to get RenderTextureHost for D3D11SWGL extId:" + << AsUint64(aExternalImage); + return; + } +#if defined(XP_WIN) + MOZ_RELEASE_ASSERT(image->AsRenderDXGITextureHost() || + image->AsRenderDXGIYCbCrTextureHost()); +#elif defined(ANDROID) + MOZ_RELEASE_ASSERT(image->AsRenderAndroidHardwareBufferTextureHost() || + image->AsRenderAndroidSurfaceTextureHost()); +#endif + + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + + Surface* surface = surfaceCursor->second.get(); + surface->mExternalImage = image; + MOZ_RELEASE_ASSERT(surface->mTiles.empty()); + MOZ_RELEASE_ASSERT(surface->mIsExternal); +} + +// static +gfx::SamplingFilter RenderCompositorLayersSWGL::ToSamplingFilter( + wr::ImageRendering aImageRendering) { + if (aImageRendering == wr::ImageRendering::Auto) { + return gfx::SamplingFilter::LINEAR; + } + return gfx::SamplingFilter::POINT; +} + +void RenderCompositorLayersSWGL::AddSurface( + wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) { + float sx = aTransform.scale.x; + float sy = aTransform.scale.y; + float tx = aTransform.offset.x; + float ty = aTransform.offset.y; + gfx::Matrix4x4 transform(sx, 0.0, 0.0, 0.0, 0.0, sy, 0.0, 0.0, 0.0, 0.0, 1.0, + 0.0, tx, ty, 0.0, 1.0); + gfx::IntRect clipRect(aClipRect.min.x, aClipRect.min.y, aClipRect.width(), + aClipRect.height()); + + mFrameSurfaces.AppendElement(FrameSurface{aId, transform, clipRect, + ToSamplingFilter(aImageRendering)}); +} + +void RenderCompositorLayersSWGL::MaybeRequestAllowFrameRecording( + bool aWillRecord) { + mCompositor->RequestAllowFrameRecording(aWillRecord); +} + +class WindowLMC : public profiler_screenshots::Window { + public: + explicit WindowLMC(Compositor* aCompositor) : mCompositor(aCompositor) {} + + already_AddRefed GetWindowContents( + const gfx::IntSize& aWindowSize) override; + already_AddRefed CreateDownscaleTarget( + const gfx::IntSize& aSize) override; + already_AddRefed + CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) override; + + protected: + Compositor* mCompositor; +}; + +class RenderSourceLMC : public profiler_screenshots::RenderSource { + public: + explicit RenderSourceLMC(CompositingRenderTarget* aRT) + : RenderSource(aRT->GetSize()), mRT(aRT) {} + + const auto& RenderTarget() { return mRT; } + + protected: + virtual ~RenderSourceLMC() {} + + RefPtr mRT; +}; + +class DownscaleTargetLMC : public profiler_screenshots::DownscaleTarget { + public: + explicit DownscaleTargetLMC(CompositingRenderTarget* aRT, + Compositor* aCompositor) + : profiler_screenshots::DownscaleTarget(aRT->GetSize()), + mRenderSource(new RenderSourceLMC(aRT)), + mCompositor(aCompositor) {} + + already_AddRefed AsRenderSource() + override { + return do_AddRef(mRenderSource); + } + + bool DownscaleFrom(profiler_screenshots::RenderSource* aSource, + const IntRect& aSourceRect, + const IntRect& aDestRect) override { + MOZ_RELEASE_ASSERT(aSourceRect.TopLeft() == IntPoint()); + MOZ_RELEASE_ASSERT(aDestRect.TopLeft() == IntPoint()); + RefPtr previousTarget = + mCompositor->GetCurrentRenderTarget(); + + mCompositor->SetRenderTarget(mRenderSource->RenderTarget()); + bool result = mCompositor->BlitRenderTarget( + static_cast(aSource)->RenderTarget(), + aSourceRect.Size(), aDestRect.Size()); + + // Restore the old render target. + mCompositor->SetRenderTarget(previousTarget); + + return result; + } + + protected: + virtual ~DownscaleTargetLMC() {} + + RefPtr mRenderSource; + Compositor* mCompositor; +}; + +class AsyncReadbackBufferLMC + : public profiler_screenshots::AsyncReadbackBuffer { + public: + AsyncReadbackBufferLMC(mozilla::layers::AsyncReadbackBuffer* aARB, + Compositor* aCompositor) + : profiler_screenshots::AsyncReadbackBuffer(aARB->GetSize()), + mARB(aARB), + mCompositor(aCompositor) {} + void CopyFrom(profiler_screenshots::RenderSource* aSource) override { + mCompositor->ReadbackRenderTarget( + static_cast(aSource)->RenderTarget(), mARB); + } + bool MapAndCopyInto(DataSourceSurface* aSurface, + const IntSize& aReadSize) override { + return mARB->MapAndCopyInto(aSurface, aReadSize); + } + + protected: + virtual ~AsyncReadbackBufferLMC() {} + + RefPtr mARB; + Compositor* mCompositor; +}; + +already_AddRefed +WindowLMC::GetWindowContents(const gfx::IntSize& aWindowSize) { + RefPtr rt = mCompositor->GetWindowRenderTarget(); + if (!rt) { + return nullptr; + } + return MakeAndAddRef(rt); +} + +already_AddRefed +WindowLMC::CreateDownscaleTarget(const gfx::IntSize& aSize) { + RefPtr rt = + mCompositor->CreateRenderTarget(IntRect({}, aSize), INIT_MODE_NONE); + return MakeAndAddRef(rt, mCompositor); +} + +already_AddRefed +WindowLMC::CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) { + RefPtr carb = + mCompositor->CreateAsyncReadbackBuffer(aSize); + if (!carb) { + return nullptr; + } + return MakeAndAddRef(carb, mCompositor); +} + +bool RenderCompositorLayersSWGL::MaybeRecordFrame( + layers::CompositionRecorder& aRecorder) { + WindowLMC window(mCompositor); + gfx::IntSize size = GetBufferSize().ToUnknownSize(); + RefPtr snapshot = + window.GetWindowContents(size); + if (!snapshot) { + return true; + } + + RefPtr buffer = + window.CreateAsyncReadbackBuffer(size); + buffer->CopyFrom(snapshot); + + RefPtr frame = + new RenderCompositorRecordedFrame(TimeStamp::Now(), std::move(buffer)); + aRecorder.RecordFrame(frame); + return false; +} + +bool RenderCompositorLayersSWGL::MaybeGrabScreenshot( + const gfx::IntSize& aWindowSize) { + if (!mCompositingStarted) { + return true; + } + WindowLMC window(mCompositor); + mProfilerScreenshotGrabber.MaybeGrabScreenshot(window, aWindowSize); + return true; +} + +bool RenderCompositorLayersSWGL::MaybeProcessScreenshotQueue() { + mProfilerScreenshotGrabber.MaybeProcessQueue(); + return true; +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderCompositorLayersSWGL.h b/gfx/webrender_bindings/RenderCompositorLayersSWGL.h new file mode 100644 index 0000000000..3cf6bb44f5 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorLayersSWGL.h @@ -0,0 +1,195 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_Layers_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_Layers_H + +#include + +#include "mozilla/HashFunctions.h" +#include "mozilla/layers/Compositor.h" +#include "mozilla/layers/ScreenshotGrabber.h" +#include "mozilla/webrender/RenderCompositor.h" +#include "mozilla/webrender/RenderTextureHost.h" + +namespace mozilla { + +namespace wr { + +class SurfaceD3D11SWGL; + +class RenderCompositorLayersSWGL : public RenderCompositor { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorLayersSWGL(layers::Compositor* aCompositor, + const RefPtr& aWidget, + void* aContext); + virtual ~RenderCompositorLayersSWGL(); + + void* swgl() const override { return mContext; } + + bool MakeCurrent() override; + + bool BeginFrame() override; + void CancelFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) override; + + bool SurfaceOriginIsTopLeft() override { return true; } + + LayoutDeviceIntSize GetBufferSize() override; + + // Should we support this? + bool SupportsExternalBufferTextures() const override { return false; } + + layers::WebRenderBackend BackendType() const override { + return layers::WebRenderBackend::SOFTWARE; + } + + bool ShouldUseNativeCompositor() override { return true; } + + void StartCompositing(wr::ColorF aClearColor, + const wr::DeviceIntRect* aDirtyRects, + size_t aNumDirtyRects, + const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects) override; + + void CompositorBeginFrame() override {} + void CompositorEndFrame() override; + void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) override; + void Unbind() override; + bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, void** aData, + int32_t* aStride) override; + void UnmapTile() override; + void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) override; + void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override; + void DestroySurface(NativeSurfaceId aId) override; + void CreateTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) override; + void DestroyTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) override; + void AttachExternalImage(wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage) override; + void AddSurface(wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering) override; + void EnableNativeCompositor(bool aEnable) override {} + void DeInit() override {} + + void MaybeRequestAllowFrameRecording(bool aWillRecord) override; + bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) override; + bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) override; + bool MaybeProcessScreenshotQueue() override; + + // TODO: Screenshots etc + + struct TileKey { + TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {} + + int32_t mX; + int32_t mY; + }; + + // Each tile retains a texture, and a DataSourceSurface of the + // same size. We draw into the source surface, and then copy the + // changed area into the texture. + class Tile { + public: + Tile() = default; + virtual ~Tile() = default; + + virtual bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) = 0; + virtual void Unmap(const gfx::IntRect& aDirtyRect) = 0; + virtual layers::DataTextureSource* GetTextureSource() = 0; + virtual bool IsValid() = 0; + + gfx::Rect mValidRect; + + struct KeyHashFn { + std::size_t operator()(const TileKey& aId) const { + return HashGeneric(aId.mX, aId.mY); + } + }; + }; + + class Surface { + public: + explicit Surface(wr::DeviceIntSize aTileSize, bool aIsOpaque) + : mTileSize(aTileSize), mIsOpaque(aIsOpaque) {} + virtual ~Surface() {} + + gfx::IntSize TileSize() { + return gfx::IntSize(mTileSize.width, mTileSize.height); + } + virtual SurfaceD3D11SWGL* AsSurfaceD3D11SWGL() { return nullptr; } + + // External images can change size depending on which image + // is attached, so mTileSize will be 0,0 when mIsExternal + // is true. + wr::DeviceIntSize mTileSize; + bool mIsOpaque; + bool mIsExternal = false; + std::unordered_map, Tile::KeyHashFn> mTiles; + RefPtr mExternalImage; + + struct IdHashFn { + std::size_t operator()(const wr::NativeSurfaceId& aId) const { + return HashGeneric(wr::AsUint64(aId)); + } + }; + }; + + static gfx::SamplingFilter ToSamplingFilter( + wr::ImageRendering aImageRendering); + + protected: + // The set of surfaces added to be composited for the current frame + struct FrameSurface { + wr::NativeSurfaceId mId; + gfx::Matrix4x4 mTransform; + gfx::IntRect mClipRect; + gfx::SamplingFilter mFilter; + }; + + virtual void HandleExternalImage(RenderTextureHost* aExternalImage, + FrameSurface& aFrameSurface) = 0; + virtual UniquePtr DoCreateSurface( + wr::DeviceIntSize aTileSize, bool aIsOpaque); + virtual UniquePtr DoCreateTile( + Surface* aSurface) = 0; + + RefPtr mCompositor; + void* mContext = nullptr; + + std::unordered_map, Surface::IdHashFn> + mSurfaces; + + // Temporary state held between MapTile and UnmapTile + Tile* mCurrentTile = nullptr; + gfx::IntRect mCurrentTileDirty; + wr::NativeTileId mCurrentTileId; + + nsTArray mFrameSurfaces; + bool mInFrame = false; + bool mCompositingStarted = false; + + layers::ScreenshotGrabber mProfilerScreenshotGrabber; +}; + +static inline bool operator==(const RenderCompositorLayersSWGL::TileKey& a0, + const RenderCompositorLayersSWGL::TileKey& a1) { + return a0.mX == a1.mX && a0.mY == a1.mY; +} + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorNative.cpp b/gfx/webrender_bindings/RenderCompositorNative.cpp new file mode 100644 index 0000000000..81cafd1fd6 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorNative.cpp @@ -0,0 +1,672 @@ +/* -*- 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 "RenderCompositorNative.h" + +#include "GLContext.h" +#include "GLContextProvider.h" +#include "mozilla/ProfilerLabels.h" +#include "mozilla/ProfilerMarkers.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/CompositionRecorder.h" +#include "mozilla/layers/NativeLayer.h" +#include "mozilla/layers/SurfacePool.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/widget/CompositorWidget.h" +#include "RenderCompositorRecordedFrame.h" + +namespace mozilla::wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +RenderCompositorNative::RenderCompositorNative( + const RefPtr& aWidget, gl::GLContext* aGL) + : RenderCompositor(aWidget), + mNativeLayerRoot(GetWidget()->GetNativeLayerRoot()) { + LOG("RenderCompositorNative::RenderCompositorNative()"); + +#if defined(XP_MACOSX) || defined(MOZ_WAYLAND) + auto pool = RenderThread::Get()->SharedSurfacePool(); + if (pool) { + mSurfacePoolHandle = pool->GetHandleForGL(aGL); + } +#endif + MOZ_RELEASE_ASSERT(mSurfacePoolHandle); +} + +RenderCompositorNative::~RenderCompositorNative() { + LOG("RRenderCompositorNative::~RenderCompositorNative()"); + + Pause(); + mProfilerScreenshotGrabber.Destroy(); + mNativeLayerRoot->SetLayers({}); + mNativeLayerForEntireWindow = nullptr; + mNativeLayerRootSnapshotter = nullptr; + mNativeLayerRoot = nullptr; +} + +bool RenderCompositorNative::BeginFrame() { + if (!MakeCurrent()) { + gfxCriticalNote << "Failed to make render context current, can't draw."; + return false; + } + + gfx::IntSize bufferSize = GetBufferSize().ToUnknownSize(); + if (!ShouldUseNativeCompositor()) { + if (bufferSize.IsEmpty()) { + return false; + } + if (mNativeLayerForEntireWindow && + mNativeLayerForEntireWindow->GetSize() != bufferSize) { + mNativeLayerRoot->RemoveLayer(mNativeLayerForEntireWindow); + mNativeLayerForEntireWindow = nullptr; + } + if (!mNativeLayerForEntireWindow) { + mNativeLayerForEntireWindow = + mNativeLayerRoot->CreateLayer(bufferSize, false, mSurfacePoolHandle); + mNativeLayerRoot->AppendLayer(mNativeLayerForEntireWindow); + } + } + + gfx::IntRect bounds({}, bufferSize); + if (!InitDefaultFramebuffer(bounds)) { + return false; + } + + return true; +} + +RenderedFrameId RenderCompositorNative::EndFrame( + const nsTArray& aDirtyRects) { + RenderedFrameId frameId = GetNextRenderFrameId(); + + DoSwap(); + + if (mNativeLayerForEntireWindow) { + mNativeLayerForEntireWindow->NotifySurfaceReady(); + mNativeLayerRoot->CommitToScreen(); + } + + return frameId; +} + +void RenderCompositorNative::Pause() {} + +bool RenderCompositorNative::Resume() { return true; } + +inline layers::WebRenderCompositor RenderCompositorNative::CompositorType() + const { + if (gfx::gfxVars::UseWebRenderCompositor()) { +#if defined(XP_MACOSX) + return layers::WebRenderCompositor::CORE_ANIMATION; +#elif defined(MOZ_WAYLAND) + return layers::WebRenderCompositor::WAYLAND; +#endif + } + return layers::WebRenderCompositor::DRAW; +} + +LayoutDeviceIntSize RenderCompositorNative::GetBufferSize() { + return mWidget->GetClientSize(); +} + +bool RenderCompositorNative::ShouldUseNativeCompositor() { + return gfx::gfxVars::UseWebRenderCompositor(); +} + +void RenderCompositorNative::GetCompositorCapabilities( + CompositorCapabilities* aCaps) { + RenderCompositor::GetCompositorCapabilities(aCaps); +#if defined(XP_MACOSX) + aCaps->supports_surface_for_backdrop = !gfx::gfxVars::UseSoftwareWebRender(); +#endif +} + +bool RenderCompositorNative::MaybeReadback( + const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, bool* aNeedsYFlip) { + if (!ShouldUseNativeCompositor()) { + return false; + } + + MOZ_RELEASE_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8); + if (!mNativeLayerRootSnapshotter) { + mNativeLayerRootSnapshotter = mNativeLayerRoot->CreateSnapshotter(); + + if (!mNativeLayerRootSnapshotter) { + return false; + } + } + bool success = mNativeLayerRootSnapshotter->ReadbackPixels( + aReadbackSize, gfx::SurfaceFormat::B8G8R8A8, aReadbackBuffer); + + // ReadbackPixels might have changed the current context. Make sure GL is + // current again. + MakeCurrent(); + + if (aNeedsYFlip) { + *aNeedsYFlip = true; + } + + return success; +} + +bool RenderCompositorNative::MaybeRecordFrame( + layers::CompositionRecorder& aRecorder) { + if (!ShouldUseNativeCompositor()) { + return false; + } + + if (!mNativeLayerRootSnapshotter) { + mNativeLayerRootSnapshotter = mNativeLayerRoot->CreateSnapshotter(); + } + + if (!mNativeLayerRootSnapshotter) { + return true; + } + + gfx::IntSize size = GetBufferSize().ToUnknownSize(); + RefPtr snapshot = + mNativeLayerRootSnapshotter->GetWindowContents(size); + if (!snapshot) { + return true; + } + + RefPtr buffer = + mNativeLayerRootSnapshotter->CreateAsyncReadbackBuffer(size); + buffer->CopyFrom(snapshot); + + RefPtr frame = + new RenderCompositorRecordedFrame(TimeStamp::Now(), std::move(buffer)); + aRecorder.RecordFrame(frame); + + // GetWindowContents might have changed the current context. Make sure our + // context is current again. + MakeCurrent(); + return true; +} + +bool RenderCompositorNative::MaybeGrabScreenshot( + const gfx::IntSize& aWindowSize) { + if (!ShouldUseNativeCompositor()) { + return false; + } + + if (!mNativeLayerRootSnapshotter) { + mNativeLayerRootSnapshotter = mNativeLayerRoot->CreateSnapshotter(); + } + + if (mNativeLayerRootSnapshotter) { + mProfilerScreenshotGrabber.MaybeGrabScreenshot(*mNativeLayerRootSnapshotter, + aWindowSize); + + // MaybeGrabScreenshot might have changed the current context. Make sure our + // context is current again. + MakeCurrent(); + } + + return true; +} + +bool RenderCompositorNative::MaybeProcessScreenshotQueue() { + if (!ShouldUseNativeCompositor()) { + return false; + } + + mProfilerScreenshotGrabber.MaybeProcessQueue(); + + // MaybeProcessQueue might have changed the current context. Make sure our + // context is current again. + MakeCurrent(); + + return true; +} + +void RenderCompositorNative::CompositorBeginFrame() { + mAddedLayers.Clear(); + mAddedTilePixelCount = 0; + mAddedClippedPixelCount = 0; + mBeginFrameTimeStamp = TimeStamp::Now(); + mSurfacePoolHandle->OnBeginFrame(); + mNativeLayerRoot->PrepareForCommit(); +} + +void RenderCompositorNative::CompositorEndFrame() { + if (profiler_thread_is_being_profiled_for_markers()) { + auto bufferSize = GetBufferSize(); + [[maybe_unused]] uint64_t windowPixelCount = + uint64_t(bufferSize.width) * bufferSize.height; + int nativeLayerCount = 0; + for (const auto& it : mSurfaces) { + nativeLayerCount += int(it.second.mNativeLayers.size()); + } + PROFILER_MARKER_TEXT( + "WR OS Compositor frame", GRAPHICS, + MarkerTiming::IntervalUntilNowFrom(mBeginFrameTimeStamp), + nsPrintfCString("%d%% painting, %d%% overdraw, %d used " + "layers (%d%% memory) + %d unused layers (%d%% memory)", + int(mDrawnPixelCount * 100 / windowPixelCount), + int(mAddedClippedPixelCount * 100 / windowPixelCount), + int(mAddedLayers.Length()), + int(mAddedTilePixelCount * 100 / windowPixelCount), + int(nativeLayerCount - mAddedLayers.Length()), + int((mTotalTilePixelCount - mAddedTilePixelCount) * + 100 / windowPixelCount))); + } + mDrawnPixelCount = 0; + + DoFlush(); + + mNativeLayerRoot->SetLayers(mAddedLayers); + mNativeLayerRoot->CommitToScreen(); + mSurfacePoolHandle->OnEndFrame(); +} + +void RenderCompositorNative::BindNativeLayer(wr::NativeTileId aId, + const gfx::IntRect& aDirtyRect) { + MOZ_RELEASE_ASSERT(!mCurrentlyBoundNativeLayer); + + auto surfaceCursor = mSurfaces.find(aId.surface_id); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface& surface = surfaceCursor->second; + + auto layerCursor = surface.mNativeLayers.find(TileKey(aId.x, aId.y)); + MOZ_RELEASE_ASSERT(layerCursor != surface.mNativeLayers.end()); + RefPtr layer = layerCursor->second; + + mCurrentlyBoundNativeLayer = layer; + + mDrawnPixelCount += aDirtyRect.Area(); +} + +void RenderCompositorNative::UnbindNativeLayer() { + MOZ_RELEASE_ASSERT(mCurrentlyBoundNativeLayer); + + mCurrentlyBoundNativeLayer->NotifySurfaceReady(); + mCurrentlyBoundNativeLayer = nullptr; +} + +void RenderCompositorNative::CreateSurface(wr::NativeSurfaceId aId, + wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, + bool aIsOpaque) { + MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end()); + mSurfaces.insert({aId, Surface{aTileSize, aIsOpaque}}); +} + +void RenderCompositorNative::CreateExternalSurface(wr::NativeSurfaceId aId, + bool aIsOpaque) { + MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end()); + + RefPtr layer = + mNativeLayerRoot->CreateLayerForExternalTexture(aIsOpaque); + + Surface surface{DeviceIntSize{}, aIsOpaque}; + surface.mIsExternal = true; + surface.mNativeLayers.insert({TileKey(0, 0), layer}); + + mSurfaces.insert({aId, std::move(surface)}); +} + +void RenderCompositorNative::CreateBackdropSurface(wr::NativeSurfaceId aId, + wr::ColorF aColor) { + MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end()); + + gfx::DeviceColor color(aColor.r, aColor.g, aColor.b, aColor.a); + RefPtr layer = + mNativeLayerRoot->CreateLayerForColor(color); + + Surface surface{DeviceIntSize{}, (aColor.a >= 1.0f)}; + surface.mNativeLayers.insert({TileKey(0, 0), layer}); + + mSurfaces.insert({aId, std::move(surface)}); +} + +void RenderCompositorNative::AttachExternalImage( + wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) { + RenderTextureHost* image = + RenderThread::Get()->GetRenderTexture(aExternalImage); + MOZ_RELEASE_ASSERT(image); + + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + + Surface& surface = surfaceCursor->second; + MOZ_RELEASE_ASSERT(surface.mNativeLayers.size() == 1); + MOZ_RELEASE_ASSERT(surface.mIsExternal); + surface.mNativeLayers.begin()->second->AttachExternalImage(image); +} + +void RenderCompositorNative::DestroySurface(NativeSurfaceId aId) { + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + + Surface& surface = surfaceCursor->second; + if (!surface.mIsExternal) { + for (const auto& iter : surface.mNativeLayers) { + mTotalTilePixelCount -= gfx::IntRect({}, iter.second->GetSize()).Area(); + } + } + + mSurfaces.erase(surfaceCursor); +} + +void RenderCompositorNative::CreateTile(wr::NativeSurfaceId aId, int aX, + int aY) { + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface& surface = surfaceCursor->second; + MOZ_RELEASE_ASSERT(!surface.mIsExternal); + + RefPtr layer = mNativeLayerRoot->CreateLayer( + surface.TileSize(), surface.mIsOpaque, mSurfacePoolHandle); + surface.mNativeLayers.insert({TileKey(aX, aY), layer}); + mTotalTilePixelCount += gfx::IntRect({}, layer->GetSize()).Area(); +} + +void RenderCompositorNative::DestroyTile(wr::NativeSurfaceId aId, int aX, + int aY) { + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + Surface& surface = surfaceCursor->second; + MOZ_RELEASE_ASSERT(!surface.mIsExternal); + + auto layerCursor = surface.mNativeLayers.find(TileKey(aX, aY)); + MOZ_RELEASE_ASSERT(layerCursor != surface.mNativeLayers.end()); + RefPtr layer = std::move(layerCursor->second); + surface.mNativeLayers.erase(layerCursor); + mTotalTilePixelCount -= gfx::IntRect({}, layer->GetSize()).Area(); + + // If the layer is currently present in mNativeLayerRoot, it will be destroyed + // once CompositorEndFrame() replaces mNativeLayerRoot's layers and drops that + // reference. So until that happens, the layer still needs to hold on to its + // front buffer. However, we can tell it to drop its back buffers now, because + // we know that we will never draw to it again. + // Dropping the back buffers now puts them back in the surface pool, so those + // surfaces can be immediately re-used for drawing in other layers in the + // current frame. + layer->DiscardBackbuffers(); +} + +gfx::SamplingFilter ToSamplingFilter(wr::ImageRendering aImageRendering) { + if (aImageRendering == wr::ImageRendering::Auto) { + return gfx::SamplingFilter::LINEAR; + } + return gfx::SamplingFilter::POINT; +} + +void RenderCompositorNative::AddSurface( + wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) { + MOZ_RELEASE_ASSERT(!mCurrentlyBoundNativeLayer); + + auto surfaceCursor = mSurfaces.find(aId); + MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end()); + const Surface& surface = surfaceCursor->second; + + float sx = aTransform.scale.x; + float sy = aTransform.scale.y; + float tx = aTransform.offset.x; + float ty = aTransform.offset.y; + gfx::Matrix4x4 transform(sx, 0.0, 0.0, 0.0, 0.0, sy, 0.0, 0.0, 0.0, 0.0, 1.0, + 0.0, tx, ty, 0.0, 1.0); + + for (auto it = surface.mNativeLayers.begin(); + it != surface.mNativeLayers.end(); ++it) { + RefPtr layer = it->second; + gfx::IntSize layerSize = layer->GetSize(); + gfx::IntPoint layerPosition(surface.mTileSize.width * it->first.mX, + surface.mTileSize.height * it->first.mY); + layer->SetPosition(layerPosition); + gfx::IntRect clipRect(aClipRect.min.x, aClipRect.min.y, aClipRect.width(), + aClipRect.height()); + layer->SetClipRect(Some(clipRect)); + layer->SetTransform(transform); + layer->SetSamplingFilter(ToSamplingFilter(aImageRendering)); + mAddedLayers.AppendElement(layer); + + if (!surface.mIsExternal) { + mAddedTilePixelCount += layerSize.width * layerSize.height; + } + gfx::Rect r = transform.TransformBounds( + gfx::Rect(layer->CurrentSurfaceDisplayRect())); + gfx::IntRect visibleRect = + clipRect.Intersect(RoundedToInt(r) + layerPosition); + mAddedClippedPixelCount += visibleRect.Area(); + } +} + +/* static */ +UniquePtr RenderCompositorNativeOGL::Create( + const RefPtr& aWidget, nsACString& aError) { + RefPtr gl = RenderThread::Get()->SingletonGL(); + if (!gl) { + gl = gl::GLContextProvider::CreateForCompositorWidget( + aWidget, /* aHardwareWebRender */ true, /* aForceAccelerated */ true); + RenderThread::MaybeEnableGLDebugMessage(gl); + } + if (!gl || !gl->MakeCurrent()) { + gfxCriticalNote << "Failed GL context creation for WebRender: " + << gfx::hexa(gl.get()); + return nullptr; + } + return MakeUnique(aWidget, std::move(gl)); +} + +RenderCompositorNativeOGL::RenderCompositorNativeOGL( + const RefPtr& aWidget, + RefPtr&& aGL) + : RenderCompositorNative(aWidget, aGL), mGL(aGL) { + MOZ_ASSERT(mGL); +} + +RenderCompositorNativeOGL::~RenderCompositorNativeOGL() { + if (!mGL->MakeCurrent()) { + gfxCriticalNote + << "Failed to make render context current during destroying."; + // Leak resources! + mPreviousFrameDoneSync = nullptr; + mThisFrameDoneSync = nullptr; + return; + } + + if (mPreviousFrameDoneSync) { + mGL->fDeleteSync(mPreviousFrameDoneSync); + } + if (mThisFrameDoneSync) { + mGL->fDeleteSync(mThisFrameDoneSync); + } +} + +bool RenderCompositorNativeOGL::InitDefaultFramebuffer( + const gfx::IntRect& aBounds) { + if (mNativeLayerForEntireWindow) { + Maybe fbo = mNativeLayerForEntireWindow->NextSurfaceAsFramebuffer( + aBounds, aBounds, true); + if (!fbo) { + return false; + } + mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, *fbo); + } else { + mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGL->GetDefaultFramebuffer()); + } + return true; +} + +void RenderCompositorNativeOGL::DoSwap() { + InsertFrameDoneSync(); + if (mNativeLayerForEntireWindow) { + mGL->fFlush(); + } +} + +void RenderCompositorNativeOGL::DoFlush() { mGL->fFlush(); } + +void RenderCompositorNativeOGL::InsertFrameDoneSync() { +#ifdef XP_MACOSX + // Only do this on macOS. + // On other platforms, SwapBuffers automatically applies back-pressure. + if (mThisFrameDoneSync) { + mGL->fDeleteSync(mThisFrameDoneSync); + } + mThisFrameDoneSync = mGL->fFenceSync(LOCAL_GL_SYNC_GPU_COMMANDS_COMPLETE, 0); +#endif +} + +bool RenderCompositorNativeOGL::WaitForGPU() { + if (mPreviousFrameDoneSync) { + AUTO_PROFILER_LABEL("Waiting for GPU to finish previous frame", GRAPHICS); + mGL->fClientWaitSync(mPreviousFrameDoneSync, + LOCAL_GL_SYNC_FLUSH_COMMANDS_BIT, + LOCAL_GL_TIMEOUT_IGNORED); + mGL->fDeleteSync(mPreviousFrameDoneSync); + } + mPreviousFrameDoneSync = mThisFrameDoneSync; + mThisFrameDoneSync = nullptr; + + return true; +} + +void RenderCompositorNativeOGL::Bind(wr::NativeTileId aId, + wr::DeviceIntPoint* aOffset, + uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) { + gfx::IntRect validRect(aValidRect.min.x, aValidRect.min.y, aValidRect.width(), + aValidRect.height()); + gfx::IntRect dirtyRect(aDirtyRect.min.x, aDirtyRect.min.y, aDirtyRect.width(), + aDirtyRect.height()); + + BindNativeLayer(aId, dirtyRect); + + Maybe fbo = mCurrentlyBoundNativeLayer->NextSurfaceAsFramebuffer( + validRect, dirtyRect, true); + + *aFboId = *fbo; + *aOffset = wr::DeviceIntPoint{0, 0}; +} + +void RenderCompositorNativeOGL::Unbind() { + mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0); + + UnbindNativeLayer(); +} + +/* static */ +UniquePtr RenderCompositorNativeSWGL::Create( + const RefPtr& aWidget, nsACString& aError) { + void* ctx = wr_swgl_create_context(); + if (!ctx) { + gfxCriticalNote << "Failed SWGL context creation for WebRender"; + return nullptr; + } + return MakeUnique(aWidget, ctx); +} + +RenderCompositorNativeSWGL::RenderCompositorNativeSWGL( + const RefPtr& aWidget, void* aContext) + : RenderCompositorNative(aWidget), mContext(aContext) { + MOZ_ASSERT(mContext); +} + +RenderCompositorNativeSWGL::~RenderCompositorNativeSWGL() { + wr_swgl_destroy_context(mContext); +} + +bool RenderCompositorNativeSWGL::MakeCurrent() { + wr_swgl_make_current(mContext); + return true; +} + +bool RenderCompositorNativeSWGL::InitDefaultFramebuffer( + const gfx::IntRect& aBounds) { + if (mNativeLayerForEntireWindow) { + if (!MapNativeLayer(mNativeLayerForEntireWindow, aBounds, aBounds)) { + return false; + } + wr_swgl_init_default_framebuffer(mContext, aBounds.x, aBounds.y, + aBounds.width, aBounds.height, + mLayerStride, mLayerValidRectData); + } + return true; +} + +void RenderCompositorNativeSWGL::CancelFrame() { + if (mNativeLayerForEntireWindow && mLayerTarget) { + wr_swgl_init_default_framebuffer(mContext, 0, 0, 0, 0, 0, nullptr); + UnmapNativeLayer(); + } +} + +void RenderCompositorNativeSWGL::DoSwap() { + if (mNativeLayerForEntireWindow && mLayerTarget) { + wr_swgl_init_default_framebuffer(mContext, 0, 0, 0, 0, 0, nullptr); + UnmapNativeLayer(); + } +} + +bool RenderCompositorNativeSWGL::MapNativeLayer( + layers::NativeLayer* aLayer, const gfx::IntRect& aDirtyRect, + const gfx::IntRect& aValidRect) { + uint8_t* data = nullptr; + gfx::IntSize size; + int32_t stride = 0; + gfx::SurfaceFormat format = gfx::SurfaceFormat::UNKNOWN; + RefPtr dt = aLayer->NextSurfaceAsDrawTarget( + aValidRect, gfx::IntRegion(aDirtyRect), gfx::BackendType::SKIA); + if (!dt || !dt->LockBits(&data, &size, &stride, &format)) { + return false; + } + MOZ_ASSERT(format == gfx::SurfaceFormat::B8G8R8A8 || + format == gfx::SurfaceFormat::B8G8R8X8); + mLayerTarget = std::move(dt); + mLayerData = data; + mLayerValidRectData = data + aValidRect.y * stride + aValidRect.x * 4; + mLayerStride = stride; + return true; +} + +void RenderCompositorNativeSWGL::UnmapNativeLayer() { + MOZ_ASSERT(mLayerTarget && mLayerData); + mLayerTarget->ReleaseBits(mLayerData); + mLayerTarget = nullptr; + mLayerData = nullptr; + mLayerValidRectData = nullptr; + mLayerStride = 0; +} + +bool RenderCompositorNativeSWGL::MapTile(wr::NativeTileId aId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) { + if (mNativeLayerForEntireWindow) { + return false; + } + gfx::IntRect dirtyRect(aDirtyRect.min.x, aDirtyRect.min.y, aDirtyRect.width(), + aDirtyRect.height()); + gfx::IntRect validRect(aValidRect.min.x, aValidRect.min.y, aValidRect.width(), + aValidRect.height()); + BindNativeLayer(aId, dirtyRect); + if (!MapNativeLayer(mCurrentlyBoundNativeLayer, dirtyRect, validRect)) { + UnbindNativeLayer(); + return false; + } + *aData = mLayerValidRectData; + *aStride = mLayerStride; + return true; +} + +void RenderCompositorNativeSWGL::UnmapTile() { + if (!mNativeLayerForEntireWindow && mCurrentlyBoundNativeLayer) { + UnmapNativeLayer(); + UnbindNativeLayer(); + } +} + +} // namespace mozilla::wr diff --git a/gfx/webrender_bindings/RenderCompositorNative.h b/gfx/webrender_bindings/RenderCompositorNative.h new file mode 100644 index 0000000000..936fdd3db8 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorNative.h @@ -0,0 +1,233 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_NATIVE_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_NATIVE_H + +#include + +#include "GLTypes.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/layers/ScreenshotGrabber.h" +#include "mozilla/webrender/RenderCompositor.h" +#include "mozilla/TimeStamp.h" + +namespace mozilla { + +namespace layers { +class NativeLayerRootSnapshotter; +class NativeLayerRoot; +class NativeLayer; +class SurfacePoolHandle; +} // namespace layers + +namespace wr { + +// RenderCompositorNative is a skeleton class for implementing compositors +// backed by NativeLayer surfaces and tiles. This is not meant to be directly +// instantiated and is instead derived for various use-cases such as OpenGL or +// SWGL. +class RenderCompositorNative : public RenderCompositor { + public: + virtual ~RenderCompositorNative(); + + bool BeginFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) final; + void Pause() override; + bool Resume() override; + + layers::WebRenderCompositor CompositorType() const override; + + LayoutDeviceIntSize GetBufferSize() override; + + bool ShouldUseNativeCompositor() override; + void GetCompositorCapabilities(CompositorCapabilities* aCaps) override; + + bool SurfaceOriginIsTopLeft() override { return true; } + + // Does the readback for the ShouldUseNativeCompositor() case. + bool MaybeReadback(const gfx::IntSize& aReadbackSize, + const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, + bool* aNeedsYFlip) override; + bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) override; + bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) override; + bool MaybeProcessScreenshotQueue() override; + + // Interface for wr::Compositor + void CompositorBeginFrame() override; + void CompositorEndFrame() override; + void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset, + wr::DeviceIntSize aTileSize, bool aIsOpaque) override; + void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override; + void CreateBackdropSurface(wr::NativeSurfaceId aId, + wr::ColorF aColor) override; + void DestroySurface(NativeSurfaceId aId) override; + void CreateTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override; + void DestroyTile(wr::NativeSurfaceId aId, int32_t aX, int32_t aY) override; + void AttachExternalImage(wr::NativeSurfaceId aId, + wr::ExternalImageId aExternalImage) override; + void AddSurface(wr::NativeSurfaceId aId, + const wr::CompositorSurfaceTransform& aTransform, + wr::DeviceIntRect aClipRect, + wr::ImageRendering aImageRendering) override; + + struct TileKey { + TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {} + + int32_t mX; + int32_t mY; + }; + + protected: + explicit RenderCompositorNative( + const RefPtr& aWidget, + gl::GLContext* aGL = nullptr); + + virtual bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) = 0; + virtual void DoSwap() = 0; + virtual void DoFlush() {} + + void BindNativeLayer(wr::NativeTileId aId, const gfx::IntRect& aDirtyRect); + void UnbindNativeLayer(); + + // Can be null. + RefPtr mNativeLayerRoot; + UniquePtr mNativeLayerRootSnapshotter; + layers::ScreenshotGrabber mProfilerScreenshotGrabber; + RefPtr mNativeLayerForEntireWindow; + RefPtr mSurfacePoolHandle; + + struct TileKeyHashFn { + std::size_t operator()(const TileKey& aId) const { + return HashGeneric(aId.mX, aId.mY); + } + }; + + struct Surface { + explicit Surface(wr::DeviceIntSize aTileSize, bool aIsOpaque) + : mTileSize(aTileSize), mIsOpaque(aIsOpaque) {} + gfx::IntSize TileSize() { + return gfx::IntSize(mTileSize.width, mTileSize.height); + } + + // External images can change size depending on which image + // is attached, so mTileSize will be 0,0 when mIsExternal + // is true. + wr::DeviceIntSize mTileSize; + bool mIsOpaque; + bool mIsExternal = false; + std::unordered_map, TileKeyHashFn> + mNativeLayers; + }; + + struct SurfaceIdHashFn { + std::size_t operator()(const wr::NativeSurfaceId& aId) const { + return HashGeneric(wr::AsUint64(aId)); + } + }; + + // Used in native compositor mode: + RefPtr mCurrentlyBoundNativeLayer; + nsTArray> mAddedLayers; + uint64_t mTotalTilePixelCount = 0; + uint64_t mAddedTilePixelCount = 0; + uint64_t mAddedClippedPixelCount = 0; + uint64_t mDrawnPixelCount = 0; + gfx::IntRect mVisibleBounds; + std::unordered_map mSurfaces; + TimeStamp mBeginFrameTimeStamp; +}; + +static inline bool operator==(const RenderCompositorNative::TileKey& a0, + const RenderCompositorNative::TileKey& a1) { + return a0.mX == a1.mX && a0.mY == a1.mY; +} + +// RenderCompositorNativeOGL is a NativeLayer compositor that exposes an +// OpenGL framebuffer for the respective NativeLayer bound to each tile. +class RenderCompositorNativeOGL : public RenderCompositorNative { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorNativeOGL(const RefPtr& aWidget, + RefPtr&& aGL); + virtual ~RenderCompositorNativeOGL(); + + bool WaitForGPU() override; + + gl::GLContext* gl() const override { return mGL; } + + void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId, + wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect) override; + void Unbind() override; + + protected: + void InsertFrameDoneSync(); + + bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) override; + void DoSwap() override; + void DoFlush() override; + + RefPtr mGL; + + // Used to apply back-pressure in WaitForGPU(). + GLsync mPreviousFrameDoneSync = nullptr; + GLsync mThisFrameDoneSync = nullptr; +}; + +// RenderCompositorNativeSWGL is a NativeLayer compositor that only +// deals with mapping the underlying buffer for SWGL usage of a tile. +class RenderCompositorNativeSWGL : public RenderCompositorNative { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorNativeSWGL(const RefPtr& aWidget, + void* aContext); + virtual ~RenderCompositorNativeSWGL(); + + void* swgl() const override { return mContext; } + + bool MakeCurrent() override; + + 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 + // last row will fall short if aValidRect is not at X==0). + bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, void** aData, + int32_t* aStride) override; + void UnmapTile() override; + + protected: + bool InitDefaultFramebuffer(const gfx::IntRect& aBounds) override; + void DoSwap() override; + + bool MapNativeLayer(layers::NativeLayer* aLayer, + const gfx::IntRect& aDirtyRect, + const gfx::IntRect& aValidRect); + void UnmapNativeLayer(); + + void* mContext = nullptr; + RefPtr mLayerTarget; + uint8_t* mLayerData = nullptr; + uint8_t* mLayerValidRectData = nullptr; + int32_t mLayerStride = 0; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorOGL.cpp b/gfx/webrender_bindings/RenderCompositorOGL.cpp new file mode 100644 index 0000000000..9653e06d43 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorOGL.cpp @@ -0,0 +1,126 @@ +/* -*- 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 "RenderCompositorOGL.h" + +#include "GLContext.h" +#include "GLContextEGL.h" +#include "GLContextProvider.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/widget/CompositorWidget.h" + +namespace mozilla::wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +/* static */ +UniquePtr RenderCompositorOGL::Create( + const RefPtr& aWidget, nsACString& aError) { + RefPtr gl = RenderThread::Get()->SingletonGL(); + if (!gl) { + gl = gl::GLContextProvider::CreateForCompositorWidget( + aWidget, /* aHardwareWebRender */ true, /* aForceAccelerated */ true); + RenderThread::MaybeEnableGLDebugMessage(gl); + } + if (!gl || !gl->MakeCurrent()) { + gfxCriticalNote << "Failed GL context creation for WebRender: " + << gfx::hexa(gl.get()); + return nullptr; + } + return MakeUnique(std::move(gl), aWidget); +} + +RenderCompositorOGL::RenderCompositorOGL( + RefPtr&& aGL, + const RefPtr& aWidget) + : RenderCompositor(aWidget), mGL(aGL) { + MOZ_ASSERT(mGL); + LOG("RenderCompositorOGL::RenderCompositorOGL()"); + + mIsEGL = aGL->GetContextType() == mozilla::gl::GLContextType::EGL; +} + +RenderCompositorOGL::~RenderCompositorOGL() { + LOG("RenderCompositorOGL::~RenderCompositorOGL()"); + + if (!mGL->MakeCurrent()) { + gfxCriticalNote + << "Failed to make render context current during destroying."; + // Leak resources! + return; + } +} + +bool RenderCompositorOGL::BeginFrame() { + if (!mGL->MakeCurrent()) { + gfxCriticalNote << "Failed to make render context current, can't draw."; + return false; + } + + mGL->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGL->GetDefaultFramebuffer()); + + return true; +} + +RenderedFrameId RenderCompositorOGL::EndFrame( + const nsTArray& aDirtyRects) { + RenderedFrameId frameId = GetNextRenderFrameId(); + if (UsePartialPresent() && aDirtyRects.Length() > 0) { + gfx::IntRegion bufferInvalid; + const auto bufferSize = GetBufferSize(); + for (const DeviceIntRect& rect : aDirtyRects) { + const auto left = std::max(0, std::min(bufferSize.width, rect.min.x)); + const auto top = std::max(0, std::min(bufferSize.height, rect.min.y)); + + const auto right = std::min(bufferSize.width, std::max(0, rect.max.x)); + const auto bottom = std::min(bufferSize.height, std::max(0, rect.max.y)); + + const auto width = right - left; + const auto height = bottom - top; + + bufferInvalid.OrWith( + gfx::IntRect(left, (GetBufferSize().height - bottom), width, height)); + } + gl()->SetDamage(bufferInvalid); + } + mGL->SwapBuffers(); + return frameId; +} + +void RenderCompositorOGL::Pause() {} + +bool RenderCompositorOGL::Resume() { return true; } + +LayoutDeviceIntSize RenderCompositorOGL::GetBufferSize() { + return mWidget->GetClientSize(); +} + +uint32_t RenderCompositorOGL::GetMaxPartialPresentRects() { + return gfx::gfxVars::WebRenderMaxPartialPresentRects(); +} + +bool RenderCompositorOGL::RequestFullRender() { return false; } + +bool RenderCompositorOGL::UsePartialPresent() { + return gfx::gfxVars::WebRenderMaxPartialPresentRects() > 0; +} + +bool RenderCompositorOGL::ShouldDrawPreviousPartialPresentRegions() { + return true; +} + +size_t RenderCompositorOGL::GetBufferAge() const { + if (!StaticPrefs:: + gfx_webrender_allow_partial_present_buffer_age_AtStartup()) { + return 0; + } + return gl()->GetBufferAge(); +} + +} // namespace mozilla::wr diff --git a/gfx/webrender_bindings/RenderCompositorOGL.h b/gfx/webrender_bindings/RenderCompositorOGL.h new file mode 100644 index 0000000000..78429a2db4 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorOGL.h @@ -0,0 +1,49 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_OGL_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_OGL_H + +#include "GLTypes.h" +#include "mozilla/webrender/RenderCompositor.h" + +namespace mozilla { +namespace wr { + +class RenderCompositorOGL : public RenderCompositor { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorOGL(RefPtr&& aGL, + const RefPtr& aWidget); + virtual ~RenderCompositorOGL(); + + bool BeginFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) final; + void Pause() override; + bool Resume() override; + + gl::GLContext* gl() const override { return mGL; } + + LayoutDeviceIntSize GetBufferSize() override; + + // Interface for partial present + bool UsePartialPresent() override; + bool RequestFullRender() override; + uint32_t GetMaxPartialPresentRects() override; + bool ShouldDrawPreviousPartialPresentRegions() override; + size_t GetBufferAge() const override; + + protected: + RefPtr mGL; + bool mIsEGL; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp b/gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp new file mode 100644 index 0000000000..d2d0cce016 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorOGLSWGL.cpp @@ -0,0 +1,508 @@ +/* -*- 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 "RenderCompositorOGLSWGL.h" + +#include "GLContext.h" +#include "GLContextEGL.h" +#include "mozilla/layers/BuildConstants.h" +#include "mozilla/layers/CompositorOGL.h" +#include "mozilla/layers/Effects.h" +#include "mozilla/layers/TextureHostOGL.h" +#include "mozilla/widget/CompositorWidget.h" +#include "OGLShaderProgram.h" + +#ifdef MOZ_WIDGET_ANDROID +# include "mozilla/java/GeckoSurfaceTextureWrappers.h" +# include "mozilla/layers/AndroidHardwareBuffer.h" +# include "mozilla/webrender/RenderAndroidHardwareBufferTextureHost.h" +# include "mozilla/webrender/RenderAndroidSurfaceTextureHost.h" +# include "mozilla/widget/AndroidCompositorWidget.h" +# include +# include +#endif + +#ifdef MOZ_WIDGET_GTK +# include "mozilla/widget/GtkCompositorWidget.h" +# include +# ifdef MOZ_X11 +# include +# endif +#endif + +namespace mozilla { +using namespace layers; +using namespace gfx; +namespace wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +UniquePtr RenderCompositorOGLSWGL::Create( + const RefPtr& aWidget, nsACString& aError) { + if (!aWidget->GetCompositorOptions().AllowSoftwareWebRenderOGL()) { + return nullptr; + } + + RefPtr compositor; +#ifdef MOZ_WIDGET_ANDROID + RefPtr context = + RenderThread::Get()->SingletonGLForCompositorOGL(); + if (!context) { + gfxCriticalNote << "SingletonGL does not exist for SWGL"; + return nullptr; + } + auto programs = RenderThread::Get()->GetProgramsForCompositorOGL(); + if (!programs) { + gfxCriticalNote << "Failed to get Programs for CompositorOGL for SWGL"; + return nullptr; + } + + nsCString log; + RefPtr compositorOGL; + compositorOGL = new CompositorOGL(aWidget, /* aSurfaceWidth */ -1, + /* aSurfaceHeight */ -1, + /* aUseExternalSurfaceSize */ true); + if (!compositorOGL->Initialize(context, programs, &log)) { + gfxCriticalNote << "Failed to initialize CompositorOGL for SWGL: " + << log.get(); + return nullptr; + } + compositor = compositorOGL; +#elif defined(MOZ_WIDGET_GTK) + nsCString log; + RefPtr compositorOGL; + compositorOGL = new CompositorOGL(aWidget); + if (!compositorOGL->Initialize(&log)) { + gfxCriticalNote << "Failed to initialize CompositorOGL for SWGL: " + << log.get(); + return nullptr; + } + compositor = compositorOGL; +#endif + + if (!compositor) { + return nullptr; + } + + void* ctx = wr_swgl_create_context(); + if (!ctx) { + gfxCriticalNote << "Failed SWGL context creation for WebRender"; + return nullptr; + } + + return MakeUnique(compositor, aWidget, ctx); +} + +RenderCompositorOGLSWGL::RenderCompositorOGLSWGL( + Compositor* aCompositor, const RefPtr& aWidget, + void* aContext) + : RenderCompositorLayersSWGL(aCompositor, aWidget, aContext) { + LOG("RenderCompositorOGLSWGL::RenderCompositorOGLSWGL()"); +} + +RenderCompositorOGLSWGL::~RenderCompositorOGLSWGL() { + LOG("RRenderCompositorOGLSWGL::~RenderCompositorOGLSWGL()"); +#ifdef MOZ_WIDGET_ANDROID + java::GeckoSurfaceTexture::DestroyUnused((int64_t)GetGLContext()); + DestroyEGLSurface(); +#endif +} + +gl::GLContext* RenderCompositorOGLSWGL::GetGLContext() { + return mCompositor->AsCompositorOGL()->gl(); +} + +bool RenderCompositorOGLSWGL::MakeCurrent() { + GetGLContext()->MakeCurrent(); +#ifdef MOZ_WIDGET_ANDROID + if (GetGLContext()->GetContextType() == gl::GLContextType::EGL) { + gl::GLContextEGL::Cast(GetGLContext())->SetEGLSurfaceOverride(mEGLSurface); + } +#endif + RenderCompositorLayersSWGL::MakeCurrent(); + return true; +} + +EGLSurface RenderCompositorOGLSWGL::CreateEGLSurface() { + MOZ_ASSERT(GetGLContext()->GetContextType() == gl::GLContextType::EGL); + + EGLSurface surface = EGL_NO_SURFACE; + surface = gl::GLContextEGL::CreateEGLSurfaceForCompositorWidget( + mWidget, gl::GLContextEGL::Cast(GetGLContext())->mSurfaceConfig); + if (surface == EGL_NO_SURFACE) { + const auto* renderThread = RenderThread::Get(); + gfxCriticalNote << "Failed to create EGLSurface. " + << renderThread->RendererCount() << " renderers, " + << renderThread->ActiveRendererCount() << " active."; + } + + // The subsequent render after creating a new surface must be a full render. + mFullRender = true; + + return surface; +} + +void RenderCompositorOGLSWGL::DestroyEGLSurface() { + MOZ_ASSERT(GetGLContext()->GetContextType() == gl::GLContextType::EGL); + + const auto& gle = gl::GLContextEGL::Cast(GetGLContext()); + const auto& egl = gle->mEgl; + + // Release EGLSurface of back buffer before calling ResizeBuffers(). + if (mEGLSurface) { + gle->SetEGLSurfaceOverride(EGL_NO_SURFACE); + gl::GLContextEGL::DestroySurface(*egl, mEGLSurface); + mEGLSurface = EGL_NO_SURFACE; + } +} + +bool RenderCompositorOGLSWGL::BeginFrame() { + MOZ_ASSERT(!mInFrame); + RenderCompositorLayersSWGL::BeginFrame(); + +#ifdef MOZ_WIDGET_ANDROID + java::GeckoSurfaceTexture::DestroyUnused((int64_t)GetGLContext()); + GetGLContext() + ->MakeCurrent(); // DestroyUnused can change the current context! +#endif + + return true; +} + +RenderedFrameId RenderCompositorOGLSWGL::EndFrame( + const nsTArray& aDirtyRects) { + mFullRender = false; + + return RenderCompositorLayersSWGL::EndFrame(aDirtyRects); +} + +void RenderCompositorOGLSWGL::HandleExternalImage( + RenderTextureHost* aExternalImage, FrameSurface& aFrameSurface) { + MOZ_ASSERT(aExternalImage); + +#ifdef MOZ_WIDGET_ANDROID + GLenum target = + LOCAL_GL_TEXTURE_EXTERNAL; // This is required by SurfaceTexture + GLenum wrapMode = LOCAL_GL_CLAMP_TO_EDGE; + + if (auto* host = aExternalImage->AsRenderAndroidSurfaceTextureHost()) { + host->UpdateTexImageIfNecessary(); + + // We need to hold the texture source separately from the effect, + // since the effect doesn't hold a strong reference. + RefPtr layer = new SurfaceTextureSource( + (TextureSourceProvider*)mCompositor, host->mSurfTex, host->mFormat, + target, wrapMode, host->mSize, host->mTransformOverride); + RefPtr texturedEffect = + CreateTexturedEffect(host->mFormat, layer, aFrameSurface.mFilter, + /* isAlphaPremultiplied */ true); + + gfx::Rect drawRect(0, 0, host->mSize.width, host->mSize.height); + + EffectChain effect; + effect.mPrimaryEffect = texturedEffect; + mCompositor->DrawQuad(drawRect, aFrameSurface.mClipRect, effect, 1.0, + aFrameSurface.mTransform, drawRect); + } else if (auto* host = + aExternalImage->AsRenderAndroidHardwareBufferTextureHost()) { + // We need to hold the texture source separately from the effect, + // since the effect doesn't hold a strong reference. + RefPtr layer = + new AndroidHardwareBufferTextureSource( + (TextureSourceProvider*)mCompositor, + host->GetAndroidHardwareBuffer(), + host->GetAndroidHardwareBuffer()->mFormat, target, wrapMode, + host->GetSize()); + RefPtr texturedEffect = CreateTexturedEffect( + host->GetAndroidHardwareBuffer()->mFormat, layer, aFrameSurface.mFilter, + /* isAlphaPremultiplied */ true); + + gfx::Rect drawRect(0, 0, host->GetSize().width, host->GetSize().height); + + EffectChain effect; + effect.mPrimaryEffect = texturedEffect; + mCompositor->DrawQuad(drawRect, aFrameSurface.mClipRect, effect, 1.0, + aFrameSurface.mTransform, drawRect); + } +#endif +} + +void RenderCompositorOGLSWGL::GetCompositorCapabilities( + CompositorCapabilities* aCaps) { + RenderCompositor::GetCompositorCapabilities(aCaps); + + // max_update_rects are not yet handled properly + aCaps->max_update_rects = 0; +} + +bool RenderCompositorOGLSWGL::RequestFullRender() { return mFullRender; } + +void RenderCompositorOGLSWGL::Pause() { +#ifdef MOZ_WIDGET_ANDROID + DestroyEGLSurface(); +#elif defined(MOZ_WIDGET_GTK) + mCompositor->Pause(); +#endif +} + +bool RenderCompositorOGLSWGL::Resume() { +#ifdef MOZ_WIDGET_ANDROID + // Destroy EGLSurface if it exists. + DestroyEGLSurface(); + + auto size = GetBufferSize(); + GLint maxTextureSize = 0; + GetGLContext()->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, + (GLint*)&maxTextureSize); + + // When window size is too big, hardware buffer allocation could fail. + if (maxTextureSize < size.width || maxTextureSize < size.height) { + gfxCriticalNote << "Too big ANativeWindow size(" << size.width << ", " + << size.height << ") MaxTextureSize " << maxTextureSize; + return false; + } + + mEGLSurface = CreateEGLSurface(); + if (mEGLSurface == EGL_NO_SURFACE) { + // Often when we fail to create an EGL surface it is because the + // Java Surface we have been provided is invalid. Therefore the on + // the first occurence we don't raise a WebRenderError and instead + // just return failure. This allows the widget a chance to request + // a new Java Surface. On subsequent failures, raising the + // WebRenderError will result in the compositor being recreated, + // falling back through webrender configurations, and eventually + // crashing if we still do not succeed. + if (!mHandlingNewSurfaceError) { + mHandlingNewSurfaceError = true; + } else { + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + } + return false; + } + mHandlingNewSurfaceError = false; + + gl::GLContextEGL::Cast(GetGLContext())->SetEGLSurfaceOverride(mEGLSurface); + mCompositor->SetDestinationSurfaceSize(size.ToUnknownSize()); +#elif defined(MOZ_WIDGET_GTK) + bool resumed = mCompositor->Resume(); + if (!resumed) { + RenderThread::Get()->HandleWebRenderError(WebRenderError::NEW_SURFACE); + return false; + } +#endif + return true; +} + +bool RenderCompositorOGLSWGL::IsPaused() { +#ifdef MOZ_WIDGET_ANDROID + return mEGLSurface == EGL_NO_SURFACE; +#endif + return false; +} + +LayoutDeviceIntSize RenderCompositorOGLSWGL::GetBufferSize() { + return mWidget->GetClientSize(); +} + +UniquePtr +RenderCompositorOGLSWGL::DoCreateTile(Surface* aSurface) { + auto source = MakeRefPtr( + mCompositor->AsCompositorOGL(), layers::TextureFlags::NO_FLAGS); + + return MakeUnique(std::move(source), aSurface->TileSize()); +} + +bool RenderCompositorOGLSWGL::MaybeReadback( + const gfx::IntSize& aReadbackSize, const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, bool* aNeedsYFlip) { +#ifdef MOZ_WIDGET_ANDROID + MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::RGBA8); + const GLenum format = LOCAL_GL_RGBA; +#else + MOZ_ASSERT(aReadbackFormat == wr::ImageFormat::BGRA8); + const GLenum format = LOCAL_GL_BGRA; +#endif + + GetGLContext()->fReadPixels(0, 0, aReadbackSize.width, aReadbackSize.height, + format, LOCAL_GL_UNSIGNED_BYTE, + &aReadbackBuffer[0]); + + if (aNeedsYFlip) { + *aNeedsYFlip = true; + } + + return true; +} + +// This is a DataSourceSurface that represents a 0-based PBO for GLTextureImage. +class PBOUnpackSurface : public gfx::DataSourceSurface { + public: + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PBOUnpackSurface, override) + + explicit PBOUnpackSurface(const gfx::IntSize& aSize) : mSize(aSize) {} + + uint8_t* GetData() override { return nullptr; } + int32_t Stride() override { return mSize.width * sizeof(uint32_t); } + gfx::SurfaceType GetType() const override { + return gfx::SurfaceType::DATA_ALIGNED; + } + gfx::IntSize GetSize() const override { return mSize; } + gfx::SurfaceFormat GetFormat() const override { + return gfx::SurfaceFormat::B8G8R8A8; + } + + // PBO offsets need to start from a 0 address, but DataSourceSurface::Map + // checks for failure by comparing the address against nullptr. Override Map + // to work around this. + bool Map(MapType, MappedSurface* aMappedSurface) override { + aMappedSurface->mData = GetData(); + aMappedSurface->mStride = Stride(); + return true; + } + + void Unmap() override {} + + private: + gfx::IntSize mSize; +}; + +RenderCompositorOGLSWGL::TileOGL::TileOGL( + RefPtr&& aTexture, + const gfx::IntSize& aSize) + : mTexture(aTexture) { + auto* gl = mTexture->gl(); + if (gl && gl->HasPBOState() && gl->MakeCurrent()) { + mSurface = new PBOUnpackSurface(aSize); + // Create a PBO large enough to encompass any valid rects within the tile. + gl->fGenBuffers(1, &mPBO); + gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mPBO); + gl->fBufferData(LOCAL_GL_PIXEL_UNPACK_BUFFER, + mSurface->Stride() * aSize.height, nullptr, + LOCAL_GL_DYNAMIC_DRAW); + gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0); + } else { + // Couldn't allocate a PBO, so just use a memory surface instead. + mSurface = gfx::Factory::CreateDataSourceSurface( + aSize, gfx::SurfaceFormat::B8G8R8A8); + } +} + +RenderCompositorOGLSWGL::TileOGL::~TileOGL() { + if (mPBO) { + auto* gl = mTexture->gl(); + if (gl && gl->MakeCurrent()) { + gl->fDeleteBuffers(1, &mPBO); + mPBO = 0; + } + } +} + +layers::DataTextureSource* +RenderCompositorOGLSWGL::TileOGL::GetTextureSource() { + return mTexture.get(); +} + +bool RenderCompositorOGLSWGL::TileOGL::Map(wr::DeviceIntRect aDirtyRect, + wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) { + if (mPBO) { + auto* gl = mTexture->gl(); + if (!gl) { + return false; + } + // Map the PBO, but only within the range of the buffer that spans from the + // linear start offset to the linear end offset. Since we don't care about + // the previous contents of the buffer, we can just tell OpenGL to + // invalidate the entire buffer, even though we're only mapping a sub-range. + gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mPBO); + size_t stride = mSurface->Stride(); + size_t offset = + stride * aValidRect.min.y + aValidRect.min.x * sizeof(uint32_t); + size_t length = stride * (aValidRect.height() - 1) + + (aValidRect.width()) * sizeof(uint32_t); + void* data = gl->fMapBufferRange( + LOCAL_GL_PIXEL_UNPACK_BUFFER, offset, length, + LOCAL_GL_MAP_WRITE_BIT | LOCAL_GL_MAP_INVALIDATE_BUFFER_BIT); + gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0); + if (!data) { + return false; + } + *aData = data; + *aStride = stride; + } else { + // No PBO is available, so just directly write to the memory surface. + gfx::DataSourceSurface::MappedSurface map; + if (!mSurface->Map(gfx::DataSourceSurface::READ_WRITE, &map)) { + return false; + } + // Verify that we're not somehow using a PBOUnpackSurface. + MOZ_ASSERT(map.mData != nullptr); + // glTex(Sub)Image on ES doesn't support arbitrary strides without + // the EXT_unpack_subimage extension. To avoid needing to make a + // copy of the data we'll always draw it with stride = bpp*width + // unless we're uploading the entire texture. + if (!mTexture->IsValid()) { + // If we don't have a texture we need to position our + // data in the correct spot because we're going to upload + // the entire surface + *aData = map.mData + aValidRect.min.y * map.mStride + + aValidRect.min.x * sizeof(uint32_t); + + *aStride = map.mStride; + mSubSurface = nullptr; + } else { + // Otherwise, we can just use the top left as a scratch space + *aData = map.mData; + *aStride = aDirtyRect.width() * BytesPerPixel(mSurface->GetFormat()); + mSubSurface = Factory::CreateWrappingDataSourceSurface( + (uint8_t*)*aData, *aStride, + IntSize(aDirtyRect.width(), aDirtyRect.height()), + mSurface->GetFormat()); + } + } + return true; +} + +void RenderCompositorOGLSWGL::TileOGL::Unmap(const gfx::IntRect& aDirtyRect) { + nsIntRegion dirty(aDirtyRect); + if (mPBO) { + // If there is a PBO, it must be unmapped before it can be sourced from. + // Leave the PBO bound before the call to Update so that the texture uploads + // will source from it. + auto* gl = mTexture->gl(); + if (!gl) { + return; + } + gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, mPBO); + gl->fUnmapBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER); + mTexture->Update(mSurface, &dirty); + gl->fBindBuffer(LOCAL_GL_PIXEL_UNPACK_BUFFER, 0); + } else { + if (mSubSurface) { + mSurface->Unmap(); + // Our subsurface has a stride = aDirtyRect.width + // We use a negative offset to move it to match + // the dirty rect's top-left. These two offsets + // will cancel each other out by the time we reach + // TexSubImage. + IntPoint srcOffset = {0, 0}; + IntPoint dstOffset = aDirtyRect.TopLeft(); + // adjust the dirty region to be relative to the dstOffset + dirty.MoveBy(-dstOffset); + mTexture->Update(mSubSurface, &dirty, &srcOffset, &dstOffset); + mSubSurface = nullptr; + } else { + mSurface->Unmap(); + mTexture->Update(mSurface, &dirty); + } + } +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderCompositorOGLSWGL.h b/gfx/webrender_bindings/RenderCompositorOGLSWGL.h new file mode 100644 index 0000000000..7752574311 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorOGLSWGL.h @@ -0,0 +1,104 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_OGL_SWGL_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_OGL_SWGL_H + +#include "mozilla/layers/Compositor.h" +#include "mozilla/webrender/RenderCompositorLayersSWGL.h" + +namespace mozilla { + +namespace layers { +class TextureImageTextureSourceOGL; +} + +namespace wr { + +class RenderCompositorOGLSWGL : public RenderCompositorLayersSWGL { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorOGLSWGL(layers::Compositor* aCompositor, + const RefPtr& aWidget, + void* aContext); + virtual ~RenderCompositorOGLSWGL(); + + gl::GLContext* GetGLContext(); + + bool MakeCurrent() override; + + bool BeginFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) override; + + void GetCompositorCapabilities(CompositorCapabilities* aCaps) override; + + // Returns true for requesting rendering during readback. + // RenderCompositorOGLSWGL::MaybeReadback() requests rendering. + // This value is not used by WebRender, since native compositor API is used + // for sw-wr. + bool UsePartialPresent() override { return true; } + bool RequestFullRender() override; + + void Pause() override; + bool Resume() override; + bool IsPaused() override; + + LayoutDeviceIntSize GetBufferSize() override; + + layers::WebRenderCompositor CompositorType() const override { + return layers::WebRenderCompositor::OPENGL; + } + + bool MaybeReadback(const gfx::IntSize& aReadbackSize, + const wr::ImageFormat& aReadbackFormat, + const Range& aReadbackBuffer, + bool* aNeedsYFlip) override; + + private: + void HandleExternalImage(RenderTextureHost* aExternalImage, + FrameSurface& aFrameSurface) override; + UniquePtr DoCreateTile( + Surface* aSurface) override; + + EGLSurface CreateEGLSurface(); + void DestroyEGLSurface(); + + EGLSurface mEGLSurface = EGL_NO_SURFACE; + bool mFullRender = false; + +#ifdef MOZ_WIDGET_ANDROID + // Whether we are in the process of handling a NEW_SURFACE error. On Android + // this is used to allow the widget an opportunity to recover from the first + // instance, before raising a WebRenderError on subsequent occurences. + bool mHandlingNewSurfaceError = false; +#endif + + class TileOGL : public RenderCompositorLayersSWGL::Tile { + public: + TileOGL(RefPtr&& aTexture, + const gfx::IntSize& aSize); + virtual ~TileOGL(); + + bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect, + void** aData, int32_t* aStride) override; + void Unmap(const gfx::IntRect& aDirtyRect) override; + layers::DataTextureSource* GetTextureSource() override; + bool IsValid() override { return true; } + + private: + RefPtr mTexture; + RefPtr mSurface; + RefPtr mSubSurface; + GLuint mPBO = 0; + }; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorRecordedFrame.h b/gfx/webrender_bindings/RenderCompositorRecordedFrame.h new file mode 100644 index 0000000000..f7a516107b --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorRecordedFrame.h @@ -0,0 +1,49 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_RECORDEDFRAME_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_RECORDEDFRAME_H + +#include "mozilla/layers/CompositionRecorder.h" + +namespace mozilla { + +namespace wr { + +class RenderCompositorRecordedFrame final : public layers::RecordedFrame { + public: + RenderCompositorRecordedFrame( + const TimeStamp& aTimeStamp, + RefPtr&& aBuffer) + : RecordedFrame(aTimeStamp), mBuffer(aBuffer) {} + + virtual already_AddRefed GetSourceSurface() override { + if (mSurface) { + return do_AddRef(mSurface); + } + + gfx::IntSize size = mBuffer->Size(); + mSurface = gfx::Factory::CreateDataSourceSurface( + size, gfx::SurfaceFormat::B8G8R8A8, + /* aZero = */ false); + + if (!mBuffer->MapAndCopyInto(mSurface, size)) { + mSurface = nullptr; + return nullptr; + } + + return do_AddRef(mSurface); + } + + private: + RefPtr mBuffer; + RefPtr mSurface; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderCompositorSWGL.cpp b/gfx/webrender_bindings/RenderCompositorSWGL.cpp new file mode 100644 index 0000000000..d767ff83f7 --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorSWGL.cpp @@ -0,0 +1,315 @@ +/* -*- 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 "RenderCompositorSWGL.h" + +#include "mozilla/gfx/Logging.h" +#include "mozilla/widget/CompositorWidget.h" + +#ifdef MOZ_WIDGET_GTK +# include "mozilla/WidgetUtilsGtk.h" +#endif + +namespace mozilla { +using namespace gfx; + +namespace wr { + +extern LazyLogModule gRenderThreadLog; +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +/* static */ +UniquePtr RenderCompositorSWGL::Create( + const RefPtr& aWidget, nsACString& aError) { + void* ctx = wr_swgl_create_context(); + if (!ctx) { + gfxCriticalNote << "Failed SWGL context creation for WebRender"; + return nullptr; + } + return MakeUnique(aWidget, ctx); +} + +RenderCompositorSWGL::RenderCompositorSWGL( + const RefPtr& aWidget, void* aContext) + : RenderCompositor(aWidget), mContext(aContext) { + MOZ_ASSERT(mContext); + LOG("RenderCompositorSWGL::RenderCompositorSWGL()"); +} + +RenderCompositorSWGL::~RenderCompositorSWGL() { + LOG("RenderCompositorSWGL::~RenderCompositorSWGL()"); + + wr_swgl_destroy_context(mContext); +} + +void RenderCompositorSWGL::ClearMappedBuffer() { + mMappedData = nullptr; + mMappedStride = 0; + mDT = nullptr; +} + +bool RenderCompositorSWGL::MakeCurrent() { + wr_swgl_make_current(mContext); + return true; +} + +bool RenderCompositorSWGL::BeginFrame() { + mRenderWidgetSize = Some(mWidget->GetClientSize()); +#ifdef MOZ_WIDGET_GTK + if (mLastRenderWidgetSize != mRenderWidgetSize.value()) { + mLastRenderWidgetSize = mRenderWidgetSize.value(); + mRequestFullRender = true; + } +#endif + // Set up a temporary region representing the entire window surface in case a + // dirty region is not supplied. + ClearMappedBuffer(); + mDirtyRegion = LayoutDeviceIntRect(LayoutDeviceIntPoint(), GetBufferSize()); + wr_swgl_make_current(mContext); + return true; +} + +bool RenderCompositorSWGL::AllocateMappedBuffer( + const wr::DeviceIntRect* aOpaqueRects, size_t aNumOpaqueRects) { + // Request a new draw target to use from the widget... + MOZ_ASSERT(!mDT); + layers::BufferMode bufferMode = layers::BufferMode::BUFFERED; + mDT = mWidget->StartRemoteDrawingInRegion(mDirtyRegion, &bufferMode); + if (!mDT) { + gfxCriticalNoteOnce + << "RenderCompositorSWGL failed mapping default framebuffer, no dt"; + return false; + } + // Attempt to lock the underlying buffer directly from the draw target. + // Verify that the size at least matches what the widget claims and that + // the format is BGRA8 as SWGL requires. + uint8_t* data = nullptr; + gfx::IntSize size; + int32_t stride = 0; + gfx::SurfaceFormat format = gfx::SurfaceFormat::UNKNOWN; + if (bufferMode != layers::BufferMode::BUFFERED && !mSurface && + mDT->LockBits(&data, &size, &stride, &format) && + (format != gfx::SurfaceFormat::B8G8R8A8 && + format != gfx::SurfaceFormat::B8G8R8X8)) { + // We tried to lock the DT and it succeeded, but the size or format + // of the data is not compatible, so just release it and fall back below... + mDT->ReleaseBits(data); + data = nullptr; + } + LayoutDeviceIntRect bounds = mDirtyRegion.GetBounds(); + // If locking succeeded above, just use that. + if (data) { + mMappedData = data; + mMappedStride = stride; + // Disambiguate whether the widget's draw target has its origin at zero or + // if it is offset to the dirty region origin. The DT might either enclose + // only the region itself, the region including the origin, or the entire + // widget. Thus, if the DT doesn't only enclose the region, we assume it + // contains the origin. + if (size != bounds.Size().ToUnknownSize()) { + // Update the bounds to include zero if the origin is at zero. + bounds.ExpandToEnclose(LayoutDeviceIntPoint(0, 0)); + } + // Sometimes we end up racing on the widget size, and it can shrink between + // BeginFrame and StartCompositing. We calculated our dirty region based on + // the previous widget size, so we need to clamp the bounds here to ensure + // we remain within the buffer. + bounds.IntersectRect( + bounds, + LayoutDeviceIntRect(bounds.TopLeft(), + LayoutDeviceIntSize(size.width, size.height))); + } else { + // If we couldn't lock the DT above, then allocate a data surface and map + // that for usage with SWGL. + size = bounds.Size().ToUnknownSize(); + if (!mSurface || mSurface->GetSize() != size) { + mSurface = gfx::Factory::CreateDataSourceSurface( + size, gfx::SurfaceFormat::B8G8R8A8); + } + gfx::DataSourceSurface::MappedSurface map = {nullptr, 0}; + if (!mSurface || !mSurface->Map(gfx::DataSourceSurface::READ_WRITE, &map)) { + // We failed mapping the data surface, so need to cancel the frame. + mWidget->EndRemoteDrawingInRegion(mDT, mDirtyRegion); + ClearMappedBuffer(); + gfxCriticalNoteOnce + << "RenderCompositorSWGL failed mapping default framebuffer, no surf"; + return false; + } + mMappedData = map.mData; + mMappedStride = map.mStride; + } + MOZ_ASSERT(mMappedData != nullptr && mMappedStride > 0); + wr_swgl_init_default_framebuffer(mContext, bounds.x, bounds.y, bounds.width, + bounds.height, mMappedStride, mMappedData); + + LayoutDeviceIntRegion opaque; + for (size_t i = 0; i < aNumOpaqueRects; i++) { + const auto& rect = aOpaqueRects[i]; + opaque.OrWith(LayoutDeviceIntRect(rect.min.x, rect.min.y, rect.width(), + rect.height())); + } + + LayoutDeviceIntRegion clear = mWidget->GetTransparentRegion(); + clear.AndWith(mDirtyRegion); + clear.SubOut(opaque); + for (auto iter = clear.RectIter(); !iter.Done(); iter.Next()) { + const auto& rect = iter.Get(); + wr_swgl_clear_color_rect(mContext, 0, rect.x, rect.y, rect.width, + rect.height, 0, 0, 0, 0); + } + + return true; +} + +void RenderCompositorSWGL::StartCompositing( + wr::ColorF aClearColor, const wr::DeviceIntRect* aDirtyRects, + size_t aNumDirtyRects, const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects) { + if (mDT) { + // Cancel any existing buffers that might accidentally be left from updates + CommitMappedBuffer(false); + // Reset the region to the widget bounds + mDirtyRegion = LayoutDeviceIntRect(LayoutDeviceIntPoint(), GetBufferSize()); + } + if (aNumDirtyRects) { + // Install the dirty rects into the bounds of the existing region + auto bounds = mDirtyRegion.GetBounds(); + mDirtyRegion.SetEmpty(); + for (size_t i = 0; i < aNumDirtyRects; i++) { + const auto& rect = aDirtyRects[i]; + mDirtyRegion.OrWith(LayoutDeviceIntRect(rect.min.x, rect.min.y, + rect.width(), rect.height())); + } + // Ensure the region lies within the widget bounds + mDirtyRegion.AndWith(bounds); + } + // Now that the dirty rects have been supplied and the composition region + // is known, allocate and install a framebuffer encompassing the composition + // region. + if (mDirtyRegion.IsEmpty() || + !AllocateMappedBuffer(aOpaqueRects, aNumOpaqueRects)) { + // If allocation of the mapped default framebuffer failed, then just install + // a temporary framebuffer (with a minimum size of 2x2) so compositing can + // still proceed. + auto bounds = mDirtyRegion.GetBounds(); + bounds.width = std::max(bounds.width, 2); + bounds.height = std::max(bounds.height, 2); + wr_swgl_init_default_framebuffer(mContext, bounds.x, bounds.y, bounds.width, + bounds.height, 0, nullptr); + } +} + +void RenderCompositorSWGL::CommitMappedBuffer(bool aDirty) { + if (!mDT) { + mDirtyRegion.SetEmpty(); + return; + } + // Force any delayed clears to resolve. + if (aDirty) { + wr_swgl_resolve_framebuffer(mContext, 0); + } + // Clear out the old framebuffer in case something tries to access it after + // the frame. + wr_swgl_init_default_framebuffer(mContext, 0, 0, 0, 0, 0, nullptr); + // If we have a draw target at this point, mapping must have succeeded. + MOZ_ASSERT(mMappedData != nullptr); + if (mSurface) { + // If we're using a data surface, unmap it and draw it to the DT if there + // are any supplied dirty rects. + mSurface->Unmap(); + if (aDirty) { + // The temporary source surface is always a partial region of the widget + // that is offset from the origin to the actual bounds of the dirty + // region. The destination DT may also be an offset partial region, but we + // must check to see if its size matches the region bounds to verify this. + LayoutDeviceIntRect bounds = mDirtyRegion.GetBounds(); + gfx::IntPoint srcOffset = bounds.TopLeft().ToUnknownPoint(); + gfx::IntPoint dstOffset = mDT->GetSize() == bounds.Size().ToUnknownSize() + ? srcOffset + : gfx::IntPoint(0, 0); + for (auto iter = mDirtyRegion.RectIter(); !iter.Done(); iter.Next()) { + gfx::IntRect dirtyRect = iter.Get().ToUnknownRect(); + mDT->CopySurface(mSurface, dirtyRect - srcOffset, + dirtyRect.TopLeft() - dstOffset); + } + } + } else { + // Otherwise, we had locked the DT directly. Just release the data. + mDT->ReleaseBits(mMappedData); + } + mDT->Flush(); + + // Done with the DT. Hand it back to the widget and clear out any trace of it. + mWidget->EndRemoteDrawingInRegion(mDT, mDirtyRegion); + mDirtyRegion.SetEmpty(); + ClearMappedBuffer(); +} + +void RenderCompositorSWGL::CancelFrame() { + CommitMappedBuffer(false); + mRenderWidgetSize = Nothing(); +} + +RenderedFrameId RenderCompositorSWGL::EndFrame( + const nsTArray& aDirtyRects) { + // Dirty rects have already been set inside StartCompositing. We need to keep + // those dirty rects exactly the same here so we supply the same exact region + // to EndRemoteDrawingInRegion as for StartRemoteDrawingInRegion. + RenderedFrameId frameId = GetNextRenderFrameId(); + CommitMappedBuffer(); + mRenderWidgetSize = Nothing(); + return frameId; +} + +bool RenderCompositorSWGL::RequestFullRender() { +#ifdef MOZ_WIDGET_ANDROID + // XXX Add partial present support. + return true; +#endif +#ifdef MOZ_WIDGET_GTK + // We're requested to do full render after Resume() on Wayland. + if (mRequestFullRender) { + mRequestFullRender = false; + return true; + } +#endif + return false; +} + +void RenderCompositorSWGL::Pause() {} + +bool RenderCompositorSWGL::Resume() { +#ifdef MOZ_WIDGET_GTK + mRequestFullRender = true; +#endif + return true; +} + +LayoutDeviceIntSize RenderCompositorSWGL::GetBufferSize() { + // If we're between BeginFrame() and EndFrame()/CancelFrame() calls + // return recent rendering size instead of actual underlying widget + // size. It prevents possible rendering artifacts if widget size was changed. + return mRenderWidgetSize ? mRenderWidgetSize.value() + : mWidget->GetClientSize(); +} + +void RenderCompositorSWGL::GetCompositorCapabilities( + CompositorCapabilities* aCaps) { + // Always support a single update rect for SwCompositor + aCaps->max_update_rects = 1; + + // On uncomposited desktops such as X11 without compositor or Window 7 with + // Aero disabled we need to force a full redraw when the window contents may + // be damaged. +#ifdef MOZ_WIDGET_GTK + aCaps->redraw_on_invalidation = widget::GdkIsX11Display(); +#else + aCaps->redraw_on_invalidation = true; +#endif +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderCompositorSWGL.h b/gfx/webrender_bindings/RenderCompositorSWGL.h new file mode 100644 index 0000000000..ad1db8faaf --- /dev/null +++ b/gfx/webrender_bindings/RenderCompositorSWGL.h @@ -0,0 +1,90 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_SWGL_H +#define MOZILLA_GFX_RENDERCOMPOSITOR_SWGL_H + +#include "mozilla/gfx/2D.h" +#include "mozilla/webrender/RenderCompositor.h" + +namespace mozilla { + +namespace wr { + +class RenderCompositorSWGL : public RenderCompositor { + public: + static UniquePtr Create( + const RefPtr& aWidget, nsACString& aError); + + RenderCompositorSWGL(const RefPtr& aWidget, + void* aContext); + virtual ~RenderCompositorSWGL(); + + void* swgl() const override { return mContext; } + + bool MakeCurrent() override; + + bool BeginFrame() override; + void CancelFrame() override; + RenderedFrameId EndFrame(const nsTArray& aDirtyRects) final; + + void StartCompositing(wr::ColorF aClearColor, + const wr::DeviceIntRect* aDirtyRects, + size_t aNumDirtyRects, + const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects) override; + + bool UsePartialPresent() override { return true; } + bool RequestFullRender() override; + + 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; + + bool SupportsExternalBufferTextures() const override { return true; } + + // Interface for wr::Compositor + void GetCompositorCapabilities(CompositorCapabilities* aCaps) override; + + private: + void* mContext = nullptr; + RefPtr mDT; + LayoutDeviceIntRegion mDirtyRegion; + // Keep consistent buffer size between BeginFrame and EndFrame/CancelFrame + // calls to make sure we don't change buffer size during rendering. + Maybe mRenderWidgetSize; + RefPtr mSurface; + uint8_t* mMappedData = nullptr; + int32_t mMappedStride = 0; +#ifdef MOZ_WIDGET_GTK + // On Wayland we need to request full render if widget size is changed + // because SW rendering backend reallocates and clears target surface. + LayoutDeviceIntSize mLastRenderWidgetSize; + bool mRequestFullRender = false; +#endif + + void ClearMappedBuffer(); + + bool AllocateMappedBuffer(const wr::DeviceIntRect* aOpaqueRects, + size_t aNumOpaqueRects); + + void CommitMappedBuffer(bool aDirty = true); +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RenderD3D11TextureHost.cpp b/gfx/webrender_bindings/RenderD3D11TextureHost.cpp new file mode 100644 index 0000000000..451d0d9072 --- /dev/null +++ b/gfx/webrender_bindings/RenderD3D11TextureHost.cpp @@ -0,0 +1,775 @@ +/* -*- 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 "RenderD3D11TextureHost.h" + +#include "GLContextEGL.h" +#include "GLLibraryEGL.h" +#include "RenderThread.h" +#include "RenderCompositor.h" +#include "RenderCompositorD3D11SWGL.h" +#include "ScopedGLHelpers.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/gfx/CanvasManagerParent.h" +#include "mozilla/gfx/DeviceManagerDx.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/FenceD3D11.h" +#include "mozilla/layers/GpuProcessD3D11QueryMap.h" +#include "mozilla/layers/GpuProcessD3D11TextureMap.h" +#include "mozilla/layers/TextureD3D11.h" + +namespace mozilla { +namespace wr { + +RenderDXGITextureHost::RenderDXGITextureHost( + RefPtr aHandle, + Maybe& aGpuProcessTextureId, + uint32_t aArrayIndex, gfx::SurfaceFormat aFormat, + gfx::ColorSpace2 aColorSpace, gfx::ColorRange aColorRange, + gfx::IntSize aSize, bool aHasKeyedMutex, gfx::FenceInfo& aAcquireFenceInfo, + Maybe& aGpuProcessQueryId) + : mHandle(aHandle), + mGpuProcessTextureId(aGpuProcessTextureId), + mGpuProcessQueryId(aGpuProcessQueryId), + mArrayIndex(aArrayIndex), + mSurface(0), + mStream(0), + mTextureHandle{0}, + mFormat(aFormat), + mColorSpace(aColorSpace), + mColorRange(aColorRange), + mSize(aSize), + mHasKeyedMutex(aHasKeyedMutex), + mAcquireFenceInfo(aAcquireFenceInfo), + mLocked(false) { + MOZ_COUNT_CTOR_INHERITED(RenderDXGITextureHost, RenderTextureHost); + MOZ_ASSERT((mFormat != gfx::SurfaceFormat::NV12 && + mFormat != gfx::SurfaceFormat::P010 && + mFormat != gfx::SurfaceFormat::P016) || + (mSize.width % 2 == 0 && mSize.height % 2 == 0)); + MOZ_ASSERT((aHandle && aGpuProcessTextureId.isNothing()) || + (!aHandle && aGpuProcessTextureId.isSome())); +} + +RenderDXGITextureHost::~RenderDXGITextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderDXGITextureHost, RenderTextureHost); + DeleteTextureHandle(); +} + +RefPtr RenderDXGITextureHost::GetQuery() { + if (mGpuProcessQueryId.isNothing()) { + return nullptr; + } + + auto* queryMap = layers::GpuProcessD3D11QueryMap::Get(); + if (!queryMap) { + return nullptr; + } + + auto query = queryMap->GetQuery(mGpuProcessQueryId.ref()); + if (!query) { + gfxCriticalNoteOnce << "Failed to get ID3D11Query"; + } + + return query; +} + +ID3D11Texture2D* RenderDXGITextureHost::GetD3D11Texture2DWithGL() { + if (mTexture) { + return mTexture; + } + + if (!mGL) { + // SingletonGL is always used on Windows with ANGLE. + mGL = RenderThread::Get()->SingletonGL(); + } + + if (!EnsureD3D11Texture2DWithGL()) { + return nullptr; + } + + return mTexture; +} + +size_t RenderDXGITextureHost::GetPlaneCount() const { + if (mFormat == gfx::SurfaceFormat::NV12 || + mFormat == gfx::SurfaceFormat::P010 || + mFormat == gfx::SurfaceFormat::P016) { + return 2; + } + return 1; +} + +template +static bool MapTexture(T* aHost, RenderCompositor* aCompositor, + RefPtr& aTexture, + RefPtr& aDeviceContext, + RefPtr& aCpuTexture, + D3D11_MAPPED_SUBRESOURCE& aMappedSubresource) { + if (!aCompositor) { + return false; + } + + RenderCompositorD3D11SWGL* compositor = + aCompositor->AsRenderCompositorD3D11SWGL(); + if (!compositor) { + return false; + } + + if (!aHost->EnsureD3D11Texture2D(compositor->GetDevice())) { + return false; + } + + if (!aHost->LockInternal()) { + return false; + } + + D3D11_TEXTURE2D_DESC textureDesc = {0}; + aTexture->GetDesc(&textureDesc); + + compositor->GetDevice()->GetImmediateContext(getter_AddRefs(aDeviceContext)); + + textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + textureDesc.Usage = D3D11_USAGE_STAGING; + textureDesc.BindFlags = 0; + textureDesc.MiscFlags = 0; + textureDesc.MipLevels = 1; + HRESULT hr = compositor->GetDevice()->CreateTexture2D( + &textureDesc, nullptr, getter_AddRefs(aCpuTexture)); + if (FAILED(hr)) { + return false; + } + + aDeviceContext->CopyResource(aCpuTexture, aTexture); + aHost->Unlock(); + + hr = aDeviceContext->Map(aCpuTexture, 0, D3D11_MAP_READ, 0, + &aMappedSubresource); + return SUCCEEDED(hr); +} + +bool RenderDXGITextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + // TODO: We currently readback from the GPU texture into a new + // staging texture every time this is mapped. We might be better + // off retaining the mapped memory to trade performance for memory + // usage. + if (!mCpuTexture && !MapTexture(this, aCompositor, mTexture, mDeviceContext, + mCpuTexture, mMappedSubresource)) { + return false; + } + + aPlaneInfo.mSize = GetSize(aChannelIndex); + aPlaneInfo.mStride = mMappedSubresource.RowPitch; + aPlaneInfo.mData = mMappedSubresource.pData; + + // If this is the second plane, then offset the data pointer by the + // size of the first plane. + if (aChannelIndex == 1) { + aPlaneInfo.mData = + (uint8_t*)aPlaneInfo.mData + aPlaneInfo.mStride * GetSize(0).height; + } + return true; +} + +void RenderDXGITextureHost::UnmapPlanes() { + mMappedSubresource.pData = nullptr; + if (mCpuTexture) { + mDeviceContext->Unmap(mCpuTexture, 0); + mCpuTexture = nullptr; + } + mDeviceContext = nullptr; +} + +bool RenderDXGITextureHost::EnsureD3D11Texture2DWithGL() { + if (mTexture) { + return true; + } + + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + + // Fetch the D3D11 device. + EGLDeviceEXT eglDevice = nullptr; + egl->fQueryDisplayAttribEXT(LOCAL_EGL_DEVICE_EXT, (EGLAttrib*)&eglDevice); + MOZ_ASSERT(eglDevice); + ID3D11Device* device = nullptr; + egl->mLib->fQueryDeviceAttribEXT(eglDevice, LOCAL_EGL_D3D11_DEVICE_ANGLE, + (EGLAttrib*)&device); + // There's a chance this might fail if we end up on d3d9 angle for some + // reason. + if (!device) { + gfxCriticalNote << "RenderDXGITextureHost device is not available"; + return false; + } + + return EnsureD3D11Texture2D(device); +} + +bool RenderDXGITextureHost::EnsureD3D11Texture2D(ID3D11Device* aDevice) { + if (mTexture) { + RefPtr device; + mTexture->GetDevice(getter_AddRefs(device)); + if (aDevice != device) { + gfxCriticalNote << "RenderDXGITextureHost uses obsoleted device"; + return false; + } + return true; + } + + if (mGpuProcessTextureId.isSome()) { + auto* textureMap = layers::GpuProcessD3D11TextureMap::Get(); + if (textureMap) { + RefPtr texture; + textureMap->WaitTextureReady(mGpuProcessTextureId.ref()); + mTexture = textureMap->GetTexture(mGpuProcessTextureId.ref()); + if (mTexture) { + return true; + } else { + gfxCriticalNote << "GpuProcessTextureId is not valid"; + } + } + return false; + } + + RefPtr device1; + aDevice->QueryInterface((ID3D11Device1**)getter_AddRefs(device1)); + if (!device1) { + gfxCriticalNoteOnce << "Failed to get ID3D11Device1"; + return 0; + } + + // Get the D3D11 texture from shared handle. + HRESULT hr = device1->OpenSharedResource1( + (HANDLE)mHandle->GetHandle(), __uuidof(ID3D11Texture2D), + (void**)(ID3D11Texture2D**)getter_AddRefs(mTexture)); + if (FAILED(hr)) { + MOZ_ASSERT(false, + "RenderDXGITextureHost::EnsureLockable(): Failed to open shared " + "texture"); + gfxCriticalNote + << "RenderDXGITextureHost Failed to open shared texture, hr=" + << gfx::hexa(hr); + return false; + } + MOZ_ASSERT(mTexture.get()); + mTexture->QueryInterface((IDXGIKeyedMutex**)getter_AddRefs(mKeyedMutex)); + + MOZ_ASSERT(mHasKeyedMutex == !!mKeyedMutex); + if (mHasKeyedMutex != !!mKeyedMutex) { + gfxCriticalNoteOnce << "KeyedMutex mismatch"; + } + return true; +} + +bool RenderDXGITextureHost::EnsureLockable() { + if (mTextureHandle[0]) { + return true; + } + + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + + // We use EGLStream to get the converted gl handle from d3d texture. The + // NV_stream_consumer_gltexture_yuv and ANGLE_stream_producer_d3d_texture + // could support nv12 and rgb d3d texture format. + if (!egl->IsExtensionSupported( + gl::EGLExtension::NV_stream_consumer_gltexture_yuv) || + !egl->IsExtensionSupported( + gl::EGLExtension::ANGLE_stream_producer_d3d_texture)) { + gfxCriticalNote << "RenderDXGITextureHost egl extensions are not suppored"; + return false; + } + + // Get the D3D11 texture from shared handle. + if (!EnsureD3D11Texture2DWithGL()) { + return false; + } + + // Create the EGLStream. + mStream = egl->fCreateStreamKHR(nullptr); + MOZ_ASSERT(mStream); + + bool ok = true; + if (mFormat != gfx::SurfaceFormat::NV12 && + mFormat != gfx::SurfaceFormat::P010 && + mFormat != gfx::SurfaceFormat::P016) { + // The non-nv12 format. + + mGL->fGenTextures(1, mTextureHandle); + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, + LOCAL_GL_TEXTURE_EXTERNAL_OES, + mTextureHandle[0]); + ok &= + bool(egl->fStreamConsumerGLTextureExternalAttribsNV(mStream, nullptr)); + ok &= bool(egl->fCreateStreamProducerD3DTextureANGLE(mStream, nullptr)); + } else { + // The nv12/p016 format. + + // Setup the NV12 stream consumer/producer. + EGLAttrib consumerAttributes[] = { + LOCAL_EGL_COLOR_BUFFER_TYPE, + LOCAL_EGL_YUV_BUFFER_EXT, + LOCAL_EGL_YUV_NUMBER_OF_PLANES_EXT, + 2, + LOCAL_EGL_YUV_PLANE0_TEXTURE_UNIT_NV, + 0, + LOCAL_EGL_YUV_PLANE1_TEXTURE_UNIT_NV, + 1, + LOCAL_EGL_NONE, + }; + mGL->fGenTextures(2, mTextureHandle); + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, + LOCAL_GL_TEXTURE_EXTERNAL_OES, + mTextureHandle[0]); + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE1, + LOCAL_GL_TEXTURE_EXTERNAL_OES, + mTextureHandle[1]); + ok &= bool(egl->fStreamConsumerGLTextureExternalAttribsNV( + mStream, consumerAttributes)); + ok &= bool(egl->fCreateStreamProducerD3DTextureANGLE(mStream, nullptr)); + } + + const EGLAttrib frameAttributes[] = { + LOCAL_EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, + static_cast(mArrayIndex), + LOCAL_EGL_NONE, + }; + + // Insert the d3d texture. + ok &= bool(egl->fStreamPostD3DTextureANGLE(mStream, (void*)mTexture.get(), + frameAttributes)); + + if (!ok) { + gfxCriticalNote << "RenderDXGITextureHost init stream failed"; + DeleteTextureHandle(); + return false; + } + + // Now, we could get the gl handle from the stream. + MOZ_ALWAYS_TRUE(egl->fStreamConsumerAcquireKHR(mStream)); + + return true; +} + +wr::WrExternalImage RenderDXGITextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (mGL.get() != aGL) { + // Release the texture handle in the previous gl context. + DeleteTextureHandle(); + mGL = aGL; + } + + if (!mGL) { + // XXX Software WebRender is not handled yet. + // Software WebRender does not provide GLContext + gfxCriticalNoteOnce + << "Software WebRender is not suppored by RenderDXGITextureHost."; + return InvalidToWrExternalImage(); + } + + if (!EnsureLockable()) { + return InvalidToWrExternalImage(); + } + + if (!LockInternal()) { + return InvalidToWrExternalImage(); + } + + const auto uvs = GetUvCoords(GetSize(aChannelIndex)); + return NativeTextureToWrExternalImage(GetGLHandle(aChannelIndex), uvs.first.x, + uvs.first.y, uvs.second.x, + uvs.second.y); +} + +bool RenderDXGITextureHost::LockInternal() { + if (!mLocked) { + if (mAcquireFenceInfo.mFenceHandle) { + if (!mAcquireFence) { + mAcquireFence = layers::FenceD3D11::CreateFromHandle( + mAcquireFenceInfo.mFenceHandle); + } + if (mAcquireFence) { + MOZ_ASSERT(mAcquireFenceInfo.mFenceHandle == mAcquireFence->mHandle); + + mAcquireFence->Update(mAcquireFenceInfo.mFenceValue); + RefPtr d3d11Device = + gfx::DeviceManagerDx::Get()->GetCompositorDevice(); + mAcquireFence->Wait(d3d11Device); + } + } + if (mKeyedMutex) { + HRESULT hr = mKeyedMutex->AcquireSync(0, 10000); + if (hr != S_OK) { + gfxCriticalError() << "RenderDXGITextureHost AcquireSync timeout, hr=" + << gfx::hexa(hr); + return false; + } + } + mLocked = true; + } + return true; +} + +void RenderDXGITextureHost::Unlock() { + if (mLocked) { + if (mKeyedMutex) { + mKeyedMutex->ReleaseSync(0); + } + mLocked = false; + } +} + +void RenderDXGITextureHost::ClearCachedResources() { + DeleteTextureHandle(); + mGL = nullptr; +} + +void RenderDXGITextureHost::DeleteTextureHandle() { + if (mTextureHandle[0] == 0) { + return; + } + + MOZ_ASSERT(mGL.get()); + if (!mGL) { + return; + } + + if (mGL->MakeCurrent()) { + mGL->fDeleteTextures(2, mTextureHandle); + + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + if (mSurface) { + egl->fDestroySurface(mSurface); + } + if (mStream) { + egl->fDestroyStreamKHR(mStream); + } + } + + for (int i = 0; i < 2; ++i) { + mTextureHandle[i] = 0; + } + + mTexture = nullptr; + mKeyedMutex = nullptr; + mSurface = 0; + mStream = 0; +} + +GLuint RenderDXGITextureHost::GetGLHandle(uint8_t aChannelIndex) const { + MOZ_ASSERT(((mFormat == gfx::SurfaceFormat::NV12 || + mFormat == gfx::SurfaceFormat::P010 || + mFormat == gfx::SurfaceFormat::P016) && + aChannelIndex < 2) || + aChannelIndex < 1); + return mTextureHandle[aChannelIndex]; +} + +gfx::IntSize RenderDXGITextureHost::GetSize(uint8_t aChannelIndex) const { + MOZ_ASSERT(((mFormat == gfx::SurfaceFormat::NV12 || + mFormat == gfx::SurfaceFormat::P010 || + mFormat == gfx::SurfaceFormat::P016) && + aChannelIndex < 2) || + aChannelIndex < 1); + + if (aChannelIndex == 0) { + return mSize; + } else { + // The CbCr channel size is a half of Y channel size in NV12 format. + return mSize / 2; + } +} + +bool RenderDXGITextureHost::SyncObjectNeeded() { + return mGpuProcessTextureId.isNothing() && !mHasKeyedMutex && + !mAcquireFenceInfo.mFenceHandle; +} + +RenderDXGIYCbCrTextureHost::RenderDXGIYCbCrTextureHost( + RefPtr (&aHandles)[3], + gfx::YUVColorSpace aYUVColorSpace, gfx::ColorDepth aColorDepth, + gfx::ColorRange aColorRange, gfx::IntSize aSizeY, gfx::IntSize aSizeCbCr) + : mHandles{aHandles[0], aHandles[1], aHandles[2]}, + mSurfaces{0}, + mStreams{0}, + mTextureHandles{0}, + mYUVColorSpace(aYUVColorSpace), + mColorDepth(aColorDepth), + mColorRange(aColorRange), + mSizeY(aSizeY), + mSizeCbCr(aSizeCbCr), + mLocked(false) { + MOZ_COUNT_CTOR_INHERITED(RenderDXGIYCbCrTextureHost, RenderTextureHost); + // Assume the chroma planes are rounded up if the luma plane is odd sized. + MOZ_ASSERT((mSizeCbCr.width == mSizeY.width || + mSizeCbCr.width == (mSizeY.width + 1) >> 1) && + (mSizeCbCr.height == mSizeY.height || + mSizeCbCr.height == (mSizeY.height + 1) >> 1)); + MOZ_ASSERT(aHandles[0] && aHandles[1] && aHandles[2]); +} + +bool RenderDXGIYCbCrTextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + D3D11_MAPPED_SUBRESOURCE mappedSubresource; + if (!MapTexture(this, aCompositor, mTextures[aChannelIndex], mDeviceContext, + mCpuTexture[aChannelIndex], mappedSubresource)) { + return false; + } + + aPlaneInfo.mSize = GetSize(aChannelIndex); + aPlaneInfo.mStride = mappedSubresource.RowPitch; + aPlaneInfo.mData = mappedSubresource.pData; + return true; +} + +void RenderDXGIYCbCrTextureHost::UnmapPlanes() { + for (uint32_t i = 0; i < 3; i++) { + if (mCpuTexture[i]) { + mDeviceContext->Unmap(mCpuTexture[i], 0); + mCpuTexture[i] = nullptr; + } + } + mDeviceContext = nullptr; +} + +RenderDXGIYCbCrTextureHost::~RenderDXGIYCbCrTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderDXGIYCbCrTextureHost, RenderTextureHost); + DeleteTextureHandle(); +} + +bool RenderDXGIYCbCrTextureHost::EnsureLockable() { + if (mTextureHandles[0]) { + return true; + } + + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + + // The eglCreatePbufferFromClientBuffer doesn't support R8 format, so we + // use EGLStream to get the converted gl handle from d3d R8 texture. + + if (!egl->IsExtensionSupported( + gl::EGLExtension::NV_stream_consumer_gltexture_yuv) || + !egl->IsExtensionSupported( + gl::EGLExtension::ANGLE_stream_producer_d3d_texture)) { + gfxCriticalNote + << "RenderDXGIYCbCrTextureHost egl extensions are not suppored"; + return false; + } + + // Fetch the D3D11 device. + EGLDeviceEXT eglDevice = nullptr; + egl->fQueryDisplayAttribEXT(LOCAL_EGL_DEVICE_EXT, (EGLAttrib*)&eglDevice); + MOZ_ASSERT(eglDevice); + ID3D11Device* device = nullptr; + egl->mLib->fQueryDeviceAttribEXT(eglDevice, LOCAL_EGL_D3D11_DEVICE_ANGLE, + (EGLAttrib*)&device); + // There's a chance this might fail if we end up on d3d9 angle for some + // reason. + if (!device) { + gfxCriticalNote << "RenderDXGIYCbCrTextureHost device is not available"; + return false; + } + + if (!EnsureD3D11Texture2D(device)) { + return false; + } + + mGL->fGenTextures(3, mTextureHandles); + bool ok = true; + for (int i = 0; i < 3; ++i) { + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0 + i, + LOCAL_GL_TEXTURE_EXTERNAL_OES, + mTextureHandles[i]); + + // Create the EGLStream. + mStreams[i] = egl->fCreateStreamKHR(nullptr); + MOZ_ASSERT(mStreams[i]); + + ok &= bool( + egl->fStreamConsumerGLTextureExternalAttribsNV(mStreams[i], nullptr)); + ok &= bool(egl->fCreateStreamProducerD3DTextureANGLE(mStreams[i], nullptr)); + + // Insert the R8 texture. + ok &= bool(egl->fStreamPostD3DTextureANGLE( + mStreams[i], (void*)mTextures[i].get(), nullptr)); + + // Now, we could get the R8 gl handle from the stream. + MOZ_ALWAYS_TRUE(egl->fStreamConsumerAcquireKHR(mStreams[i])); + } + + if (!ok) { + gfxCriticalNote << "RenderDXGIYCbCrTextureHost init stream failed"; + DeleteTextureHandle(); + return false; + } + + return true; +} + +bool RenderDXGIYCbCrTextureHost::EnsureD3D11Texture2D(ID3D11Device* aDevice) { + RefPtr device1; + aDevice->QueryInterface((ID3D11Device1**)getter_AddRefs(device1)); + if (!device1) { + gfxCriticalNoteOnce << "Failed to get ID3D11Device1"; + return false; + } + + if (mTextures[0]) { + RefPtr device; + mTextures[0]->GetDevice(getter_AddRefs(device)); + if (aDevice != device) { + gfxCriticalNote << "RenderDXGIYCbCrTextureHost uses obsoleted device"; + return false; + } + } + + if (mTextureHandles[0]) { + return true; + } + + for (int i = 0; i < 3; ++i) { + // Get the R8 D3D11 texture from shared handle. + HRESULT hr = device1->OpenSharedResource1( + (HANDLE)mHandles[i]->GetHandle(), __uuidof(ID3D11Texture2D), + (void**)(ID3D11Texture2D**)getter_AddRefs(mTextures[i])); + if (FAILED(hr)) { + NS_WARNING( + "RenderDXGIYCbCrTextureHost::EnsureLockable(): Failed to open " + "shared " + "texture"); + gfxCriticalNote + << "RenderDXGIYCbCrTextureHost Failed to open shared texture, hr=" + << gfx::hexa(hr); + return false; + } + } + + for (int i = 0; i < 3; ++i) { + mTextures[i]->QueryInterface( + (IDXGIKeyedMutex**)getter_AddRefs(mKeyedMutexs[i])); + } + return true; +} + +bool RenderDXGIYCbCrTextureHost::LockInternal() { + if (!mLocked) { + if (mKeyedMutexs[0]) { + for (const auto& mutex : mKeyedMutexs) { + HRESULT hr = mutex->AcquireSync(0, 10000); + if (hr != S_OK) { + gfxCriticalError() + << "RenderDXGIYCbCrTextureHost AcquireSync timeout, hr=" + << gfx::hexa(hr); + return false; + } + } + } + mLocked = true; + } + return true; +} + +wr::WrExternalImage RenderDXGIYCbCrTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (mGL.get() != aGL) { + // Release the texture handle in the previous gl context. + DeleteTextureHandle(); + mGL = aGL; + } + + if (!mGL) { + // XXX Software WebRender is not handled yet. + // Software WebRender does not provide GLContext + gfxCriticalNoteOnce << "Software WebRender is not suppored by " + "RenderDXGIYCbCrTextureHost."; + return InvalidToWrExternalImage(); + } + + if (!EnsureLockable()) { + return InvalidToWrExternalImage(); + } + + if (!LockInternal()) { + return InvalidToWrExternalImage(); + } + + const auto uvs = GetUvCoords(GetSize(aChannelIndex)); + return NativeTextureToWrExternalImage(GetGLHandle(aChannelIndex), uvs.first.x, + uvs.first.y, uvs.second.x, + uvs.second.y); +} + +void RenderDXGIYCbCrTextureHost::Unlock() { + if (mLocked) { + if (mKeyedMutexs[0]) { + for (const auto& mutex : mKeyedMutexs) { + mutex->ReleaseSync(0); + } + } + mLocked = false; + } +} + +void RenderDXGIYCbCrTextureHost::ClearCachedResources() { + DeleteTextureHandle(); + mGL = nullptr; +} + +GLuint RenderDXGIYCbCrTextureHost::GetGLHandle(uint8_t aChannelIndex) const { + MOZ_ASSERT(aChannelIndex < 3); + + return mTextureHandles[aChannelIndex]; +} + +gfx::IntSize RenderDXGIYCbCrTextureHost::GetSize(uint8_t aChannelIndex) const { + MOZ_ASSERT(aChannelIndex < 3); + + if (aChannelIndex == 0) { + return mSizeY; + } else { + return mSizeCbCr; + } +} + +void RenderDXGIYCbCrTextureHost::DeleteTextureHandle() { + if (mTextureHandles[0] == 0) { + return; + } + + MOZ_ASSERT(mGL.get()); + if (!mGL) { + return; + } + + if (mGL->MakeCurrent()) { + mGL->fDeleteTextures(3, mTextureHandles); + + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + for (int i = 0; i < 3; ++i) { + mTextureHandles[i] = 0; + mTextures[i] = nullptr; + mKeyedMutexs[i] = nullptr; + + if (mSurfaces[i]) { + egl->fDestroySurface(mSurfaces[i]); + mSurfaces[i] = 0; + } + if (mStreams[i]) { + egl->fDestroyStreamKHR(mStreams[i]); + mStreams[i] = 0; + } + } + } +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderD3D11TextureHost.h b/gfx/webrender_bindings/RenderD3D11TextureHost.h new file mode 100644 index 0000000000..a46b5f3fb5 --- /dev/null +++ b/gfx/webrender_bindings/RenderD3D11TextureHost.h @@ -0,0 +1,230 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERD3D11TEXTUREHOST_H +#define MOZILLA_GFX_RENDERD3D11TEXTUREHOST_H + +#include + +#include "GLTypes.h" +#include "mozilla/gfx/FileHandleWrapper.h" +#include "RenderTextureHostSWGL.h" + +struct ID3D11Texture2D; +struct IDXGIKeyedMutex; + +namespace mozilla { + +namespace layers { +class FenceD3D11; +} // namespace layers + +namespace wr { + +class RenderDXGITextureHost final : public RenderTextureHostSWGL { + public: + RenderDXGITextureHost( + RefPtr aHandle, + Maybe& aGpuProcessTextureId, + uint32_t aArrayIndex, gfx::SurfaceFormat aFormat, gfx::ColorSpace2, + gfx::ColorRange aColorRange, gfx::IntSize aSize, bool aHasKeyedMutex, + gfx::FenceInfo& aAcquireFenceInfo, + Maybe& aGpuProcessQueryId); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + void ClearCachedResources() override; + + gfx::IntSize GetSize(uint8_t aChannelIndex) const; + GLuint GetGLHandle(uint8_t aChannelIndex) const; + + bool SyncObjectNeeded() override; + + RenderDXGITextureHost* AsRenderDXGITextureHost() override { return this; } + + gfx::ColorRange GetColorRange() const { return mColorRange; } + + ID3D11Texture2D* GetD3D11Texture2DWithGL(); + ID3D11Texture2D* GetD3D11Texture2D() { return mTexture; } + + // RenderTextureHostSWGL + gfx::SurfaceFormat GetFormat() const override { return mFormat; } + gfx::ColorDepth GetColorDepth() const override { + if (mFormat == gfx::SurfaceFormat::P010) { + return gfx::ColorDepth::COLOR_10; + } + if (mFormat == gfx::SurfaceFormat::P016) { + return gfx::ColorDepth::COLOR_16; + } + return gfx::ColorDepth::COLOR_8; + } + size_t GetPlaneCount() const override; + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + void UnmapPlanes() override; + gfx::YUVRangedColorSpace GetYUVColorSpace() const override { + return ToYUVRangedColorSpace(ToYUVColorSpace(mColorSpace), mColorRange); + } + + bool EnsureD3D11Texture2D(ID3D11Device* aDevice); + bool LockInternal(); + + size_t Bytes() override { + size_t bytes = 0; + + size_t bpp = GetPlaneCount() > 1 + ? (GetColorDepth() == gfx::ColorDepth::COLOR_8 ? 1 : 2) + : 4; + + for (size_t i = 0; i < GetPlaneCount(); i++) { + gfx::IntSize size = GetSize(i); + bytes += size.width * size.height * bpp; + } + return bytes; + } + + uint32_t ArrayIndex() const { return mArrayIndex; } + + void SetIsSoftwareDecodedVideo() override { mIsSoftwareDecodedVideo = true; } + bool IsSoftwareDecodedVideo() override { return mIsSoftwareDecodedVideo; } + + RefPtr GetQuery(); + + private: + virtual ~RenderDXGITextureHost(); + + bool EnsureD3D11Texture2DWithGL(); + bool EnsureLockable(); + + void DeleteTextureHandle(); + + RefPtr mGL; + + RefPtr mHandle; + Maybe mGpuProcessTextureId; + Maybe mGpuProcessQueryId; + RefPtr mTexture; + uint32_t mArrayIndex = 0; + RefPtr mKeyedMutex; + + // Temporary state between MapPlane and UnmapPlanes. + RefPtr mDeviceContext; + RefPtr mCpuTexture; + D3D11_MAPPED_SUBRESOURCE mMappedSubresource; + + EGLSurface mSurface; + EGLStreamKHR mStream; + + // We could use NV12 format for this texture. So, we might have 2 gl texture + // handles for Y and CbCr data. + GLuint mTextureHandle[2]; + + bool mIsSoftwareDecodedVideo = false; + + RefPtr mAcquireFence; + + public: + const gfx::SurfaceFormat mFormat; + const gfx::ColorSpace2 mColorSpace; + const gfx::ColorRange mColorRange; + const gfx::IntSize mSize; + const bool mHasKeyedMutex; + const gfx::FenceInfo mAcquireFenceInfo; + + private: + bool mLocked; +}; + +class RenderDXGIYCbCrTextureHost final : public RenderTextureHostSWGL { + public: + explicit RenderDXGIYCbCrTextureHost( + RefPtr (&aHandles)[3], + gfx::YUVColorSpace aYUVColorSpace, gfx::ColorDepth aColorDepth, + gfx::ColorRange aColorRange, gfx::IntSize aSizeY, gfx::IntSize aSizeCbCr); + + RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() override { + return this; + } + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + void ClearCachedResources() override; + + gfx::IntSize GetSize(uint8_t aChannelIndex) const; + GLuint GetGLHandle(uint8_t aChannelIndex) const; + + bool SyncObjectNeeded() override { return true; } + + gfx::ColorRange GetColorRange() const { return mColorRange; } + + // RenderTextureHostSWGL + gfx::SurfaceFormat GetFormat() const override { + return gfx::SurfaceFormat::YUV; + } + gfx::ColorDepth GetColorDepth() const override { return mColorDepth; } + size_t GetPlaneCount() const override { return 3; } + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + void UnmapPlanes() override; + gfx::YUVRangedColorSpace GetYUVColorSpace() const override { + return ToYUVRangedColorSpace(mYUVColorSpace, GetColorRange()); + } + + bool EnsureD3D11Texture2D(ID3D11Device* aDevice); + bool LockInternal(); + + ID3D11Texture2D* GetD3D11Texture2D(uint8_t aChannelIndex) { + return mTextures[aChannelIndex]; + } + + size_t Bytes() override { + size_t bytes = 0; + + size_t bpp = mColorDepth == gfx::ColorDepth::COLOR_8 ? 1 : 2; + + for (size_t i = 0; i < GetPlaneCount(); i++) { + gfx::IntSize size = GetSize(i); + bytes += size.width * size.height * bpp; + } + return bytes; + } + + private: + virtual ~RenderDXGIYCbCrTextureHost(); + + bool EnsureLockable(); + + void DeleteTextureHandle(); + + RefPtr mGL; + + RefPtr mHandles[3]; + RefPtr mTextures[3]; + RefPtr mKeyedMutexs[3]; + + EGLSurface mSurfaces[3]; + EGLStreamKHR mStreams[3]; + + // The gl handles for Y, Cb and Cr data. + GLuint mTextureHandles[3]; + + // Temporary state between MapPlane and UnmapPlanes. + RefPtr mDeviceContext; + RefPtr mCpuTexture[3]; + + gfx::YUVColorSpace mYUVColorSpace; + gfx::ColorDepth mColorDepth; + gfx::ColorRange mColorRange; + gfx::IntSize mSizeY; + gfx::IntSize mSizeCbCr; + + bool mLocked; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERD3D11TEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderDMABUFTextureHost.cpp b/gfx/webrender_bindings/RenderDMABUFTextureHost.cpp new file mode 100644 index 0000000000..f52535b95a --- /dev/null +++ b/gfx/webrender_bindings/RenderDMABUFTextureHost.cpp @@ -0,0 +1,67 @@ +/* -*- 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 "RenderDMABUFTextureHost.h" + +#include "GLContextEGL.h" +#include "mozilla/gfx/Logging.h" +#include "ScopedGLHelpers.h" + +namespace mozilla::wr { + +RenderDMABUFTextureHost::RenderDMABUFTextureHost(DMABufSurface* aSurface) + : mSurface(aSurface) { + MOZ_COUNT_CTOR_INHERITED(RenderDMABUFTextureHost, RenderTextureHost); +} + +RenderDMABUFTextureHost::~RenderDMABUFTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderDMABUFTextureHost, RenderTextureHost); + DeleteTextureHandle(); +} + +wr::WrExternalImage RenderDMABUFTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (mGL.get() != aGL) { + if (mGL) { + // This should not happen. EGLImage is created only in + // parent process. + MOZ_ASSERT_UNREACHABLE("Unexpected GL context"); + return InvalidToWrExternalImage(); + } + mGL = aGL; + } + + if (!mGL || !mGL->MakeCurrent()) { + return InvalidToWrExternalImage(); + } + + if (!mSurface->GetTexture(aChannelIndex)) { + if (!mSurface->CreateTexture(mGL, aChannelIndex)) { + return InvalidToWrExternalImage(); + } + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, LOCAL_GL_TEXTURE_2D, + mSurface->GetTexture(aChannelIndex)); + } + + const auto uvs = GetUvCoords(gfx::IntSize( + mSurface->GetWidth(aChannelIndex), mSurface->GetHeight(aChannelIndex))); + return NativeTextureToWrExternalImage(mSurface->GetTexture(aChannelIndex), + uvs.first.x, uvs.first.y, uvs.second.x, + uvs.second.y); +} + +void RenderDMABUFTextureHost::Unlock() {} + +void RenderDMABUFTextureHost::DeleteTextureHandle() { + mSurface->ReleaseTextures(); +} + +void RenderDMABUFTextureHost::ClearCachedResources() { + DeleteTextureHandle(); + mGL = nullptr; +} + +} // namespace mozilla::wr diff --git a/gfx/webrender_bindings/RenderDMABUFTextureHost.h b/gfx/webrender_bindings/RenderDMABUFTextureHost.h new file mode 100644 index 0000000000..a38eeaf596 --- /dev/null +++ b/gfx/webrender_bindings/RenderDMABUFTextureHost.h @@ -0,0 +1,46 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERDMABUFTEXTUREHOST_H +#define MOZILLA_GFX_RENDERDMABUFTEXTUREHOST_H + +#include "mozilla/layers/TextureHostOGL.h" +#include "RenderTextureHost.h" +#include "mozilla/widget/DMABufSurface.h" + +namespace mozilla { + +namespace layers { +class SurfaceDescriptorDMABuf; +} + +namespace wr { + +class RenderDMABUFTextureHost final : public RenderTextureHost { + public: + explicit RenderDMABUFTextureHost(DMABufSurface* aSurface); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + void ClearCachedResources() override; + + size_t Bytes() override { + return mSurface->GetWidth() * mSurface->GetHeight() * + BytesPerPixel(mSurface->GetFormat()); + } + + private: + virtual ~RenderDMABUFTextureHost(); + void DeleteTextureHandle(); + + RefPtr mSurface; + RefPtr mGL; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERDMABUFTEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp new file mode 100644 index 0000000000..51e12d6ace --- /dev/null +++ b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.cpp @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "RenderDcompSurfaceTextureHost.h" + +#include + +#define LOG(msg, ...) \ + MOZ_LOG(gDcompSurface, LogLevel::Debug, \ + ("RenderDcompSurfaceTextureHost=%p, handle=%p, size=[%u,%u] " msg, \ + this, this->mHandle, this->mSize.Width(), this->mSize.Height(), \ + ##__VA_ARGS__)) + +namespace mozilla::wr { + +RenderDcompSurfaceTextureHost::RenderDcompSurfaceTextureHost( + HANDLE aHandle, gfx::IntSize aSize, gfx::SurfaceFormat aFormat) + : mHandle(aHandle), mSize(aSize), mFormat(aFormat) { + MOZ_ASSERT(aHandle && aHandle != INVALID_HANDLE_VALUE); +} + +IDCompositionSurface* RenderDcompSurfaceTextureHost::CreateSurfaceFromDevice( + IDCompositionDevice* aDevice) { + // Already created surface, no need to recreate it again. + if (mDcompSurface) { + return mDcompSurface; + } + + auto* surface = + static_cast(getter_AddRefs(mDcompSurface)); + auto hr = aDevice->CreateSurfaceFromHandle( + mHandle, reinterpret_cast(surface)); + if (FAILED(hr)) { + LOG("Failed to create surface from Dcomp handle %p, hr=%lx", mHandle, hr); + return nullptr; + } + LOG("Created surface %p correctly", surface); + return mDcompSurface; +} + +} // namespace mozilla::wr + +#undef LOG diff --git a/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h new file mode 100644 index 0000000000..7533e7c75f --- /dev/null +++ b/gfx/webrender_bindings/RenderDcompSurfaceTextureHost.h @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: ; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#ifndef MOZILLA_GFX_RENDERDCOMPSURFACETEXTUREHOST_H +#define MOZILLA_GFX_RENDERDCOMPSURFACETEXTUREHOST_H + +#include "GLTypes.h" +#include "RenderTextureHostSWGL.h" +#include "mozilla/webrender/RenderThread.h" + +struct IDCompositionDevice; +struct IDCompositionSurface; + +inline mozilla::LazyLogModule gDcompSurface("DcompSurface"); + +namespace mozilla::wr { + +/** + * A render texture host is responsible to create a dcomp surface from an + * existing dcomp handle. Currently usage is that MF media engine will create + * a surface handle from another remote process, and we reconstruct the surface + * and use it in the DCLayerTree in the GPU process. + */ +class RenderDcompSurfaceTextureHost final : public RenderTextureHostSWGL { + public: + RenderDcompSurfaceTextureHost(HANDLE aHandle, gfx::IntSize aSize, + gfx::SurfaceFormat aFormat); + + // RenderTextureHost + RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() override { + return this; + } + + // RenderTextureHostSWGL + gfx::SurfaceFormat GetFormat() const override { return mFormat; } + gfx::ColorDepth GetColorDepth() const override { + return gfx::ColorDepth::COLOR_8; + } + size_t GetPlaneCount() const override { return 1; } + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override { + return false; + } + void UnmapPlanes() override {} + gfx::YUVRangedColorSpace GetYUVColorSpace() const override { + return gfx::YUVRangedColorSpace::GbrIdentity; + } + size_t Bytes() override { return 0; } + + gfx::IntSize GetSize() const { return mSize; }; + + HANDLE GetDcompSurfaceHandle() const { return mHandle; } + + // Not thread-safe. They should only be called on the renderer thread on the + // GPU process. + IDCompositionSurface* CreateSurfaceFromDevice(IDCompositionDevice* aDevice); + IDCompositionSurface* GetSurface() const { return mDcompSurface; }; + + private: + const HANDLE mHandle; + const gfx::IntSize mSize; + const gfx::SurfaceFormat mFormat; + RefPtr mDcompSurface; +}; + +} // namespace mozilla::wr + +#endif // MOZILLA_GFX_RENDERDCOMPSURFACETEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderEGLImageTextureHost.cpp b/gfx/webrender_bindings/RenderEGLImageTextureHost.cpp new file mode 100644 index 0000000000..6ca9e74072 --- /dev/null +++ b/gfx/webrender_bindings/RenderEGLImageTextureHost.cpp @@ -0,0 +1,96 @@ +/* -*- 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 "RenderEGLImageTextureHost.h" + +#include "mozilla/gfx/Logging.h" +#include "GLContextEGL.h" +#include "GLLibraryEGL.h" + +namespace mozilla { +namespace wr { + +RenderEGLImageTextureHost::RenderEGLImageTextureHost(EGLImage aImage, + EGLSync aSync, + gfx::IntSize aSize) + : mImage(aImage), + mSync(aSync), + mSize(aSize), + mTextureTarget(LOCAL_GL_TEXTURE_2D), + mTextureHandle(0) { + MOZ_COUNT_CTOR_INHERITED(RenderEGLImageTextureHost, RenderTextureHost); +} + +RenderEGLImageTextureHost::~RenderEGLImageTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderEGLImageTextureHost, RenderTextureHost); + DeleteTextureHandle(); +} + +wr::WrExternalImage RenderEGLImageTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + MOZ_ASSERT(aChannelIndex == 0); + + if (mGL.get() != aGL) { + if (mGL) { + // This should not happen. SharedSurface_EGLImage is created only in + // parent process. + MOZ_ASSERT_UNREACHABLE("Unexpected GL context"); + return InvalidToWrExternalImage(); + } + mGL = aGL; + } + + if (!mImage || !mGL || !mGL->MakeCurrent()) { + return InvalidToWrExternalImage(); + } + + EGLint status = LOCAL_EGL_CONDITION_SATISFIED; + if (mSync) { + const auto& gle = gl::GLContextEGL::Cast(mGL); + const auto& egl = gle->mEgl; + MOZ_ASSERT(egl->IsExtensionSupported(gl::EGLExtension::KHR_fence_sync)); + status = egl->fClientWaitSync(mSync, 0, LOCAL_EGL_FOREVER); + // We do not need to delete sync here. It is deleted by + // SharedSurface_EGLImage. + mSync = 0; + } + + if (status != LOCAL_EGL_CONDITION_SATISFIED) { + MOZ_ASSERT( + status != 0, + "ClientWaitSync generated an error. Has mSync already been destroyed?"); + return InvalidToWrExternalImage(); + } + + if (!mTextureHandle) { + mTextureTarget = mGL->GetPreferredEGLImageTextureTarget(); + MOZ_ASSERT(mTextureTarget == LOCAL_GL_TEXTURE_2D || + mTextureTarget == LOCAL_GL_TEXTURE_EXTERNAL); + + mGL->fGenTextures(1, &mTextureHandle); + ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0, mTextureTarget, + mTextureHandle); + mGL->fEGLImageTargetTexture2D(mTextureTarget, mImage); + } + + const auto uvs = GetUvCoords(mSize); + return NativeTextureToWrExternalImage( + mTextureHandle, uvs.first.x, uvs.first.y, uvs.second.x, uvs.second.y); +} + +void RenderEGLImageTextureHost::Unlock() {} + +void RenderEGLImageTextureHost::DeleteTextureHandle() { + if (mTextureHandle) { + // XXX recycle gl texture, since SharedSurface_EGLImage and + // RenderEGLImageTextureHost is not recycled. + mGL->fDeleteTextures(1, &mTextureHandle); + mTextureHandle = 0; + } +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderEGLImageTextureHost.h b/gfx/webrender_bindings/RenderEGLImageTextureHost.h new file mode 100644 index 0000000000..c2d1b512d2 --- /dev/null +++ b/gfx/webrender_bindings/RenderEGLImageTextureHost.h @@ -0,0 +1,46 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDEREGLIMAGETEXTUREHOST_H +#define MOZILLA_GFX_RENDEREGLIMAGETEXTUREHOST_H + +#include "mozilla/layers/TextureHostOGL.h" +#include "RenderTextureHost.h" + +namespace mozilla { + +namespace wr { + +// RenderEGLImageTextureHost is created only for SharedSurface_EGLImage that is +// created in parent process. +class RenderEGLImageTextureHost final : public RenderTextureHost { + public: + RenderEGLImageTextureHost(EGLImage aImage, EGLSync aSync, gfx::IntSize aSize); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + size_t Bytes() override { + // XXX: we don't have a format so we can't get bpp. + return mSize.width * mSize.height; + } + + private: + virtual ~RenderEGLImageTextureHost(); + void DeleteTextureHandle(); + + const EGLImage mImage; + EGLSync mSync; + const gfx::IntSize mSize; + + RefPtr mGL; + GLenum mTextureTarget; + GLuint mTextureHandle; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDEREGLIMAGETEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderExternalTextureHost.cpp b/gfx/webrender_bindings/RenderExternalTextureHost.cpp new file mode 100644 index 0000000000..db8107ff0a --- /dev/null +++ b/gfx/webrender_bindings/RenderExternalTextureHost.cpp @@ -0,0 +1,265 @@ +/* -*- 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 "RenderExternalTextureHost.h" + +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/ImageDataSerializer.h" + +#include "GLContext.h" + +namespace mozilla { +namespace wr { + +RenderExternalTextureHost::RenderExternalTextureHost( + uint8_t* aBuffer, const layers::BufferDescriptor& aDescriptor) + : mBuffer(aBuffer), + mDescriptor(aDescriptor), + mInitialized(false), + mTextureUpdateNeeded(true) { + MOZ_COUNT_CTOR_INHERITED(RenderExternalTextureHost, RenderTextureHost); + + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: { + const layers::YCbCrDescriptor& ycbcr = mDescriptor.get_YCbCrDescriptor(); + mSize = ycbcr.display().Size(); + mFormat = gfx::SurfaceFormat::YUV; + break; + } + case layers::BufferDescriptor::TRGBDescriptor: { + const layers::RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor(); + mSize = rgb.size(); + mFormat = rgb.format(); + break; + } + default: + gfxCriticalError() << "Bad buffer host descriptor " + << (int)mDescriptor.type(); + MOZ_CRASH("GFX: Bad descriptor"); + } +} + +RenderExternalTextureHost::~RenderExternalTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderExternalTextureHost, RenderTextureHost); + + if (NS_WARN_IF(!IsReadyForDeletion())) { + gfxCriticalNote << "RenderExternalTextureHost sync failed"; + } + + DeleteTextures(); +} + +bool RenderExternalTextureHost::CreateSurfaces() { + if (!IsYUV()) { + mSurfaces[0] = gfx::Factory::CreateWrappingDataSourceSurface( + GetBuffer(), + layers::ImageDataSerializer::GetRGBStride( + mDescriptor.get_RGBDescriptor()), + mSize, mFormat); + } else { + const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + const gfx::SurfaceFormat surfaceFormat = + SurfaceFormatForColorDepth(desc.colorDepth()); + auto cbcrSize = layers::ImageDataSerializer::GetCroppedCbCrSize(desc); + + mSurfaces[0] = gfx::Factory::CreateWrappingDataSourceSurface( + layers::ImageDataSerializer::GetYChannel(GetBuffer(), desc), + desc.yStride(), desc.display().Size(), surfaceFormat); + mSurfaces[1] = gfx::Factory::CreateWrappingDataSourceSurface( + layers::ImageDataSerializer::GetCbChannel(GetBuffer(), desc), + desc.cbCrStride(), cbcrSize, surfaceFormat); + mSurfaces[2] = gfx::Factory::CreateWrappingDataSourceSurface( + layers::ImageDataSerializer::GetCrChannel(GetBuffer(), desc), + desc.cbCrStride(), cbcrSize, surfaceFormat); + } + + for (size_t i = 0; i < PlaneCount(); ++i) { + if (NS_WARN_IF(!mSurfaces[i])) { + gfxCriticalNote << "Surface is null"; + return false; + } + } + + return true; +} + +void RenderExternalTextureHost::DeleteSurfaces() { + for (size_t i = 0; i < PlaneCount(); ++i) { + mSurfaces[i] = nullptr; + } +} + +void RenderExternalTextureHost::DeleteTextures() { + for (size_t i = 0; i < PlaneCount(); ++i) { + mTextureSources[i] = nullptr; + mImages[i] = InvalidToWrExternalImage(); + } +} + +bool RenderExternalTextureHost::InitializeIfNeeded() { + if (mInitialized) { + return true; + } + + if (!GetBuffer()) { + // We hit some problems to get the shmem. + gfxCriticalNote << "GetBuffer Failed"; + return false; + } + + if (!CreateSurfaces()) { + DeleteSurfaces(); + return false; + } + + mInitialized = true; + return mInitialized; +} + +bool RenderExternalTextureHost::IsReadyForDeletion() { + if (!mInitialized) { + return true; + } + + auto& textureSource = mTextureSources[0]; + if (textureSource) { + return textureSource->Sync(false); + } + + return true; +} + +wr::WrExternalImage RenderExternalTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (mGL.get() != aGL) { + mGL = aGL; + mGL->MakeCurrent(); + } + + if (!mGL || !mGL->MakeCurrent()) { + return InvalidToWrExternalImage(); + } + + if (!InitializeIfNeeded()) { + return InvalidToWrExternalImage(); + } + + UpdateTextures(); + return mImages[aChannelIndex]; +} + +void RenderExternalTextureHost::PrepareForUse() { mTextureUpdateNeeded = true; } + +void RenderExternalTextureHost::Unlock() {} + +void RenderExternalTextureHost::UpdateTexture(size_t aIndex) { + MOZ_ASSERT(mSurfaces[aIndex]); + + auto& texture = mTextureSources[aIndex]; + + if (texture) { + texture->Update(mSurfaces[aIndex]); + } else { + texture = new layers::DirectMapTextureSource(mGL, mSurfaces[aIndex]); + + const GLuint handle = texture->GetTextureHandle(); + const auto uvs = GetUvCoords(texture->GetSize()); + mImages[aIndex] = NativeTextureToWrExternalImage( + handle, uvs.first.x, uvs.first.y, uvs.second.x, uvs.second.y); + } + + MOZ_ASSERT(mGL->GetError() == LOCAL_GL_NO_ERROR); +} + +void RenderExternalTextureHost::UpdateTextures() { + if (!mTextureUpdateNeeded) { + // Nothing to do here. + return; + } + + for (size_t i = 0; i < PlaneCount(); ++i) { + UpdateTexture(i); + } + + mTextureSources[0]->MaybeFenceTexture(); + mTextureUpdateNeeded = false; +} + +size_t RenderExternalTextureHost::GetPlaneCount() const { return PlaneCount(); } + +gfx::SurfaceFormat RenderExternalTextureHost::GetFormat() const { + return mFormat; +} + +gfx::ColorDepth RenderExternalTextureHost::GetColorDepth() const { + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: + return mDescriptor.get_YCbCrDescriptor().colorDepth(); + default: + return gfx::ColorDepth::COLOR_8; + } +} + +gfx::YUVRangedColorSpace RenderExternalTextureHost::GetYUVColorSpace() const { + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: + return gfx::GetYUVRangedColorSpace(mDescriptor.get_YCbCrDescriptor()); + default: + return gfx::YUVRangedColorSpace::Default; + } +} + +bool RenderExternalTextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + if (!mBuffer) { + // We hit some problems to get the shmem. + gfxCriticalNote << "GetBuffer Failed"; + return false; + } + + switch (mDescriptor.type()) { + case layers::BufferDescriptor::TYCbCrDescriptor: { + const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + switch (aChannelIndex) { + case 0: + aPlaneInfo.mData = + layers::ImageDataSerializer::GetYChannel(mBuffer, desc); + aPlaneInfo.mStride = desc.yStride(); + aPlaneInfo.mSize = desc.display().Size(); + break; + case 1: + aPlaneInfo.mData = + layers::ImageDataSerializer::GetCbChannel(mBuffer, desc); + aPlaneInfo.mStride = desc.cbCrStride(); + aPlaneInfo.mSize = + layers::ImageDataSerializer::GetCroppedCbCrSize(desc); + break; + case 2: + aPlaneInfo.mData = + layers::ImageDataSerializer::GetCrChannel(mBuffer, desc); + aPlaneInfo.mStride = desc.cbCrStride(); + aPlaneInfo.mSize = + layers::ImageDataSerializer::GetCroppedCbCrSize(desc); + break; + } + break; + } + default: { + const layers::RGBDescriptor& desc = mDescriptor.get_RGBDescriptor(); + aPlaneInfo.mData = mBuffer; + aPlaneInfo.mStride = layers::ImageDataSerializer::GetRGBStride(desc); + aPlaneInfo.mSize = desc.size(); + break; + } + } + return true; +} + +void RenderExternalTextureHost::UnmapPlanes() {} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderExternalTextureHost.h b/gfx/webrender_bindings/RenderExternalTextureHost.h new file mode 100644 index 0000000000..c3b13250c1 --- /dev/null +++ b/gfx/webrender_bindings/RenderExternalTextureHost.h @@ -0,0 +1,81 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDEREXTERNALTEXTUREHOST_H +#define MOZILLA_GFX_RENDEREXTERNALTEXTUREHOST_H + +#include "mozilla/layers/TextureHostOGL.h" +#include "RenderTextureHostSWGL.h" + +namespace mozilla { +namespace wr { + +/** + * RenderExternalTextureHost manages external textures used by WebRender on Mac. + * The motivation for this is to be able to use Apple Client Storage OpenGL + * extension, which makes it possible to avoid some copies during texture + * upload. This is especially helpful for high resolution video. + */ +class RenderExternalTextureHost final : public RenderTextureHostSWGL { + public: + RenderExternalTextureHost(uint8_t* aBuffer, + const layers::BufferDescriptor& aDescriptor); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + void PrepareForUse() override; + size_t Bytes() override { + return mSize.width * mSize.height * BytesPerPixel(mFormat); + } + + // RenderTextureHostSWGL + size_t GetPlaneCount() const override; + + gfx::SurfaceFormat GetFormat() const override; + + gfx::ColorDepth GetColorDepth() const override; + + gfx::YUVRangedColorSpace GetYUVColorSpace() const override; + + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + + void UnmapPlanes() override; + + private: + ~RenderExternalTextureHost(); + + bool CreateSurfaces(); + void DeleteSurfaces(); + void DeleteTextures(); + + uint8_t* GetBuffer() const { return mBuffer; } + bool InitializeIfNeeded(); + bool IsReadyForDeletion(); + bool IsYUV() const { return mFormat == gfx::SurfaceFormat::YUV; } + size_t PlaneCount() const { return IsYUV() ? 3 : 1; } + void UpdateTexture(size_t aIndex); + void UpdateTextures(); + + uint8_t* mBuffer; + layers::BufferDescriptor mDescriptor; + + bool mInitialized; + bool mTextureUpdateNeeded; + + gfx::IntSize mSize; + gfx::SurfaceFormat mFormat; + + RefPtr mGL; + RefPtr mSurfaces[3]; + RefPtr mTextureSources[3]; + wr::WrExternalImage mImages[3]; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDEREXTERNALTEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp new file mode 100644 index 0000000000..bb0575949b --- /dev/null +++ b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.cpp @@ -0,0 +1,157 @@ +/* -*- 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 "RenderMacIOSurfaceTextureHost.h" + +#include "GLContextCGL.h" +#include "mozilla/gfx/Logging.h" +#include "ScopedGLHelpers.h" + +namespace mozilla { +namespace wr { + +static CGLError CreateTextureForPlane(uint8_t aPlaneID, gl::GLContext* aGL, + MacIOSurface* aSurface, + GLuint* aTexture) { + MOZ_ASSERT(aGL && aSurface && aTexture); + + aGL->fGenTextures(1, aTexture); + ActivateBindAndTexParameteri(aGL, LOCAL_GL_TEXTURE0, + LOCAL_GL_TEXTURE_RECTANGLE_ARB, *aTexture); + aGL->fTexParameteri(LOCAL_GL_TEXTURE_RECTANGLE_ARB, LOCAL_GL_TEXTURE_WRAP_T, + LOCAL_GL_CLAMP_TO_EDGE); + aGL->fTexParameteri(LOCAL_GL_TEXTURE_RECTANGLE_ARB, LOCAL_GL_TEXTURE_WRAP_S, + LOCAL_GL_CLAMP_TO_EDGE); + + CGLError result = kCGLNoError; + gfx::SurfaceFormat readFormat = gfx::SurfaceFormat::UNKNOWN; + result = aSurface->CGLTexImageIOSurface2D( + aGL, gl::GLContextCGL::Cast(aGL)->GetCGLContext(), aPlaneID, &readFormat); + // If this is a yuv format, the Webrender only supports YUV422 interleaving + // format. + MOZ_ASSERT(aSurface->GetFormat() != gfx::SurfaceFormat::YUV422 || + readFormat == gfx::SurfaceFormat::YUV422); + + return result; +} + +RenderMacIOSurfaceTextureHost::RenderMacIOSurfaceTextureHost( + MacIOSurface* aSurface) + : mSurface(aSurface), mTextureHandles{0, 0, 0} { + MOZ_COUNT_CTOR_INHERITED(RenderMacIOSurfaceTextureHost, RenderTextureHost); +} + +RenderMacIOSurfaceTextureHost::~RenderMacIOSurfaceTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderMacIOSurfaceTextureHost, RenderTextureHost); + DeleteTextureHandle(); +} + +GLuint RenderMacIOSurfaceTextureHost::GetGLHandle(uint8_t aChannelIndex) const { + MOZ_ASSERT(mSurface); + MOZ_ASSERT((mSurface->GetPlaneCount() == 0) + ? (aChannelIndex == mSurface->GetPlaneCount()) + : (aChannelIndex < mSurface->GetPlaneCount())); + return mTextureHandles[aChannelIndex]; +} + +gfx::IntSize RenderMacIOSurfaceTextureHost::GetSize( + uint8_t aChannelIndex) const { + MOZ_ASSERT(mSurface); + MOZ_ASSERT((mSurface->GetPlaneCount() == 0) + ? (aChannelIndex == mSurface->GetPlaneCount()) + : (aChannelIndex < mSurface->GetPlaneCount())); + + if (!mSurface) { + return gfx::IntSize(); + } + return gfx::IntSize(mSurface->GetDevicePixelWidth(aChannelIndex), + mSurface->GetDevicePixelHeight(aChannelIndex)); +} + +size_t RenderMacIOSurfaceTextureHost::Bytes() { + return mSurface->GetAllocSize(); +} + +wr::WrExternalImage RenderMacIOSurfaceTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (mGL.get() != aGL) { + // release the texture handle in the previous gl context + DeleteTextureHandle(); + mGL = aGL; + mGL->MakeCurrent(); + } + + if (!mSurface || !mGL || !mGL->MakeCurrent()) { + return InvalidToWrExternalImage(); + } + + if (!mTextureHandles[0]) { + MOZ_ASSERT(gl::GLContextCGL::Cast(mGL.get())->GetCGLContext()); + + // The result of GetPlaneCount() is 0 for single plane format, but it will + // be 2 if the format has 2 planar data. + CreateTextureForPlane(0, mGL, mSurface, &(mTextureHandles[0])); + for (size_t i = 1; i < mSurface->GetPlaneCount(); ++i) { + CreateTextureForPlane(i, mGL, mSurface, &(mTextureHandles[i])); + } + } + + const auto uvs = GetUvCoords(GetSize(aChannelIndex)); + return NativeTextureToWrExternalImage(GetGLHandle(aChannelIndex), uvs.first.x, + uvs.first.y, uvs.second.x, + uvs.second.y); +} + +void RenderMacIOSurfaceTextureHost::Unlock() {} + +void RenderMacIOSurfaceTextureHost::DeleteTextureHandle() { + if (mTextureHandles[0] != 0 && mGL && mGL->MakeCurrent()) { + // Calling glDeleteTextures on 0 isn't an error. So, just make them a single + // call. + mGL->fDeleteTextures(3, mTextureHandles); + for (size_t i = 0; i < 3; ++i) { + mTextureHandles[i] = 0; + } + } +} + +size_t RenderMacIOSurfaceTextureHost::GetPlaneCount() const { + size_t planeCount = mSurface->GetPlaneCount(); + return planeCount > 0 ? planeCount : 1; +} + +gfx::SurfaceFormat RenderMacIOSurfaceTextureHost::GetFormat() const { + return mSurface->GetFormat(); +} + +gfx::ColorDepth RenderMacIOSurfaceTextureHost::GetColorDepth() const { + return mSurface->GetColorDepth(); +} + +gfx::YUVRangedColorSpace RenderMacIOSurfaceTextureHost::GetYUVColorSpace() + const { + return ToYUVRangedColorSpace(mSurface->GetYUVColorSpace(), + mSurface->GetColorRange()); +} + +bool RenderMacIOSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + if (!aChannelIndex) { + mSurface->Lock(); + } + aPlaneInfo.mData = mSurface->GetBaseAddressOfPlane(aChannelIndex); + aPlaneInfo.mStride = mSurface->GetBytesPerRow(aChannelIndex); + aPlaneInfo.mSize = + gfx::IntSize(mSurface->GetDevicePixelWidth(aChannelIndex), + mSurface->GetDevicePixelHeight(aChannelIndex)); + return true; +} + +void RenderMacIOSurfaceTextureHost::UnmapPlanes() { mSurface->Unlock(); } + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h new file mode 100644 index 0000000000..173cd3c223 --- /dev/null +++ b/gfx/webrender_bindings/RenderMacIOSurfaceTextureHost.h @@ -0,0 +1,61 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERMACIOSURFACETEXTUREHOST_H +#define MOZILLA_GFX_RENDERMACIOSURFACETEXTUREHOST_H + +#include "mozilla/gfx/MacIOSurface.h" +#include "mozilla/layers/TextureHostOGL.h" +#include "RenderTextureHostSWGL.h" + +namespace mozilla { + +namespace layers { +class SurfaceDescriptorMacIOSurface; +} + +namespace wr { + +class RenderMacIOSurfaceTextureHost final : public RenderTextureHostSWGL { + public: + explicit RenderMacIOSurfaceTextureHost(MacIOSurface* aSurface); + + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + + gfx::IntSize GetSize(uint8_t aChannelIndex) const; + GLuint GetGLHandle(uint8_t aChannelIndex) const; + + RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() override { + return this; + } + + size_t Bytes() override; + + MacIOSurface* GetSurface() { return mSurface; } + + // RenderTextureHostSWGL + size_t GetPlaneCount() const override; + gfx::SurfaceFormat GetFormat() const override; + gfx::ColorDepth GetColorDepth() const override; + gfx::YUVRangedColorSpace GetYUVColorSpace() const override; + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + void UnmapPlanes() override; + + private: + virtual ~RenderMacIOSurfaceTextureHost(); + void DeleteTextureHandle(); + + RefPtr mSurface; + RefPtr mGL; + GLuint mTextureHandles[3]; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERMACIOSURFACETEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp new file mode 100644 index 0000000000..db085f8f2f --- /dev/null +++ b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp @@ -0,0 +1,78 @@ +/* -*- 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 "RenderSharedSurfaceTextureHost.h" + +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/ImageDataSerializer.h" +#include "mozilla/layers/SourceSurfaceSharedData.h" + +namespace mozilla { +namespace wr { + +RenderSharedSurfaceTextureHost::RenderSharedSurfaceTextureHost( + gfx::SourceSurfaceSharedDataWrapper* aSurface) + : mSurface(aSurface), mMap(), mLocked(false) { + MOZ_COUNT_CTOR_INHERITED(RenderSharedSurfaceTextureHost, RenderTextureHost); + MOZ_ASSERT(aSurface); +} + +RenderSharedSurfaceTextureHost::~RenderSharedSurfaceTextureHost() { + MOZ_COUNT_DTOR_INHERITED(RenderSharedSurfaceTextureHost, RenderTextureHost); +} + +wr::WrExternalImage RenderSharedSurfaceTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (!mLocked) { + if (NS_WARN_IF( + !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) { + return InvalidToWrExternalImage(); + } + mLocked = true; + } + + return RawDataToWrExternalImage(mMap.mData, + mMap.mStride * mSurface->GetSize().height); +} + +void RenderSharedSurfaceTextureHost::Unlock() { + if (mLocked) { + mSurface->Unmap(); + mLocked = false; + } +} + +size_t RenderSharedSurfaceTextureHost::Bytes() { + return mSurface->Stride() * mSurface->GetSize().height; +} + +size_t RenderSharedSurfaceTextureHost::GetPlaneCount() const { return 1; } + +gfx::SurfaceFormat RenderSharedSurfaceTextureHost::GetFormat() const { + return mSurface->GetFormat(); +} + +gfx::ColorDepth RenderSharedSurfaceTextureHost::GetColorDepth() const { + return gfx::ColorDepth::COLOR_8; +} + +bool RenderSharedSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + if (NS_WARN_IF( + !mSurface->Map(gfx::DataSourceSurface::MapType::READ, &mMap))) { + return false; + } + aPlaneInfo.mData = mMap.mData; + aPlaneInfo.mStride = mMap.mStride; + aPlaneInfo.mSize = mSurface->GetSize(); + return true; +} + +void RenderSharedSurfaceTextureHost::UnmapPlanes() { mSurface->Unmap(); } + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h new file mode 100644 index 0000000000..2575abdac3 --- /dev/null +++ b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.h @@ -0,0 +1,57 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_H +#define MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_H + +#include "RenderTextureHostSWGL.h" + +namespace mozilla { +namespace gfx { +class SourceSurfaceSharedDataWrapper; +} + +namespace wr { + +/** + * This class allows for surfaces managed by SharedSurfacesParent to be inserted + * into the render texture cache by wrapping an existing surface wrapper. These + * surfaces are backed by BGRA/X shared memory buffers. + */ +class RenderSharedSurfaceTextureHost final : public RenderTextureHostSWGL { + public: + explicit RenderSharedSurfaceTextureHost( + gfx::SourceSurfaceSharedDataWrapper* aSurface); + + // RenderTextureHost + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + size_t Bytes() override; + + // RenderTextureHostSWGL + size_t GetPlaneCount() const override; + + gfx::SurfaceFormat GetFormat() const override; + + gfx::ColorDepth GetColorDepth() const override; + + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + + void UnmapPlanes() override; + + private: + virtual ~RenderSharedSurfaceTextureHost(); + + RefPtr mSurface; + gfx::DataSourceSurface::MappedSurface mMap; + bool mLocked; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERSHAREDSURFACETEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderTextureHost.cpp b/gfx/webrender_bindings/RenderTextureHost.cpp new file mode 100644 index 0000000000..71391bd1f7 --- /dev/null +++ b/gfx/webrender_bindings/RenderTextureHost.cpp @@ -0,0 +1,58 @@ +/* -*- 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 "RenderTextureHost.h" + +#include "GLContext.h" +#include "RenderThread.h" + +namespace mozilla { +namespace wr { + +void ActivateBindAndTexParameteri(gl::GLContext* aGL, GLenum aActiveTexture, + GLenum aBindTarget, GLuint aBindTexture) { + aGL->fActiveTexture(aActiveTexture); + aGL->fBindTexture(aBindTarget, aBindTexture); + // Initialize the mip filters to linear by default. + aGL->fTexParameteri(aBindTarget, LOCAL_GL_TEXTURE_MIN_FILTER, + LOCAL_GL_LINEAR); + aGL->fTexParameteri(aBindTarget, LOCAL_GL_TEXTURE_MAG_FILTER, + LOCAL_GL_LINEAR); +} + +RenderTextureHost::RenderTextureHost() : mIsFromDRMSource(false) { + MOZ_COUNT_CTOR(RenderTextureHost); +} + +RenderTextureHost::~RenderTextureHost() { + MOZ_ASSERT(RenderThread::IsInRenderThread()); + MOZ_COUNT_DTOR(RenderTextureHost); +} + +wr::WrExternalImage RenderTextureHost::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + return InvalidToWrExternalImage(); +} + +wr::WrExternalImage RenderTextureHost::LockSWGL(uint8_t aChannelIndex, + void* aContext, + RenderCompositor* aCompositor) { + return InvalidToWrExternalImage(); +} + +std::pair RenderTextureHost::GetUvCoords( + gfx::IntSize aTextureSize) const { + return std::make_pair(gfx::Point(0.0, 0.0), + gfx::Point(static_cast(aTextureSize.width), + static_cast(aTextureSize.height))); +} + +void RenderTextureHost::Destroy() { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderTextureHost.h b/gfx/webrender_bindings/RenderTextureHost.h new file mode 100644 index 0000000000..5798cf94f5 --- /dev/null +++ b/gfx/webrender_bindings/RenderTextureHost.h @@ -0,0 +1,141 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERTEXTUREHOST_H +#define MOZILLA_GFX_RENDERTEXTUREHOST_H + +#include "GLConsts.h" +#include "GLTypes.h" +#include "nsISupportsImpl.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/layers/LayersSurfaces.h" +#include "mozilla/RefPtr.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "mozilla/webrender/WebRenderTypes.h" + +namespace mozilla { + +namespace gl { +class GLContext; +} + +namespace wr { + +class RenderAndroidHardwareBufferTextureHost; +class RenderAndroidSurfaceTextureHost; +class RenderCompositor; +class RenderDXGITextureHost; +class RenderDXGIYCbCrTextureHost; +class RenderDcompSurfaceTextureHost; +class RenderMacIOSurfaceTextureHost; +class RenderBufferTextureHost; +class RenderTextureHostSWGL; +class RenderTextureHostWrapper; + +void ActivateBindAndTexParameteri(gl::GLContext* aGL, GLenum aActiveTexture, + GLenum aBindTarget, GLuint aBindTexture); + +class RenderTextureHost { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RenderTextureHost) + + public: + RenderTextureHost(); + + virtual gfx::SurfaceFormat GetFormat() const { + return gfx::SurfaceFormat::UNKNOWN; + } + + virtual gfx::YUVRangedColorSpace GetYUVColorSpace() const { + return gfx::YUVRangedColorSpace::Default; + } + + virtual wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL); + + virtual void Unlock() {} + + virtual wr::WrExternalImage LockSWGL(uint8_t aChannelIndex, void* aContext, + RenderCompositor* aCompositor); + + virtual void UnlockSWGL() {} + + virtual void ClearCachedResources() {} + + // Called asynchronouly when corresponding TextureHost's mCompositableCount + // becomes from 0 to 1. For now, it is used only for + // SurfaceTextureHost/RenderAndroidSurfaceTextureHost. + virtual void PrepareForUse() {} + // Called asynchronouly when corresponding TextureHost's is actually going to + // be used by WebRender. For now, it is used only for + // SurfaceTextureHost/RenderAndroidSurfaceTextureHost. + virtual void NotifyForUse() {} + // Called asynchronouly when corresponding TextureHost's mCompositableCount + // becomes 0. For now, it is used only for + // SurfaceTextureHost/RenderAndroidSurfaceTextureHost. + virtual void NotifyNotUsed() {} + // Returns true when RenderTextureHost needs SyncObjectHost::Synchronize() + // call, before its usage. + virtual bool SyncObjectNeeded() { return false; } + // Returns true when this texture was generated from a DRM-protected source. + bool IsFromDRMSource() { return mIsFromDRMSource; } + void SetIsFromDRMSource(bool aIsFromDRMSource) { + mIsFromDRMSource = aIsFromDRMSource; + } + + virtual size_t Bytes() = 0; + + virtual RenderDXGITextureHost* AsRenderDXGITextureHost() { return nullptr; } + virtual RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() { + return nullptr; + } + + virtual RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() { + return nullptr; + } + + virtual RenderAndroidHardwareBufferTextureHost* + AsRenderAndroidHardwareBufferTextureHost() { + return nullptr; + } + + virtual RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost() { + return nullptr; + } + + virtual RenderTextureHostSWGL* AsRenderTextureHostSWGL() { return nullptr; } + + virtual RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() { + return nullptr; + } + + virtual void Destroy(); + + virtual void SetIsSoftwareDecodedVideo() { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + } + virtual bool IsSoftwareDecodedVideo() { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return false; + } + + protected: + virtual ~RenderTextureHost(); + + // Returns the UV coordinates to be used when sampling the texture, in pixels. + // For most implementations these will be (0, 0) and (size.x, size.y), but + // some texture types (such as RenderAndroidSurfaceTextureHost) require an + // additional transform to be applied to the coordinates. + virtual std::pair GetUvCoords( + gfx::IntSize aTextureSize) const; + + bool mIsFromDRMSource; + + friend class RenderTextureHostWrapper; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERTEXTUREHOST_H diff --git a/gfx/webrender_bindings/RenderTextureHostSWGL.cpp b/gfx/webrender_bindings/RenderTextureHostSWGL.cpp new file mode 100644 index 0000000000..ad2d960837 --- /dev/null +++ b/gfx/webrender_bindings/RenderTextureHostSWGL.cpp @@ -0,0 +1,231 @@ +/* -*- 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 "RenderTextureHostSWGL.h" + +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/TextureHost.h" +#include "RenderThread.h" + +namespace mozilla { +namespace wr { + +bool RenderTextureHostSWGL::UpdatePlanes(RenderCompositor* aCompositor) { + wr_swgl_make_current(mContext); + size_t planeCount = GetPlaneCount(); + bool texInit = false; + if (mPlanes.size() < planeCount) { + mPlanes.reserve(planeCount); + while (mPlanes.size() < planeCount) { + mPlanes.push_back(PlaneInfo(wr_swgl_gen_texture(mContext))); + } + texInit = true; + } + gfx::SurfaceFormat format = GetFormat(); + gfx::ColorDepth colorDepth = GetColorDepth(); + for (size_t i = 0; i < planeCount; i++) { + PlaneInfo& plane = mPlanes[i]; + if (!MapPlane(aCompositor, i, plane)) { + if (i > 0) { + UnmapPlanes(); + } + return false; + } + GLenum internalFormat = 0; + switch (format) { + case gfx::SurfaceFormat::B8G8R8A8: + case gfx::SurfaceFormat::B8G8R8X8: + MOZ_ASSERT(colorDepth == gfx::ColorDepth::COLOR_8); + internalFormat = LOCAL_GL_RGBA8; + break; + case gfx::SurfaceFormat::YUV: + switch (colorDepth) { + case gfx::ColorDepth::COLOR_8: + internalFormat = LOCAL_GL_R8; + break; + case gfx::ColorDepth::COLOR_10: + case gfx::ColorDepth::COLOR_12: + case gfx::ColorDepth::COLOR_16: + internalFormat = LOCAL_GL_R16; + break; + } + break; + case gfx::SurfaceFormat::NV12: + switch (colorDepth) { + case gfx::ColorDepth::COLOR_8: + internalFormat = i > 0 ? LOCAL_GL_RG8 : LOCAL_GL_R8; + break; + case gfx::ColorDepth::COLOR_10: + case gfx::ColorDepth::COLOR_12: + case gfx::ColorDepth::COLOR_16: + internalFormat = i > 0 ? LOCAL_GL_RG16 : LOCAL_GL_R16; + break; + } + break; + case gfx::SurfaceFormat::P010: + MOZ_ASSERT(colorDepth == gfx::ColorDepth::COLOR_10); + internalFormat = i > 0 ? LOCAL_GL_RG16 : LOCAL_GL_R16; + break; + case gfx::SurfaceFormat::YUV422: + MOZ_ASSERT(colorDepth == gfx::ColorDepth::COLOR_8); + internalFormat = LOCAL_GL_RGB_RAW_422_APPLE; + break; + default: + MOZ_RELEASE_ASSERT(false, "Unhandled external image format"); + break; + } + wr_swgl_set_texture_buffer(mContext, plane.mTexture, internalFormat, + plane.mSize.width, plane.mSize.height, + plane.mStride, plane.mData, 0, 0); + } + if (texInit) { + // Initialize the mip filters to linear by default. + for (const auto& plane : mPlanes) { + wr_swgl_set_texture_parameter(mContext, plane.mTexture, + LOCAL_GL_TEXTURE_MIN_FILTER, + LOCAL_GL_LINEAR); + wr_swgl_set_texture_parameter(mContext, plane.mTexture, + LOCAL_GL_TEXTURE_MAG_FILTER, + LOCAL_GL_LINEAR); + } + } + return true; +} + +bool RenderTextureHostSWGL::SetContext(void* aContext) { + if (mContext != aContext) { + CleanupPlanes(); + mContext = aContext; + wr_swgl_reference_context(mContext); + } + return mContext != nullptr; +} + +wr::WrExternalImage RenderTextureHostSWGL::LockSWGL( + uint8_t aChannelIndex, void* aContext, RenderCompositor* aCompositor) { + if (!SetContext(aContext)) { + return InvalidToWrExternalImage(); + } + if (!mLocked) { + if (!UpdatePlanes(aCompositor)) { + return InvalidToWrExternalImage(); + } + mLocked = true; + } + if (aChannelIndex >= mPlanes.size()) { + return InvalidToWrExternalImage(); + } + const PlaneInfo& plane = mPlanes[aChannelIndex]; + + const auto uvs = GetUvCoords(plane.mSize); + + // Prefer native textures, unless our backend forbids it. + // If the GetUvCoords call above returned anything other than the default, + // for example if this is a RenderAndroidSurfaceTextureHost, then this won't + // be handled correctly in the RawDataToWrExternalImage path. But we shouldn't + // hit this path in practice with a RenderAndroidSurfaceTextureHost. + layers::TextureHost::NativeTexturePolicy policy = + layers::TextureHost::BackendNativeTexturePolicy( + layers::WebRenderBackend::SOFTWARE, plane.mSize); + return policy == layers::TextureHost::NativeTexturePolicy::FORBID + ? RawDataToWrExternalImage((uint8_t*)plane.mData, + plane.mStride * plane.mSize.height) + : NativeTextureToWrExternalImage(plane.mTexture, uvs.first.x, + uvs.first.y, uvs.second.x, + uvs.second.y); +} + +void RenderTextureHostSWGL::UnlockSWGL() { + if (mLocked) { + mLocked = false; + UnmapPlanes(); + } +} + +void RenderTextureHostSWGL::CleanupPlanes() { + if (!mContext) { + return; + } + if (!mPlanes.empty()) { + wr_swgl_make_current(mContext); + for (const auto& plane : mPlanes) { + wr_swgl_delete_texture(mContext, plane.mTexture); + } + mPlanes.clear(); + } + wr_swgl_destroy_context(mContext); + mContext = nullptr; +} + +RenderTextureHostSWGL::~RenderTextureHostSWGL() { CleanupPlanes(); } + +bool RenderTextureHostSWGL::LockSWGLCompositeSurface( + void* aContext, wr::SWGLCompositeSurfaceInfo* aInfo) { + if (!SetContext(aContext)) { + return false; + } + if (!mLocked) { + if (!UpdatePlanes(nullptr)) { + return false; + } + mLocked = true; + } + MOZ_ASSERT(mPlanes.size() <= 3); + for (size_t i = 0; i < mPlanes.size(); i++) { + aInfo->textures[i] = mPlanes[i].mTexture; + } + switch (GetFormat()) { + case gfx::SurfaceFormat::YUV: + case gfx::SurfaceFormat::NV12: + case gfx::SurfaceFormat::P010: + case gfx::SurfaceFormat::YUV422: { + aInfo->yuv_planes = mPlanes.size(); + auto colorSpace = GetYUVColorSpace(); + aInfo->color_space = ToWrYuvRangedColorSpace(colorSpace); + auto colorDepth = GetColorDepth(); + aInfo->color_depth = ToWrColorDepth(colorDepth); + break; + } + case gfx::SurfaceFormat::B8G8R8A8: + case gfx::SurfaceFormat::B8G8R8X8: + break; + default: + gfxCriticalNote << "Unhandled external image format: " << GetFormat(); + MOZ_RELEASE_ASSERT(false, "Unhandled external image format"); + break; + } + aInfo->size.width = mPlanes[0].mSize.width; + aInfo->size.height = mPlanes[0].mSize.height; + return true; +} + +bool wr_swgl_lock_composite_surface(void* aContext, wr::ExternalImageId aId, + wr::SWGLCompositeSurfaceInfo* aInfo) { + RenderTextureHost* texture = RenderThread::Get()->GetRenderTexture(aId); + if (!texture) { + return false; + } + RenderTextureHostSWGL* swglTex = texture->AsRenderTextureHostSWGL(); + if (!swglTex) { + return false; + } + return swglTex->LockSWGLCompositeSurface(aContext, aInfo); +} + +void wr_swgl_unlock_composite_surface(void* aContext, wr::ExternalImageId aId) { + RenderTextureHost* texture = RenderThread::Get()->GetRenderTexture(aId); + if (!texture) { + return; + } + RenderTextureHostSWGL* swglTex = texture->AsRenderTextureHostSWGL(); + if (!swglTex) { + return; + } + swglTex->UnlockSWGL(); +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderTextureHostSWGL.h b/gfx/webrender_bindings/RenderTextureHostSWGL.h new file mode 100644 index 0000000000..b5d1e92056 --- /dev/null +++ b/gfx/webrender_bindings/RenderTextureHostSWGL.h @@ -0,0 +1,80 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERTEXTUREHOSTSWGL_H +#define MOZILLA_GFX_RENDERTEXTUREHOSTSWGL_H + +#include "GLTypes.h" +#include "RenderTextureHost.h" + +namespace mozilla { +namespace wr { + +class RenderTextureHostSWGL : public RenderTextureHost { + public: + RenderTextureHostSWGL() {} + + wr::WrExternalImage LockSWGL(uint8_t aChannelIndex, void* aContext, + RenderCompositor* aCompositor) override; + + void UnlockSWGL() override; + + RenderTextureHostSWGL* AsRenderTextureHostSWGL() override { return this; } + + virtual size_t GetPlaneCount() const = 0; + + virtual gfx::ColorDepth GetColorDepth() const { + return gfx::ColorDepth::COLOR_8; + } + + struct PlaneInfo { + explicit PlaneInfo(GLuint aTexture) : mTexture(aTexture) {} + + GLuint mTexture = 0; + void* mData = nullptr; + int32_t mStride = 0; + gfx::IntSize mSize; + }; + + virtual bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) = 0; + + virtual void UnmapPlanes() = 0; + + // Lock this texture host as an attached external image for a SWGL compositor + // surface. See swgl_bindings.rs for a description of the resulting + // WrSWGLCompositeSurfaceInfo. This is paired with a call to UnlockSWGL when + // composition is done. + bool LockSWGLCompositeSurface(void* aContext, + wr::SWGLCompositeSurfaceInfo* aInfo); + + size_t BytesFromPlanes() { + NS_ASSERTION(mPlanes.size(), "Can't compute bytes without any planes"); + size_t bytes = 0; + for (auto& plane : mPlanes) { + bytes += plane.mStride * plane.mSize.height; + } + return bytes; + } + + protected: + bool mLocked = false; + void* mContext = nullptr; + std::vector mPlanes; + + bool SetContext(void* aContext); + + bool UpdatePlanes(RenderCompositor* aCompositor); + + void CleanupPlanes(); + + virtual ~RenderTextureHostSWGL(); +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERTEXTUREHOSTSWGL_H diff --git a/gfx/webrender_bindings/RenderTextureHostWrapper.cpp b/gfx/webrender_bindings/RenderTextureHostWrapper.cpp new file mode 100644 index 0000000000..b700eafcfb --- /dev/null +++ b/gfx/webrender_bindings/RenderTextureHostWrapper.cpp @@ -0,0 +1,212 @@ +/* -*- 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 "RenderTextureHostWrapper.h" + +#include "mozilla/gfx/Logging.h" +#include "mozilla/layers/RemoteTextureMap.h" +#include "mozilla/webrender/RenderThread.h" + +namespace mozilla { +namespace wr { + +RenderTextureHostWrapper::RenderTextureHostWrapper( + ExternalImageId aExternalImageId) + : mExternalImageId(aExternalImageId) { + MOZ_COUNT_CTOR_INHERITED(RenderTextureHostWrapper, RenderTextureHost); + EnsureTextureHost(); +} + +RenderTextureHostWrapper::~RenderTextureHostWrapper() { + MOZ_COUNT_DTOR_INHERITED(RenderTextureHostWrapper, RenderTextureHost); +} + +void RenderTextureHostWrapper::EnsureTextureHost() const { + if (mTextureHost) { + return; + } + + mTextureHost = RenderThread::Get()->GetRenderTexture(mExternalImageId); + MOZ_ASSERT(mTextureHost); + if (!mTextureHost) { + gfxCriticalNoteOnce << "Failed to get RenderTextureHost for extId:" + << AsUint64(mExternalImageId); + } +} + +wr::WrExternalImage RenderTextureHostWrapper::Lock(uint8_t aChannelIndex, + gl::GLContext* aGL) { + if (!mTextureHost) { + return InvalidToWrExternalImage(); + } + + return mTextureHost->Lock(aChannelIndex, aGL); +} + +void RenderTextureHostWrapper::Unlock() { + if (mTextureHost) { + mTextureHost->Unlock(); + } +} + +std::pair RenderTextureHostWrapper::GetUvCoords( + gfx::IntSize aTextureSize) const { + if (mTextureHost) { + return mTextureHost->GetUvCoords(aTextureSize); + } + return RenderTextureHost::GetUvCoords(aTextureSize); +} + +void RenderTextureHostWrapper::ClearCachedResources() { + if (mTextureHost) { + mTextureHost->ClearCachedResources(); + } +} + +void RenderTextureHostWrapper::PrepareForUse() { + if (!mTextureHost) { + return; + } + mTextureHost->PrepareForUse(); +} + +void RenderTextureHostWrapper::NotifyForUse() { + if (!mTextureHost) { + return; + } + mTextureHost->NotifyForUse(); +} + +void RenderTextureHostWrapper::NotifyNotUsed() { + if (!mTextureHost) { + return; + } + mTextureHost->NotifyNotUsed(); +} + +bool RenderTextureHostWrapper::SyncObjectNeeded() { return false; } + +RenderMacIOSurfaceTextureHost* +RenderTextureHostWrapper::AsRenderMacIOSurfaceTextureHost() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderMacIOSurfaceTextureHost(); +} + +RenderDXGITextureHost* RenderTextureHostWrapper::AsRenderDXGITextureHost() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderDXGITextureHost(); +} + +RenderDXGIYCbCrTextureHost* +RenderTextureHostWrapper::AsRenderDXGIYCbCrTextureHost() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderDXGIYCbCrTextureHost(); +} + +RenderDcompSurfaceTextureHost* +RenderTextureHostWrapper::AsRenderDcompSurfaceTextureHost() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderDcompSurfaceTextureHost(); +} + +RenderTextureHostSWGL* RenderTextureHostWrapper::AsRenderTextureHostSWGL() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderTextureHostSWGL(); +} + +RenderAndroidHardwareBufferTextureHost* +RenderTextureHostWrapper::AsRenderAndroidHardwareBufferTextureHost() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderAndroidHardwareBufferTextureHost(); +} + +RenderAndroidSurfaceTextureHost* +RenderTextureHostWrapper::AsRenderAndroidSurfaceTextureHost() { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderAndroidSurfaceTextureHost(); +} + +RenderTextureHostSWGL* RenderTextureHostWrapper::EnsureRenderTextureHostSWGL() + const { + if (!mTextureHost) { + return nullptr; + } + return mTextureHost->AsRenderTextureHostSWGL(); +} + +void RenderTextureHostWrapper::SetIsSoftwareDecodedVideo() { + if (!mTextureHost) { + return; + } + return mTextureHost->SetIsSoftwareDecodedVideo(); +} + +bool RenderTextureHostWrapper::IsSoftwareDecodedVideo() { + if (!mTextureHost) { + return false; + } + return mTextureHost->IsSoftwareDecodedVideo(); +} + +size_t RenderTextureHostWrapper::GetPlaneCount() const { + if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) { + return swglHost->GetPlaneCount(); + } + return 0; +} + +gfx::SurfaceFormat RenderTextureHostWrapper::GetFormat() const { + if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) { + return swglHost->GetFormat(); + } + return gfx::SurfaceFormat::UNKNOWN; +} + +gfx::ColorDepth RenderTextureHostWrapper::GetColorDepth() const { + if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) { + return swglHost->GetColorDepth(); + } + return gfx::ColorDepth::COLOR_8; +} + +gfx::YUVRangedColorSpace RenderTextureHostWrapper::GetYUVColorSpace() const { + if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) { + return swglHost->GetYUVColorSpace(); + } + return gfx::YUVRangedColorSpace::Default; +} + +bool RenderTextureHostWrapper::MapPlane(RenderCompositor* aCompositor, + uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) { + if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) { + return swglHost->MapPlane(aCompositor, aChannelIndex, aPlaneInfo); + } + return false; +} + +void RenderTextureHostWrapper::UnmapPlanes() { + if (RenderTextureHostSWGL* swglHost = EnsureRenderTextureHostSWGL()) { + swglHost->UnmapPlanes(); + } +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RenderTextureHostWrapper.h b/gfx/webrender_bindings/RenderTextureHostWrapper.h new file mode 100644 index 0000000000..67f26b2a65 --- /dev/null +++ b/gfx/webrender_bindings/RenderTextureHostWrapper.h @@ -0,0 +1,81 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H +#define MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H + +#include "RenderTextureHostSWGL.h" + +namespace mozilla { + +namespace wr { + +/** + * RenderTextureHost of GPUVideoTextureHost. + * + * GPUVideoTextureHost wraps TextureHost. This class wraps RenderTextureHost of + * the wrapped TextureHost. Lifetime of the wrapped TextureHost is usually + * longer than GPUVideoTextureHost and the wrapped TextureHost is used by + * multiple GPUVideoTextureHosts. This class is used to reduce recreations of + * the wrappded RenderTextureHost. Initializations of some + * RenderTextureHosts(RenderDXGITextureHost and + * RenderDXGIYCbCrTextureHost) have overhead. + */ +class RenderTextureHostWrapper final : public RenderTextureHostSWGL { + public: + explicit RenderTextureHostWrapper(ExternalImageId aExternalImageId); + + // RenderTextureHost + wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override; + void Unlock() override; + void ClearCachedResources() override; + void PrepareForUse() override; + void NotifyForUse() override; + void NotifyNotUsed() override; + bool SyncObjectNeeded() override; + RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() override; + RenderDXGITextureHost* AsRenderDXGITextureHost() override; + RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() override; + RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() override; + RenderAndroidHardwareBufferTextureHost* + AsRenderAndroidHardwareBufferTextureHost() override; + RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost() override; + RenderTextureHostSWGL* AsRenderTextureHostSWGL() override; + void SetIsSoftwareDecodedVideo() override; + bool IsSoftwareDecodedVideo() override; + + // RenderTextureHostSWGL + size_t GetPlaneCount() const override; + gfx::SurfaceFormat GetFormat() const override; + gfx::ColorDepth GetColorDepth() const override; + gfx::YUVRangedColorSpace GetYUVColorSpace() const override; + bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex, + PlaneInfo& aPlaneInfo) override; + void UnmapPlanes() override; + + // This is just a wrapper, so doesn't need to report the + // size of the wrapped object (which reports itself). + size_t Bytes() override { return 0; } + + protected: + // RenderTextureHost + std::pair GetUvCoords( + gfx::IntSize aTextureSize) const override; + + private: + ~RenderTextureHostWrapper() override; + + void EnsureTextureHost() const; + RenderTextureHostSWGL* EnsureRenderTextureHostSWGL() const; + + ExternalImageId mExternalImageId; + mutable RefPtr mTextureHost; +}; + +} // namespace wr +} // namespace mozilla + +#endif // MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H diff --git a/gfx/webrender_bindings/RenderThread.cpp b/gfx/webrender_bindings/RenderThread.cpp new file mode 100644 index 0000000000..89fc339c03 --- /dev/null +++ b/gfx/webrender_bindings/RenderThread.cpp @@ -0,0 +1,1649 @@ +/* -*- 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 "base/task.h" +#include "GeckoProfiler.h" +#include "gfxPlatform.h" +#include "GLContext.h" +#include "RenderThread.h" +#include "nsThread.h" +#include "nsThreadUtils.h" +#include "transport/runnable_utils.h" +#include "mozilla/BackgroundHangMonitor.h" +#include "mozilla/layers/AsyncImagePipelineManager.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/gfx/GPUParent.h" +#include "mozilla/gfx/GPUProcessManager.h" +#include "mozilla/glean/GleanMetrics.h" +#include "mozilla/layers/CompositorThread.h" +#include "mozilla/layers/CompositorBridgeParent.h" +#include "mozilla/layers/CompositorManagerParent.h" +#include "mozilla/layers/WebRenderBridgeParent.h" +#include "mozilla/layers/SharedSurfacesParent.h" +#include "mozilla/layers/SurfacePool.h" +#include "mozilla/layers/SynchronousTask.h" +#include "mozilla/PerfStats.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/Telemetry.h" +#include "mozilla/webrender/RendererOGL.h" +#include "mozilla/webrender/RenderTextureHost.h" +#include "mozilla/widget/CompositorWidget.h" +#include "OGLShaderProgram.h" + +#ifdef XP_WIN +# include "GLContextEGL.h" +# include "GLLibraryEGL.h" +# include "mozilla/widget/WinCompositorWindowThread.h" +# include "mozilla/gfx/DeviceManagerDx.h" +# include "mozilla/webrender/DCLayerTree.h" +// # include "nsWindowsHelpers.h" +// # include +#endif + +#ifdef MOZ_WIDGET_ANDROID +# include "GLLibraryEGL.h" +# include "mozilla/webrender/RenderAndroidSurfaceTextureHost.h" +#endif + +#ifdef MOZ_WIDGET_GTK +# include "mozilla/WidgetUtilsGtk.h" +# include "GLLibraryEGL.h" +#endif + +using namespace mozilla; + +static already_AddRefed CreateGLContext(nsACString& aError); + +MOZ_DEFINE_MALLOC_SIZE_OF(WebRenderRendererMallocSizeOf) + +namespace mozilla::wr { + +LazyLogModule gRenderThreadLog("RenderThread"); +// Should be called only on RenderThread, since LazyLogModule is not thread safe +#define LOG(...) MOZ_LOG(gRenderThreadLog, LogLevel::Debug, (__VA_ARGS__)) + +static StaticRefPtr sRenderThread; +static mozilla::BackgroundHangMonitor* sBackgroundHangMonitor; +#ifdef DEBUG +static bool sRenderThreadEverStarted = false; +#endif + +RenderThread::RenderThread(RefPtr aThread) + : mThread(std::move(aThread)), + mThreadPool(false), + mThreadPoolLP(true), + mSingletonGLIsForHardwareWebRender(true), + mWindowInfos("RenderThread.mWindowInfos"), + mRenderTextureMapLock("RenderThread.mRenderTextureMapLock"), + mHasShutdown(false), + mHandlingDeviceReset(false), + mHandlingWebRenderError(false) {} + +RenderThread::~RenderThread() { MOZ_ASSERT(mRenderTexturesDeferred.empty()); } + +// static +RenderThread* RenderThread::Get() { return sRenderThread; } + +// static +void RenderThread::Start(uint32_t aNamespace) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!sRenderThread); + +#ifdef DEBUG + // Check to ensure nobody will try to ever start us more than once during + // the process' lifetime (in particular after ShutDown). + MOZ_ASSERT(!sRenderThreadEverStarted); + sRenderThreadEverStarted = true; +#endif + + // When the CanvasRenderer thread is disabled, WebGL may be handled on this + // thread, requiring a bigger stack size. See: CanvasManagerParent::Init + // + // This is 4M, which is higher than the default 256K. + // Increased with bug 1753349 to accommodate the `chromium/5359` branch of + // ANGLE, which has large peak stack usage for some pathological shader + // compilations. + // + // Previously increased to 512K to accommodate Mesa in bug 1753340. + // + // Previously increased to 320K to avoid a stack overflow in the + // Intel Vulkan driver initialization in bug 1716120. + // + // Note: we only override it if it's limited already. + uint32_t stackSize = nsIThreadManager::DEFAULT_STACK_SIZE; + if (stackSize && !gfx::gfxVars::SupportsThreadsafeGL()) { + stackSize = std::max(stackSize, 4096U << 10); + } + + RefPtr thread; + nsresult rv = NS_NewNamedThread( + "Renderer", getter_AddRefs(thread), + NS_NewRunnableFunction( + "Renderer::BackgroundHanSetup", + []() { + sBackgroundHangMonitor = new mozilla::BackgroundHangMonitor( + "Render", + /* Timeout values are powers-of-two to enable us get better + data. 128ms is chosen for transient hangs because 8Hz should + be the minimally acceptable goal for Render + responsiveness (normal goal is 60Hz). */ + 128, + /* 2048ms is chosen for permanent hangs because it's longer than + * most Render hangs seen in the wild, but is short enough + * to not miss getting native hang stacks. */ + 2048); + nsCOMPtr thread = NS_GetCurrentThread(); + nsThread* nsthread = static_cast(thread.get()); + nsthread->SetUseHangMonitor(true); + nsthread->SetPriority(nsISupportsPriority::PRIORITY_HIGH); + }), + {.stackSize = stackSize}); + + if (NS_FAILED(rv)) { + gfxCriticalNote << "Failed to create Renderer thread: " + << gfx::hexa((uint32_t)rv); + return; + } + + sRenderThread = new RenderThread(thread); +#ifdef XP_WIN + widget::WinCompositorWindowThread::Start(); +#endif + layers::SharedSurfacesParent::Initialize(); + + RefPtr runnable = WrapRunnable( + RefPtr(sRenderThread.get()), &RenderThread::InitDeviceTask); + sRenderThread->PostRunnable(runnable.forget()); +} + +// static +void RenderThread::ShutDown() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(sRenderThread); + + { + MutexAutoLock lock(sRenderThread->mRenderTextureMapLock); + sRenderThread->mHasShutdown = true; + } + + RefPtr runnable = WrapRunnable( + RefPtr(sRenderThread.get()), &RenderThread::ShutDownTask); + sRenderThread->PostRunnable(runnable.forget()); + + // This will empty the thread queue and thus run the above runnable while + // spinning the MT event loop. + nsCOMPtr oldThread = sRenderThread->GetRenderThread(); + oldThread->Shutdown(); + + layers::SharedSurfacesParent::Shutdown(); + +#ifdef XP_WIN + if (widget::WinCompositorWindowThread::Get()) { + widget::WinCompositorWindowThread::ShutDown(); + } +#endif + + // We null this out only after we finished shutdown to give everbody the + // chance to check for sRenderThread->mHasShutdown. Hopefully everybody + // checks this before using us! + sRenderThread = nullptr; +} + +extern void ClearAllBlobImageResources(); + +void RenderThread::ShutDownTask() { + MOZ_ASSERT(IsInRenderThread()); + LOG("RenderThread::ShutDownTask()"); + + { + // Clear RenderTextureHosts + MutexAutoLock lock(mRenderTextureMapLock); + mRenderTexturesDeferred.clear(); + mRenderTextures.clear(); + mSyncObjectNeededRenderTextures.clear(); + mRenderTextureOps.clear(); + } + + // Let go of our handle to the (internally ref-counted) thread pool. + mThreadPool.Release(); + mThreadPoolLP.Release(); + + // Releasing on the render thread will allow us to avoid dispatching to remove + // remaining textures from the texture map. + layers::SharedSurfacesParent::ShutdownRenderThread(); + +#ifdef XP_WIN + DCLayerTree::Shutdown(); +#endif + + ClearAllBlobImageResources(); + ClearSingletonGL(); + ClearSharedSurfacePool(); +} + +// static +bool RenderThread::IsInRenderThread() { + return sRenderThread && sRenderThread->mThread == NS_GetCurrentThread(); +} + +// static +already_AddRefed RenderThread::GetRenderThread() { + nsCOMPtr thread; + if (sRenderThread) { + thread = sRenderThread->mThread; + } + return thread.forget(); +} + +void RenderThread::DoAccumulateMemoryReport( + MemoryReport aReport, + const RefPtr& aPromise) { + MOZ_ASSERT(IsInRenderThread()); + + for (auto& r : mRenderers) { + r.second->AccumulateMemoryReport(&aReport); + } + + // Note memory used by the shader cache, which is shared across all WR + // instances. + MOZ_ASSERT(aReport.shader_cache == 0); + if (mProgramCache) { + aReport.shader_cache = wr_program_cache_report_memory( + mProgramCache->Raw(), &WebRenderRendererMallocSizeOf); + } + + size_t renderTextureMemory = 0; + { + MutexAutoLock lock(mRenderTextureMapLock); + for (const auto& entry : mRenderTextures) { + renderTextureMemory += entry.second->Bytes(); + } + } + aReport.render_texture_hosts = renderTextureMemory; + + aPromise->Resolve(aReport, __func__); +} + +// static +RefPtr RenderThread::AccumulateMemoryReport( + MemoryReport aInitial) { + RefPtr p = + new MemoryReportPromise::Private(__func__); + MOZ_ASSERT(!IsInRenderThread()); + if (!Get()) { + // This happens when the GPU process fails to start and we fall back to the + // basic compositor in the parent process. We could assert against this if + // we made the webrender detection code in gfxPlatform.cpp smarter. See bug + // 1494430 comment 12. + NS_WARNING("No render thread, returning empty memory report"); + p->Resolve(aInitial, __func__); + return p; + } + + Get()->PostRunnable( + NewRunnableMethod>( + "wr::RenderThread::DoAccumulateMemoryReport", Get(), + &RenderThread::DoAccumulateMemoryReport, aInitial, p)); + + return p; +} + +void RenderThread::AddRenderer(wr::WindowId aWindowId, + UniquePtr aRenderer) { + MOZ_ASSERT(IsInRenderThread()); + LOG("RenderThread::AddRenderer() aWindowId %" PRIx64 "", AsUint64(aWindowId)); + + if (mHasShutdown) { + return; + } + + mRenderers[aWindowId] = std::move(aRenderer); + CrashReporter::AnnotateCrashReport( + CrashReporter::Annotation::GraphicsNumRenderers, + (unsigned int)mRenderers.size()); + + auto windows = mWindowInfos.Lock(); + windows->emplace(AsUint64(aWindowId), new WindowInfo()); + mWrNotifierEventsQueues.emplace(AsUint64(aWindowId), + new std::queue); +} + +void RenderThread::RemoveRenderer(wr::WindowId aWindowId) { + MOZ_ASSERT(IsInRenderThread()); + LOG("RenderThread::RemoveRenderer() aWindowId %" PRIx64 "", + AsUint64(aWindowId)); + + if (mHasShutdown) { + return; + } + + mRenderers.erase(aWindowId); + CrashReporter::AnnotateCrashReport( + CrashReporter::Annotation::GraphicsNumRenderers, + (unsigned int)mRenderers.size()); + + if (mRenderers.empty()) { + if (mHandlingDeviceReset) { + ClearSingletonGL(); + } + mHandlingDeviceReset = false; + mHandlingWebRenderError = false; + } + + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + MOZ_ASSERT(it != windows->end()); + windows->erase(it); + + // Defer std::deque remove, RemoveRenderer() is called in + // HandleWrNotifierEvents(). + RefPtr runnable = + NS_NewRunnableFunction("RenderThread::RemoveRenderer", [aWindowId]() { + auto* self = RenderThread::Get(); + auto it = self->mWrNotifierEventsQueues.find(AsUint64(aWindowId)); + if (it == self->mWrNotifierEventsQueues.end()) { + return; + } + self->mWrNotifierEventsQueues.erase(it); + }); + RenderThread::Get()->PostRunnable(runnable.forget()); +} + +RendererOGL* RenderThread::GetRenderer(wr::WindowId aWindowId) { + MOZ_ASSERT(IsInRenderThread()); + + auto it = mRenderers.find(aWindowId); + MOZ_ASSERT(it != mRenderers.end()); + + if (it == mRenderers.end()) { + return nullptr; + } + + return it->second.get(); +} + +size_t RenderThread::RendererCount() const { + MOZ_ASSERT(IsInRenderThread()); + return mRenderers.size(); +} + +size_t RenderThread::ActiveRendererCount() const { + MOZ_ASSERT(IsInRenderThread()); + size_t num_active = 0; + for (const auto& it : mRenderers) { + if (!it.second->IsPaused()) { + num_active++; + } + } + return num_active; +} + +void RenderThread::WrNotifierEvent_WakeUp(WrWindowId aWindowId, + bool aCompositeNeeded) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + + WindowInfo* info = it->second.get(); + + info->mPendingWrNotifierEvents.emplace( + WrNotifierEvent::WakeUp(aCompositeNeeded)); + PostWrNotifierEvents(aWindowId, info); +} + +void RenderThread::WrNotifierEvent_NewFrameReady(WrWindowId aWindowId, + bool aCompositeNeeded, + FramePublishId aPublishId) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + WindowInfo* info = it->second.get(); + + info->mPendingWrNotifierEvents.emplace( + WrNotifierEvent::NewFrameReady(aCompositeNeeded, aPublishId)); + PostWrNotifierEvents(aWindowId, info); +} + +void RenderThread::WrNotifierEvent_ExternalEvent(WrWindowId aWindowId, + size_t aRawEvent) { + UniquePtr evt(reinterpret_cast(aRawEvent)); + { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + WindowInfo* info = it->second.get(); + + info->mPendingWrNotifierEvents.emplace( + WrNotifierEvent::ExternalEvent(std::move(evt))); + PostWrNotifierEvents(aWindowId, info); + } +} + +void RenderThread::PostWrNotifierEvents(WrWindowId aWindowId) { + { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + WindowInfo* info = it->second.get(); + PostWrNotifierEvents(aWindowId, info); + } +} + +void RenderThread::PostWrNotifierEvents(WrWindowId aWindowId, + WindowInfo* aInfo) { + // Runnable has already been triggered. + if (aInfo->mWrNotifierEventsRunnable) { + return; + } + + // Runnable has not been triggered yet. + RefPtr runnable = NewRunnableMethod( + "RenderThread::HandleWrNotifierEvents", this, + &RenderThread::HandleWrNotifierEvents, aWindowId); + aInfo->mWrNotifierEventsRunnable = runnable; + PostRunnable(runnable.forget()); +} + +void RenderThread::HandleWrNotifierEvents(WrWindowId aWindowId) { + MOZ_ASSERT(IsInRenderThread()); + + auto eventsIt = mWrNotifierEventsQueues.find(AsUint64(aWindowId)); + if (eventsIt == mWrNotifierEventsQueues.end()) { + return; + } + auto* events = eventsIt->second.get(); + + { + auto windows = mWindowInfos.Lock(); + auto infoIt = windows->find(AsUint64(aWindowId)); + if (infoIt == windows->end()) { + MOZ_ASSERT(false); + return; + } + WindowInfo* info = infoIt->second.get(); + info->mWrNotifierEventsRunnable = nullptr; + + if (events->empty() && !info->mPendingWrNotifierEvents.empty()) { + events->swap(info->mPendingWrNotifierEvents); + } + } + + bool handleNext = true; + + while (!events->empty() && handleNext) { + auto& front = events->front(); + switch (front.mTag) { + case WrNotifierEvent::Tag::WakeUp: + WrNotifierEvent_HandleWakeUp(aWindowId, front.CompositeNeeded()); + handleNext = false; + break; + case WrNotifierEvent::Tag::NewFrameReady: + WrNotifierEvent_HandleNewFrameReady(aWindowId, front.CompositeNeeded(), + front.PublishId()); + handleNext = false; + break; + case WrNotifierEvent::Tag::ExternalEvent: + WrNotifierEvent_HandleExternalEvent(aWindowId, front.ExternalEvent()); + break; + } + events->pop(); + } + + { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + return; + } + WindowInfo* info = it->second.get(); + + if (!events->empty() || !info->mPendingWrNotifierEvents.empty()) { + PostWrNotifierEvents(aWindowId, info); + } + } +} + +void RenderThread::WrNotifierEvent_HandleWakeUp(wr::WindowId aWindowId, + bool aCompositeNeeded) { + MOZ_ASSERT(IsInRenderThread()); + + bool isTrackedFrame = false; + HandleFrameOneDoc(aWindowId, aCompositeNeeded, isTrackedFrame, Nothing()); +} + +void RenderThread::WrNotifierEvent_HandleNewFrameReady( + wr::WindowId aWindowId, bool aCompositeNeeded, FramePublishId aPublishId) { + MOZ_ASSERT(IsInRenderThread()); + + bool isTrackedFrame = true; + HandleFrameOneDoc(aWindowId, aCompositeNeeded, isTrackedFrame, + Some(aPublishId)); +} + +void RenderThread::WrNotifierEvent_HandleExternalEvent( + wr::WindowId aWindowId, UniquePtr aRendererEvent) { + MOZ_ASSERT(IsInRenderThread()); + + RunEvent(aWindowId, std::move(aRendererEvent)); +} + +void RenderThread::BeginRecordingForWindow(wr::WindowId aWindowId, + const TimeStamp& aRecordingStart, + wr::PipelineId aRootPipelineId) { + MOZ_ASSERT(IsInRenderThread()); + RendererOGL* renderer = GetRenderer(aWindowId); + MOZ_ASSERT(renderer); + + renderer->BeginRecording(aRecordingStart, aRootPipelineId); +} + +Maybe RenderThread::EndRecordingForWindow( + wr::WindowId aWindowId) { + MOZ_ASSERT(IsInRenderThread()); + + RendererOGL* renderer = GetRenderer(aWindowId); + MOZ_ASSERT(renderer); + return renderer->EndRecording(); +} + +void RenderThread::HandleFrameOneDoc(wr::WindowId aWindowId, bool aRender, + bool aTrackedFrame, + Maybe aPublishId) { + MOZ_ASSERT(IsInRenderThread()); + + if (mHasShutdown) { + return; + } + + HandleFrameOneDocInner(aWindowId, aRender, aTrackedFrame, aPublishId); + + if (aTrackedFrame) { + DecPendingFrameCount(aWindowId); + } +} + +void RenderThread::HandleFrameOneDocInner(wr::WindowId aWindowId, bool aRender, + bool aTrackedFrame, + Maybe aPublishId) { + if (IsDestroyed(aWindowId)) { + return; + } + + if (mHandlingDeviceReset) { + return; + } + + bool render = aRender; + PendingFrameInfo frame; + if (aTrackedFrame) { + // scope lock + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + + WindowInfo* info = it->second.get(); + PendingFrameInfo& frameInfo = info->mPendingFrames.front(); + + frame = frameInfo; + } else { + // Just give the frame info default values. + frame = {TimeStamp::Now(), VsyncId()}; + } + + // Sadly this doesn't include the lock, since we don't have the frame there + // yet. + glean::wr::time_to_render_start.AccumulateRawDuration(TimeStamp::Now() - + frame.mStartTime); + + // It is for ensuring that PrepareForUse() is called before + // RenderTextureHost::Lock(). + HandleRenderTextureOps(); + + if (aPublishId.isSome()) { + SetFramePublishId(aWindowId, aPublishId.ref()); + } + + UpdateAndRender(aWindowId, frame.mStartId, frame.mStartTime, render, + /* aReadbackSize */ Nothing(), + /* aReadbackFormat */ Nothing(), + /* aReadbackBuffer */ Nothing()); + + // The start time is from WebRenderBridgeParent::CompositeToTarget. From that + // point until now (when the frame is finally pushed to the screen) is + // equivalent to the COMPOSITE_TIME metric in the non-WR codepath. + TimeDuration compositeDuration = TimeStamp::Now() - frame.mStartTime; + mozilla::glean::gfx::composite_time.AccumulateRawDuration(compositeDuration); + PerfStats::RecordMeasurement(PerfStats::Metric::Compositing, + compositeDuration); +} + +void RenderThread::SetClearColor(wr::WindowId aWindowId, wr::ColorF aColor) { + if (mHasShutdown) { + return; + } + + if (!IsInRenderThread()) { + PostRunnable(NewRunnableMethod( + "wr::RenderThread::SetClearColor", this, &RenderThread::SetClearColor, + aWindowId, aColor)); + return; + } + + if (IsDestroyed(aWindowId)) { + return; + } + + auto it = mRenderers.find(aWindowId); + MOZ_ASSERT(it != mRenderers.end()); + if (it != mRenderers.end()) { + wr_renderer_set_clear_color(it->second->GetRenderer(), aColor); + } +} + +void RenderThread::SetProfilerUI(wr::WindowId aWindowId, + const nsACString& aUI) { + if (mHasShutdown) { + return; + } + + if (!IsInRenderThread()) { + PostRunnable(NewRunnableMethod( + "wr::RenderThread::SetProfilerUI", this, &RenderThread::SetProfilerUI, + aWindowId, nsCString(aUI))); + return; + } + + auto it = mRenderers.find(aWindowId); + if (it != mRenderers.end()) { + it->second->SetProfilerUI(aUI); + } +} + +void RenderThread::PostEvent(wr::WindowId aWindowId, + UniquePtr aEvent) { + PostRunnable(NewRunnableMethod&&>( + "wr::RenderThread::PostEvent", this, &RenderThread::RunEvent, aWindowId, + std::move(aEvent))); +} + +void RenderThread::RunEvent(wr::WindowId aWindowId, + UniquePtr aEvent) { + MOZ_ASSERT(IsInRenderThread()); + + aEvent->Run(*this, aWindowId); + aEvent = nullptr; +} + +static void NotifyDidRender(layers::CompositorBridgeParent* aBridge, + const RefPtr& aInfo, + VsyncId aCompositeStartId, + TimeStamp aCompositeStart, TimeStamp aRenderStart, + TimeStamp aEnd, bool aRender, + RendererStats aStats) { + if (aRender && aBridge->GetWrBridge()) { + // We call this here to mimic the behavior in LayerManagerComposite, as to + // not change what Talos measures. That is, we do not record an empty frame + // as a frame. + aBridge->GetWrBridge()->RecordFrame(); + } + + aBridge->NotifyDidRender(aCompositeStartId, aCompositeStart, aRenderStart, + aEnd, &aStats); + + for (const auto& epoch : aInfo->Raw().epochs) { + aBridge->NotifyPipelineRendered(epoch.pipeline_id, epoch.epoch, + aCompositeStartId, aCompositeStart, + aRenderStart, aEnd, &aStats); + } + + if (aBridge->GetWrBridge()) { + aBridge->GetWrBridge()->RetrySkippedComposite(); + } +} + +static void NotifyDidStartRender(layers::CompositorBridgeParent* aBridge) { + if (aBridge->GetWrBridge()) { + aBridge->GetWrBridge()->RetrySkippedComposite(); + } +} + +void RenderThread::SetFramePublishId(wr::WindowId aWindowId, + FramePublishId aPublishId) { + MOZ_ASSERT(IsInRenderThread()); + + auto it = mRenderers.find(aWindowId); + MOZ_ASSERT(it != mRenderers.end()); + if (it == mRenderers.end()) { + return; + } + auto& renderer = it->second; + + renderer->SetFramePublishId(aPublishId); +} + +void RenderThread::UpdateAndRender( + wr::WindowId aWindowId, const VsyncId& aStartId, + const TimeStamp& aStartTime, bool aRender, + const Maybe& aReadbackSize, + const Maybe& aReadbackFormat, + const Maybe>& aReadbackBuffer, bool* aNeedsYFlip) { + AUTO_PROFILER_LABEL("RenderThread::UpdateAndRender", GRAPHICS); + MOZ_ASSERT(IsInRenderThread()); + MOZ_ASSERT(aRender || aReadbackBuffer.isNothing()); + + auto it = mRenderers.find(aWindowId); + MOZ_ASSERT(it != mRenderers.end()); + if (it == mRenderers.end()) { + return; + } + + TimeStamp start = TimeStamp::Now(); + + auto& renderer = it->second; + + std::string markerName = "Composite #" + std::to_string(AsUint64(aWindowId)); + AutoProfilerTracing tracingCompositeMarker( + "Paint", markerName.c_str(), geckoprofiler::category::GRAPHICS, + Some(renderer->GetCompositorBridge()->GetInnerWindowId())); + + if (renderer->IsPaused()) { + aRender = false; + } + LOG("RenderThread::UpdateAndRender() aWindowId %" PRIx64 " aRender %d", + AsUint64(aWindowId), aRender); + + layers::CompositorThread()->Dispatch( + NewRunnableFunction("NotifyDidStartRenderRunnable", &NotifyDidStartRender, + renderer->GetCompositorBridge())); + + wr::RenderedFrameId latestFrameId; + RendererStats stats = {0}; + if (aRender) { + latestFrameId = renderer->UpdateAndRender( + aReadbackSize, aReadbackFormat, aReadbackBuffer, aNeedsYFlip, &stats); + } else { + renderer->Update(); + } + // Check graphics reset status even when rendering is skipped. + renderer->CheckGraphicsResetStatus("PostUpdate", /* aForce */ false); + + TimeStamp end = TimeStamp::Now(); + RefPtr info = renderer->GetLastPipelineInfo(); + + layers::CompositorThread()->Dispatch( + NewRunnableFunction("NotifyDidRenderRunnable", &NotifyDidRender, + renderer->GetCompositorBridge(), info, aStartId, + aStartTime, start, end, aRender, stats)); + + ipc::FileDescriptor fenceFd; + + if (latestFrameId.IsValid()) { + fenceFd = renderer->GetAndResetReleaseFence(); + + // Wait for GPU after posting NotifyDidRender, since the wait is not + // necessary for the NotifyDidRender. + // The wait is necessary for Textures recycling of AsyncImagePipelineManager + // and for avoiding GPU queue is filled with too much tasks. + // WaitForGPU's implementation is different for each platform. + auto timerId = glean::wr::gpu_wait_time.Start(); + renderer->WaitForGPU(); + glean::wr::gpu_wait_time.StopAndAccumulate(std::move(timerId)); + } else { + // Update frame id for NotifyPipelinesUpdated() when rendering does not + // happen, either because rendering was not requested or the frame was + // canceled. Rendering can sometimes be canceled if UpdateAndRender is + // called when the window is not yet ready (not mapped or 0 size). + latestFrameId = renderer->UpdateFrameId(); + } + + RenderedFrameId lastCompletedFrameId = renderer->GetLastCompletedFrameId(); + + RefPtr pipelineMgr = + renderer->GetCompositorBridge()->GetAsyncImagePipelineManager(); + // pipelineMgr should always be non-null here because it is only nulled out + // after the WebRenderAPI instance for the CompositorBridgeParent is + // destroyed, and that destruction blocks until the renderer thread has + // removed the relevant renderer. And after that happens we should never reach + // this code at all; it would bail out at the mRenderers.find check above. + MOZ_ASSERT(pipelineMgr); + pipelineMgr->NotifyPipelinesUpdated(info, latestFrameId, lastCompletedFrameId, + std::move(fenceFd)); +} + +void RenderThread::Pause(wr::WindowId aWindowId) { + MOZ_ASSERT(IsInRenderThread()); + LOG("RenderThread::Pause() aWindowId %" PRIx64 "", AsUint64(aWindowId)); + + auto it = mRenderers.find(aWindowId); + MOZ_ASSERT(it != mRenderers.end()); + if (it == mRenderers.end()) { + gfxCriticalNote << "RenderThread cannot find renderer for window " + << gfx::hexa(aWindowId) << " to pause."; + return; + } + auto& renderer = it->second; + renderer->Pause(); + + CrashReporter::AnnotateCrashReport( + CrashReporter::Annotation::GraphicsNumActiveRenderers, + (unsigned int)ActiveRendererCount()); +} + +bool RenderThread::Resume(wr::WindowId aWindowId) { + MOZ_ASSERT(IsInRenderThread()); + LOG("enderThread::Resume() aWindowId %" PRIx64 "", AsUint64(aWindowId)); + + auto it = mRenderers.find(aWindowId); + MOZ_ASSERT(it != mRenderers.end()); + if (it == mRenderers.end()) { + gfxCriticalNote << "RenderThread cannot find renderer for window " + << gfx::hexa(aWindowId) << " to resume."; + return false; + } + auto& renderer = it->second; + bool resumed = renderer->Resume(); + + CrashReporter::AnnotateCrashReport( + CrashReporter::Annotation::GraphicsNumActiveRenderers, + (unsigned int)ActiveRendererCount()); + + return resumed; +} + +bool RenderThread::TooManyPendingFrames(wr::WindowId aWindowId) { + const int64_t maxFrameCount = 1; + + // Too many pending frames if pending frames exit more than maxFrameCount + // or if RenderBackend is still processing a frame. + + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return true; + } + WindowInfo* info = it->second.get(); + + if (info->PendingCount() > maxFrameCount) { + return true; + } + // If there is no ongoing frame build, we accept a new frame. + return info->mPendingFrameBuild > 0; +} + +bool RenderThread::IsDestroyed(wr::WindowId aWindowId) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + return true; + } + + return it->second->mIsDestroyed; +} + +void RenderThread::SetDestroyed(wr::WindowId aWindowId) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + it->second->mIsDestroyed = true; +} + +void RenderThread::IncPendingFrameCount(wr::WindowId aWindowId, + const VsyncId& aStartId, + const TimeStamp& aStartTime) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + it->second->mPendingFrameBuild++; + it->second->mPendingFrames.push(PendingFrameInfo{aStartTime, aStartId}); +} + +void RenderThread::DecPendingFrameBuildCount(wr::WindowId aWindowId) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + WindowInfo* info = it->second.get(); + MOZ_RELEASE_ASSERT(info->mPendingFrameBuild >= 1); + info->mPendingFrameBuild--; +} + +void RenderThread::DecPendingFrameCount(wr::WindowId aWindowId) { + auto windows = mWindowInfos.Lock(); + auto it = windows->find(AsUint64(aWindowId)); + if (it == windows->end()) { + MOZ_ASSERT(false); + return; + } + WindowInfo* info = it->second.get(); + info->mPendingFrames.pop(); +} + +void RenderThread::RegisterExternalImage( + const wr::ExternalImageId& aExternalImageId, + already_AddRefed aTexture) { + MutexAutoLock lock(mRenderTextureMapLock); + + if (mHasShutdown) { + return; + } + MOZ_ASSERT(mRenderTextures.find(aExternalImageId) == mRenderTextures.end()); + RefPtr texture = aTexture; + if (texture->SyncObjectNeeded()) { + mSyncObjectNeededRenderTextures.emplace(aExternalImageId, texture); + } + mRenderTextures.emplace(aExternalImageId, texture); +} + +void RenderThread::UnregisterExternalImage( + const wr::ExternalImageId& aExternalImageId) { + MutexAutoLock lock(mRenderTextureMapLock); + if (mHasShutdown) { + return; + } + auto it = mRenderTextures.find(aExternalImageId); + if (it == mRenderTextures.end()) { + return; + } + + auto& texture = it->second; + if (texture->SyncObjectNeeded()) { + MOZ_RELEASE_ASSERT( + mSyncObjectNeededRenderTextures.erase(aExternalImageId) == 1); + } + + if (!IsInRenderThread()) { + // The RenderTextureHost should be released in render thread. So, post the + // deletion task here. + // The shmem and raw buffer are owned by compositor ipc channel. It's + // possible that RenderTextureHost is still exist after the shmem/raw buffer + // deletion. Then the buffer in RenderTextureHost becomes invalid. It's fine + // for this situation. Gecko will only release the buffer if WR doesn't need + // it. So, no one will access the invalid buffer in RenderTextureHost. + RefPtr texture = it->second; + mRenderTextures.erase(it); + mRenderTexturesDeferred.emplace_back(std::move(texture)); + PostRunnable(NewRunnableMethod( + "RenderThread::DeferredRenderTextureHostDestroy", this, + &RenderThread::DeferredRenderTextureHostDestroy)); + } else { + mRenderTextures.erase(it); + } +} + +void RenderThread::DestroyExternalImagesSyncWait( + const std::vector&& aIds) { + if (!IsInRenderThread()) { + layers::SynchronousTask task("Destroy external images"); + + RefPtr runnable = NS_NewRunnableFunction( + "RenderThread::DestroyExternalImagesSyncWait::Runnable", + [&task, ids = std::move(aIds)]() { + layers::AutoCompleteTask complete(&task); + RenderThread::Get()->DestroyExternalImages(std::move(ids)); + }); + + PostRunnable(runnable.forget()); + task.Wait(); + return; + } + DestroyExternalImages(std::move(aIds)); +} + +void RenderThread::DestroyExternalImages( + const std::vector&& aIds) { + MOZ_ASSERT(IsInRenderThread()); + + std::vector> hosts; + { + MutexAutoLock lock(mRenderTextureMapLock); + if (mHasShutdown) { + return; + } + + for (auto& id : aIds) { + auto it = mRenderTextures.find(id); + if (it == mRenderTextures.end()) { + continue; + } + hosts.emplace_back(it->second); + } + } + + for (auto& host : hosts) { + host->Destroy(); + } +} + +void RenderThread::PrepareForUse(const wr::ExternalImageId& aExternalImageId) { + AddRenderTextureOp(RenderTextureOp::PrepareForUse, aExternalImageId); +} + +void RenderThread::NotifyNotUsed(const wr::ExternalImageId& aExternalImageId) { + AddRenderTextureOp(RenderTextureOp::NotifyNotUsed, aExternalImageId); +} + +void RenderThread::NotifyForUse(const wr::ExternalImageId& aExternalImageId) { + AddRenderTextureOp(RenderTextureOp::NotifyForUse, aExternalImageId); +} + +void RenderThread::AddRenderTextureOp( + RenderTextureOp aOp, const wr::ExternalImageId& aExternalImageId) { + MOZ_ASSERT(!IsInRenderThread()); + + MutexAutoLock lock(mRenderTextureMapLock); + + auto it = mRenderTextures.find(aExternalImageId); + MOZ_ASSERT(it != mRenderTextures.end()); + if (it == mRenderTextures.end()) { + return; + } + + RefPtr texture = it->second; + mRenderTextureOps.emplace_back(aOp, std::move(texture)); + + if (mRenderTextureOpsRunnable) { + // Runnable was already triggered + return; + } + + RefPtr runnable = + NewRunnableMethod("RenderThread::HandleRenderTextureOps", this, + &RenderThread::HandleRenderTextureOps); + mRenderTextureOpsRunnable = runnable; + PostRunnable(runnable.forget()); +} + +void RenderThread::HandleRenderTextureOps() { + MOZ_ASSERT(IsInRenderThread()); + + std::list>> + renderTextureOps; + { + MutexAutoLock lock(mRenderTextureMapLock); + mRenderTextureOps.swap(renderTextureOps); + mRenderTextureOpsRunnable = nullptr; + } + + for (auto& it : renderTextureOps) { + switch (it.first) { + case RenderTextureOp::PrepareForUse: + it.second->PrepareForUse(); + break; + case RenderTextureOp::NotifyForUse: + it.second->NotifyForUse(); + break; + case RenderTextureOp::NotifyNotUsed: + it.second->NotifyNotUsed(); + break; + } + } +} + +void RenderThread::UnregisterExternalImageDuringShutdown( + const wr::ExternalImageId& aExternalImageId) { + MOZ_ASSERT(IsInRenderThread()); + MutexAutoLock lock(mRenderTextureMapLock); + MOZ_ASSERT(mHasShutdown); + mRenderTextures.erase(aExternalImageId); +} + +bool RenderThread::SyncObjectNeeded() { + MOZ_ASSERT(IsInRenderThread()); + MutexAutoLock lock(mRenderTextureMapLock); + return !mSyncObjectNeededRenderTextures.empty(); +} + +void RenderThread::DeferredRenderTextureHostDestroy() { + MutexAutoLock lock(mRenderTextureMapLock); + mRenderTexturesDeferred.clear(); +} + +RenderTextureHost* RenderThread::GetRenderTexture( + const wr::ExternalImageId& aExternalImageId) { + MutexAutoLock lock(mRenderTextureMapLock); + auto it = mRenderTextures.find(aExternalImageId); + MOZ_ASSERT(it != mRenderTextures.end()); + if (it == mRenderTextures.end()) { + return nullptr; + } + return it->second; +} + +void RenderThread::InitDeviceTask() { + MOZ_ASSERT(IsInRenderThread()); + MOZ_ASSERT(!mSingletonGL); + LOG("RenderThread::InitDeviceTask()"); + + if (gfx::gfxVars::UseSoftwareWebRender()) { + // Ensure we don't instantiate any shared GL context when SW-WR is used. + return; + } + + nsAutoCString err; + CreateSingletonGL(err); + if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) { + mProgramCache = MakeUnique(ThreadPool().Raw()); + } + // Query the shared GL context to force the + // lazy initialization to happen now. + SingletonGL(); +} + +void RenderThread::PostRunnable(already_AddRefed aRunnable) { + nsCOMPtr runnable = aRunnable; + mThread->Dispatch(runnable.forget()); +} + +#ifndef XP_WIN +static DeviceResetReason GLenumToResetReason(GLenum aReason) { + switch (aReason) { + case LOCAL_GL_NO_ERROR: + return DeviceResetReason::FORCED_RESET; + case LOCAL_GL_INNOCENT_CONTEXT_RESET_ARB: + return DeviceResetReason::DRIVER_ERROR; + case LOCAL_GL_PURGED_CONTEXT_RESET_NV: + return DeviceResetReason::NVIDIA_VIDEO; + case LOCAL_GL_GUILTY_CONTEXT_RESET_ARB: + return DeviceResetReason::RESET; + case LOCAL_GL_UNKNOWN_CONTEXT_RESET_ARB: + return DeviceResetReason::UNKNOWN; + case LOCAL_GL_OUT_OF_MEMORY: + return DeviceResetReason::OUT_OF_MEMORY; + default: + return DeviceResetReason::OTHER; + } +} +#endif + +void RenderThread::HandleDeviceReset(const char* aWhere, GLenum aReason) { + MOZ_ASSERT(IsInRenderThread()); + + // This happens only on simulate device reset. + if (aReason == LOCAL_GL_NO_ERROR) { + if (!mHandlingDeviceReset) { + mHandlingDeviceReset = true; + + MutexAutoLock lock(mRenderTextureMapLock); + mRenderTexturesDeferred.clear(); + for (const auto& entry : mRenderTextures) { + entry.second->ClearCachedResources(); + } + + // All RenderCompositors will be destroyed by the GPUProcessManager in + // either OnRemoteProcessDeviceReset via the GPUChild, or + // OnInProcessDeviceReset here directly. + if (XRE_IsGPUProcess()) { + gfx::GPUParent::GetSingleton()->NotifyDeviceReset(); + } else { + NS_DispatchToMainThread(NS_NewRunnableFunction( + "gfx::GPUProcessManager::OnInProcessDeviceReset", []() -> void { + gfx::GPUProcessManager::Get()->OnInProcessDeviceReset( + /* aTrackThreshold */ false); + })); + } + } + return; + } + + if (mHandlingDeviceReset) { + return; + } + + mHandlingDeviceReset = true; + +#ifndef XP_WIN + // On Windows, see DeviceManagerDx::MaybeResetAndReacquireDevices. + gfx::GPUProcessManager::RecordDeviceReset(GLenumToResetReason(aReason)); +#endif + + { + MutexAutoLock lock(mRenderTextureMapLock); + mRenderTexturesDeferred.clear(); + for (const auto& entry : mRenderTextures) { + entry.second->ClearCachedResources(); + } + } + + // All RenderCompositors will be destroyed by the GPUProcessManager in + // either OnRemoteProcessDeviceReset via the GPUChild, or + // OnInProcessDeviceReset here directly. + // On Windows, device will be re-created before sessions re-creation. + gfxCriticalNote << "GFX: RenderThread detected a device reset in " << aWhere; + if (XRE_IsGPUProcess()) { + gfx::GPUParent::GetSingleton()->NotifyDeviceReset(); + } else { +#ifndef XP_WIN + // FIXME(aosmond): Do we need to do this on Windows? nsWindow::OnPaint + // seems to do its own detection for the parent process. + bool guilty = aReason == LOCAL_GL_GUILTY_CONTEXT_RESET_ARB; + NS_DispatchToMainThread(NS_NewRunnableFunction( + "gfx::GPUProcessManager::OnInProcessDeviceReset", [guilty]() -> void { + gfx::GPUProcessManager::Get()->OnInProcessDeviceReset(guilty); + })); +#endif + } +} + +bool RenderThread::IsHandlingDeviceReset() { + MOZ_ASSERT(IsInRenderThread()); + return mHandlingDeviceReset; +} + +void RenderThread::SimulateDeviceReset() { + if (!IsInRenderThread()) { + PostRunnable(NewRunnableMethod("RenderThread::SimulateDeviceReset", this, + &RenderThread::SimulateDeviceReset)); + } else { + // When this function is called GPUProcessManager::SimulateDeviceReset() + // already triggers destroying all CompositorSessions before re-creating + // them. + HandleDeviceReset("SimulateDeviceReset", LOCAL_GL_NO_ERROR); + } +} + +static void DoNotifyWebRenderError(WebRenderError aError) { + layers::CompositorManagerParent::NotifyWebRenderError(aError); +} + +void RenderThread::NotifyWebRenderError(WebRenderError aError) { + MOZ_ASSERT(IsInRenderThread()); + + layers::CompositorThread()->Dispatch(NewRunnableFunction( + "DoNotifyWebRenderErrorRunnable", &DoNotifyWebRenderError, aError)); +} + +void RenderThread::HandleWebRenderError(WebRenderError aError) { + MOZ_ASSERT(IsInRenderThread()); + if (mHandlingWebRenderError) { + return; + } + + NotifyWebRenderError(aError); + + { + MutexAutoLock lock(mRenderTextureMapLock); + mRenderTexturesDeferred.clear(); + for (const auto& entry : mRenderTextures) { + entry.second->ClearCachedResources(); + } + } + mHandlingWebRenderError = true; + // WebRender is going to be disabled by + // GPUProcessManager::NotifyWebRenderError() +} + +bool RenderThread::IsHandlingWebRenderError() { + MOZ_ASSERT(IsInRenderThread()); + return mHandlingWebRenderError; +} + +gl::GLContext* RenderThread::SingletonGL() { + nsAutoCString err; + auto* gl = SingletonGL(err); + if (!err.IsEmpty()) { + gfxCriticalNote << err.get(); + } + return gl; +} + +void RenderThread::CreateSingletonGL(nsACString& aError) { + MOZ_ASSERT(IsInRenderThread()); + LOG("RenderThread::CreateSingletonGL()"); + + mSingletonGL = CreateGLContext(aError); + mSingletonGLIsForHardwareWebRender = !gfx::gfxVars::UseSoftwareWebRender(); +} + +gl::GLContext* RenderThread::SingletonGL(nsACString& aError) { + MOZ_ASSERT(IsInRenderThread()); + if (!mSingletonGL) { + CreateSingletonGL(aError); + mShaders = nullptr; + } + if (mSingletonGL && mSingletonGLIsForHardwareWebRender && !mShaders) { + mShaders = MakeUnique(mSingletonGL, mProgramCache.get()); + } + + return mSingletonGL.get(); +} + +gl::GLContext* RenderThread::SingletonGLForCompositorOGL() { + MOZ_RELEASE_ASSERT(gfx::gfxVars::UseSoftwareWebRender()); + + if (mSingletonGLIsForHardwareWebRender) { + // Clear singleton GL, since GLContext is for hardware WebRender. + ClearSingletonGL(); + } + return SingletonGL(); +} + +void RenderThread::ClearSingletonGL() { + MOZ_ASSERT(IsInRenderThread()); + LOG("RenderThread::ClearSingletonGL()"); + + if (mSurfacePool) { + mSurfacePool->DestroyGLResourcesForContext(mSingletonGL); + } + if (mProgramsForCompositorOGL) { + mProgramsForCompositorOGL->Clear(); + mProgramsForCompositorOGL = nullptr; + } + if (mShaders) { + if (mSingletonGL) { + mSingletonGL->MakeCurrent(); + } + mShaders = nullptr; + } + mSingletonGL = nullptr; +} + +RefPtr +RenderThread::GetProgramsForCompositorOGL() { + if (!mSingletonGL) { + return nullptr; + } + + if (!mProgramsForCompositorOGL) { + mProgramsForCompositorOGL = + MakeAndAddRef(mSingletonGL); + } + return mProgramsForCompositorOGL; +} + +RefPtr RenderThread::SharedSurfacePool() { +#if defined(XP_MACOSX) || defined(MOZ_WAYLAND) + if (!mSurfacePool) { + size_t poolSizeLimit = + StaticPrefs::gfx_webrender_compositor_surface_pool_size_AtStartup(); + mSurfacePool = layers::SurfacePool::Create(poolSizeLimit); + } +#endif + return mSurfacePool; +} + +void RenderThread::ClearSharedSurfacePool() { mSurfacePool = nullptr; } + +static void GLAPIENTRY DebugMessageCallback(GLenum aSource, GLenum aType, + GLuint aId, GLenum aSeverity, + GLsizei aLength, + const GLchar* aMessage, + const GLvoid* aUserParam) { + constexpr const char* kContextLost = "Context has been lost."; + + if (StaticPrefs::gfx_webrender_gl_debug_message_critical_note_AtStartup() && + aSeverity == LOCAL_GL_DEBUG_SEVERITY_HIGH) { + auto message = std::string(aMessage, aLength); + // When content lost happned, error messages are flooded by its message. + if (message != kContextLost) { + gfxCriticalNote << message; + } else { + gfxCriticalNoteOnce << message; + } + } + + if (StaticPrefs::gfx_webrender_gl_debug_message_print_AtStartup()) { + gl::GLContext* gl = (gl::GLContext*)aUserParam; + gl->DebugCallback(aSource, aType, aId, aSeverity, aLength, aMessage); + } +} + +// static +void RenderThread::MaybeEnableGLDebugMessage(gl::GLContext* aGLContext) { + if (!aGLContext) { + return; + } + + bool enableDebugMessage = + StaticPrefs::gfx_webrender_gl_debug_message_critical_note_AtStartup() || + StaticPrefs::gfx_webrender_gl_debug_message_print_AtStartup(); + + if (enableDebugMessage && + aGLContext->IsExtensionSupported(gl::GLContext::KHR_debug)) { + aGLContext->fEnable(LOCAL_GL_DEBUG_OUTPUT); + aGLContext->fDisable(LOCAL_GL_DEBUG_OUTPUT_SYNCHRONOUS); + aGLContext->fDebugMessageCallback(&DebugMessageCallback, (void*)aGLContext); + aGLContext->fDebugMessageControl(LOCAL_GL_DONT_CARE, LOCAL_GL_DONT_CARE, + LOCAL_GL_DONT_CARE, 0, nullptr, true); + } +} + +WebRenderShaders::WebRenderShaders(gl::GLContext* gl, + WebRenderProgramCache* programCache) { + mGL = gl; + mShaders = + wr_shaders_new(gl, programCache ? programCache->Raw() : nullptr, + StaticPrefs::gfx_webrender_precache_shaders_AtStartup()); +} + +WebRenderShaders::~WebRenderShaders() { + wr_shaders_delete(mShaders, mGL.get()); +} + +WebRenderThreadPool::WebRenderThreadPool(bool low_priority) { + mThreadPool = wr_thread_pool_new(low_priority); +} + +WebRenderThreadPool::~WebRenderThreadPool() { Release(); } + +void WebRenderThreadPool::Release() { + if (mThreadPool) { + wr_thread_pool_delete(mThreadPool); + mThreadPool = nullptr; + } +} + +WebRenderProgramCache::WebRenderProgramCache(wr::WrThreadPool* aThreadPool) { + MOZ_ASSERT(aThreadPool); + + nsAutoString path; + if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) { + path.Append(gfx::gfxVars::ProfDirectory()); + } + mProgramCache = wr_program_cache_new(&path, aThreadPool); + if (gfx::gfxVars::UseWebRenderProgramBinaryDisk()) { + wr_try_load_startup_shaders_from_disk(mProgramCache); + } +} + +WebRenderProgramCache::~WebRenderProgramCache() { + wr_program_cache_delete(mProgramCache); +} + +} // namespace mozilla::wr + +#ifdef XP_WIN +static already_AddRefed CreateGLContextANGLE( + nsACString& aError) { + const RefPtr d3d11Device = + gfx::DeviceManagerDx::Get()->GetCompositorDevice(); + if (!d3d11Device) { + aError.Assign("RcANGLE(no compositor device for EGLDisplay)"_ns); + return nullptr; + } + + nsCString failureId; + const auto lib = gl::GLLibraryEGL::Get(&failureId); + if (!lib) { + aError.Assign( + nsPrintfCString("RcANGLE(load EGL lib failed: %s)", failureId.get())); + return nullptr; + } + + const auto egl = lib->CreateDisplay(d3d11Device.get()); + if (!egl) { + aError.Assign(nsPrintfCString("RcANGLE(create EGLDisplay failed: %s)", + failureId.get())); + return nullptr; + } + + gl::CreateContextFlags flags = gl::CreateContextFlags::PREFER_ES3; + + if (StaticPrefs::gfx_webrender_prefer_robustness_AtStartup()) { + flags |= gl::CreateContextFlags::PREFER_ROBUSTNESS; + } + + if (egl->IsExtensionSupported( + gl::EGLExtension::MOZ_create_context_provoking_vertex_dont_care)) { + flags |= gl::CreateContextFlags::PROVOKING_VERTEX_DONT_CARE; + } + + // Create GLContext with dummy EGLSurface, the EGLSurface is not used. + // Instread we override it with EGLSurface of SwapChain's back buffer. + + auto gl = gl::GLContextEGL::CreateWithoutSurface(egl, {flags}, &failureId); + if (!gl || !gl->IsANGLE()) { + aError.Assign(nsPrintfCString("RcANGLE(create GL context failed: %p, %s)", + gl.get(), failureId.get())); + return nullptr; + } + + if (!gl->MakeCurrent()) { + aError.Assign( + nsPrintfCString("RcANGLE(make current GL context failed: %p, %x)", + gl.get(), gl->mEgl->mLib->fGetError())); + return nullptr; + } + + return gl.forget(); +} +#endif + +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GTK) +static already_AddRefed CreateGLContextEGL() { + // Create GLContext with dummy EGLSurface. + bool forHardwareWebRender = true; + // SW-WR uses CompositorOGL in native compositor. + if (gfx::gfxVars::UseSoftwareWebRender()) { + forHardwareWebRender = false; + } + RefPtr gl = + gl::GLContextProviderEGL::CreateForCompositorWidget( + nullptr, forHardwareWebRender, /* aForceAccelerated */ true); + if (!gl || !gl->MakeCurrent()) { + gfxCriticalNote << "Failed GL context creation for hardware WebRender: " + << forHardwareWebRender; + return nullptr; + } + return gl.forget(); +} +#endif + +#ifdef XP_MACOSX +static already_AddRefed CreateGLContextCGL() { + nsCString failureUnused; + return gl::GLContextProvider::CreateHeadless( + {gl::CreateContextFlags::ALLOW_OFFLINE_RENDERER | + gl::CreateContextFlags::FORBID_SOFTWARE}, + &failureUnused); +} +#endif + +static already_AddRefed CreateGLContext(nsACString& aError) { + RefPtr gl; + +#ifdef XP_WIN + if (gfx::gfxVars::UseWebRenderANGLE()) { + gl = CreateGLContextANGLE(aError); + } +#elif defined(MOZ_WIDGET_ANDROID) + gl = CreateGLContextEGL(); +#elif defined(MOZ_WIDGET_GTK) + if (gfx::gfxVars::UseEGL()) { + gl = CreateGLContextEGL(); + } +#elif XP_MACOSX + gl = CreateGLContextCGL(); +#endif + + wr::RenderThread::MaybeEnableGLDebugMessage(gl); + + return gl.forget(); +} + +extern "C" { + +void wr_notifier_wake_up(mozilla::wr::WrWindowId aWindowId, + bool aCompositeNeeded) { + // wake_up is used for things like propagating debug options or memory + // pressure events, so we are not tracking pending frame counts. + mozilla::wr::RenderThread::Get()->WrNotifierEvent_WakeUp(aWindowId, + aCompositeNeeded); +} + +void wr_notifier_new_frame_ready(mozilla::wr::WrWindowId aWindowId, + bool aCompositeNeeded, + mozilla::wr::FramePublishId aPublishId) { + auto* renderThread = mozilla::wr::RenderThread::Get(); + renderThread->DecPendingFrameBuildCount(aWindowId); + + renderThread->WrNotifierEvent_NewFrameReady(aWindowId, aCompositeNeeded, + aPublishId); +} + +void wr_notifier_external_event(mozilla::wr::WrWindowId aWindowId, + size_t aRawEvent) { + mozilla::wr::RenderThread::Get()->WrNotifierEvent_ExternalEvent( + mozilla::wr::WindowId(aWindowId), aRawEvent); +} + +static void NotifyScheduleRender(mozilla::wr::WrWindowId aWindowId, + wr::RenderReasons aReasons) { + RefPtr cbp = mozilla::layers:: + CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId); + if (cbp) { + cbp->ScheduleComposition(aReasons); + } +} + +void wr_schedule_render(mozilla::wr::WrWindowId aWindowId, + wr::RenderReasons aReasons) { + layers::CompositorThread()->Dispatch(NewRunnableFunction( + "NotifyScheduleRender", &NotifyScheduleRender, aWindowId, aReasons)); +} + +static void NotifyDidSceneBuild( + mozilla::wr::WrWindowId aWindowId, + const RefPtr& aInfo) { + RefPtr cbp = mozilla::layers:: + CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId); + if (cbp) { + cbp->NotifyDidSceneBuild(aInfo); + } +} + +void wr_finished_scene_build(mozilla::wr::WrWindowId aWindowId, + mozilla::wr::WrPipelineInfo* aPipelineInfo) { + RefPtr info = new wr::WebRenderPipelineInfo(); + info->Raw() = std::move(*aPipelineInfo); + layers::CompositorThread()->Dispatch(NewRunnableFunction( + "NotifyDidSceneBuild", &NotifyDidSceneBuild, aWindowId, info)); +} + +} // extern C diff --git a/gfx/webrender_bindings/RenderThread.h b/gfx/webrender_bindings/RenderThread.h new file mode 100644 index 0000000000..aa508e5581 --- /dev/null +++ b/gfx/webrender_bindings/RenderThread.h @@ -0,0 +1,493 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_LAYERS_RENDERTHREAD_H +#define MOZILLA_LAYERS_RENDERTHREAD_H + +#include "base/basictypes.h" // for DISALLOW_EVIL_CONSTRUCTORS +#include "base/platform_thread.h" // for PlatformThreadId +#include "base/thread.h" // for Thread +#include "base/message_loop.h" +#include "GLTypes.h" // for GLenum +#include "nsISupportsImpl.h" +#include "mozilla/gfx/Point.h" +#include "mozilla/MozPromise.h" +#include "mozilla/DataMutex.h" +#include "mozilla/Maybe.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/webrender/WebRenderTypes.h" +#include "mozilla/layers/CompositionRecorder.h" +#include "mozilla/layers/SynchronousTask.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/VsyncDispatcher.h" + +#include +#include +#include + +namespace mozilla { +namespace gl { +class GLContext; +} // namespace gl +namespace layers { +class CompositorBridgeParent; +class ShaderProgramOGLsHolder; +class SurfacePool; +} // namespace layers +namespace wr { + +typedef MozPromise MemoryReportPromise; + +class RendererOGL; +class RenderTextureHost; +class RenderThread; + +/// A rayon thread pool that is shared by all WebRender instances within a +/// process. +class WebRenderThreadPool { + public: + explicit WebRenderThreadPool(bool low_priority); + + ~WebRenderThreadPool(); + + wr::WrThreadPool* Raw() { + // If this pointer is null we are likely at some late shutdown stage, + // when threads are no longer safe to interact with. + MOZ_RELEASE_ASSERT(mThreadPool); + return mThreadPool; + } + + /// Prematurely destroys this handle to the thread pool. + /// After calling this the object is useless. + void Release(); + + protected: + wr::WrThreadPool* mThreadPool; +}; + +class WebRenderProgramCache final { + public: + explicit WebRenderProgramCache(wr::WrThreadPool* aThreadPool); + + ~WebRenderProgramCache(); + + wr::WrProgramCache* Raw() { return mProgramCache; } + + protected: + wr::WrProgramCache* mProgramCache; +}; + +class WebRenderShaders final { + public: + WebRenderShaders(gl::GLContext* gl, WebRenderProgramCache* programCache); + ~WebRenderShaders(); + + wr::WrShaders* RawShaders() { return mShaders; } + + protected: + RefPtr mGL; + wr::WrShaders* mShaders; +}; + +class WebRenderPipelineInfo final { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderPipelineInfo); + + const wr::WrPipelineInfo& Raw() const { return mPipelineInfo; } + wr::WrPipelineInfo& Raw() { return mPipelineInfo; } + + protected: + ~WebRenderPipelineInfo() = default; + wr::WrPipelineInfo mPipelineInfo; +}; + +/// Base class for an event that can be scheduled to run on the render thread. +/// +/// The event can be passed through the same channels as regular WebRender +/// messages to preserve ordering. +class RendererEvent { + public: + virtual ~RendererEvent() = default; + virtual void Run(RenderThread& aRenderThread, wr::WindowId aWindow) = 0; +}; + +/// The render thread is where WebRender issues all of its GPU work, and as much +/// as possible this thread should only serve this purpose. +/// +/// The render thread owns the different RendererOGLs (one per window) and +/// implements the RenderNotifier api exposed by the WebRender bindings. +/// +/// Callers are not allowed to post tasks to the render thread's event loop +/// directly and must instead use the RendererEvent mechanism which avoids races +/// between the events and WebRender's own messages. +/// +/// The GL context(s) should be created and used on this thread only. +/// XXX - I've tried to organize code so that we can potentially avoid making +/// this a singleton since this bad habit has a tendency to bite us later, but +/// I haven't gotten all the way there either, in order to focus on the more +/// important pieces first. So we are a bit in-between (this is totally a +/// singleton but in some places we pretend it's not). Hopefully we can evolve +/// this in a way that keeps the door open to removing the singleton bits. +class RenderThread final { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DELETE_ON_MAIN_THREAD(RenderThread) + + public: + /// Can be called from any thread. + static RenderThread* Get(); + + /// Can only be called from the main thread. + static void Start(uint32_t aNamespace); + + /// Can only be called from the main thread. + static void ShutDown(); + + /// Can be called from any thread. + static bool IsInRenderThread(); + + /// Can be called from any thread. + static already_AddRefed GetRenderThread(); + + // Can be called from any thread. Dispatches an event to the Renderer thread + // to iterate over all Renderers, accumulates memory statistics, and resolves + // the return promise. + static RefPtr AccumulateMemoryReport( + MemoryReport aInitial); + + /// Can only be called from the render thread. + void AddRenderer(wr::WindowId aWindowId, UniquePtr aRenderer); + + /// Can only be called from the render thread. + void RemoveRenderer(wr::WindowId aWindowId); + + /// Can only be called from the render thread. + RendererOGL* GetRenderer(wr::WindowId aWindowId); + + /// Automatically forwarded to the render thread. + void SetClearColor(wr::WindowId aWindowId, wr::ColorF aColor); + + /// Automatically forwarded to the render thread. + void SetProfilerUI(wr::WindowId aWindowId, const nsACString& aUI); + + /// Automatically forwarded to the render thread. + void PipelineSizeChanged(wr::WindowId aWindowId, uint64_t aPipelineId, + float aWidth, float aHeight); + + /// Post RendererEvent to the render thread. + void PostEvent(wr::WindowId aWindowId, UniquePtr aEvent); + + /// Can only be called from the render thread. + void SetFramePublishId(wr::WindowId aWindowId, FramePublishId aPublishId); + + /// Can only be called from the render thread. + void UpdateAndRender(wr::WindowId aWindowId, const VsyncId& aStartId, + const TimeStamp& aStartTime, bool aRender, + const Maybe& aReadbackSize, + const Maybe& aReadbackFormat, + const Maybe>& aReadbackBuffer, + bool* aNeedsYFlip = nullptr); + + void Pause(wr::WindowId aWindowId); + bool Resume(wr::WindowId aWindowId); + + /// Can be called from any thread. + void RegisterExternalImage(const wr::ExternalImageId& aExternalImageId, + already_AddRefed aTexture); + + /// Can be called from any thread. + void UnregisterExternalImage(const wr::ExternalImageId& aExternalImageId); + + /// Can be called from any thread. + void DestroyExternalImagesSyncWait( + const std::vector&& aIds); + + /// Can be called from any thread. + void PrepareForUse(const wr::ExternalImageId& aExternalImageId); + + /// Can be called from any thread. + void NotifyNotUsed(const wr::ExternalImageId& aExternalImageId); + + /// Can be called from any thread. + void NotifyForUse(const wr::ExternalImageId& aExternalImageId); + + void HandleRenderTextureOps(); + + /// Can only be called from the render thread. + void UnregisterExternalImageDuringShutdown( + const wr::ExternalImageId& aExternalImageId); + + /// Can only be called from the render thread. + RenderTextureHost* GetRenderTexture( + const wr::ExternalImageId& aExternalImageId); + + /// Can be called from any thread. + bool IsDestroyed(wr::WindowId aWindowId); + /// Can be called from any thread. + void SetDestroyed(wr::WindowId aWindowId); + /// Can be called from any thread. + bool TooManyPendingFrames(wr::WindowId aWindowId); + /// Can be called from any thread. + void IncPendingFrameCount(wr::WindowId aWindowId, const VsyncId& aStartId, + const TimeStamp& aStartTime); + /// Can be called from any thread. + void DecPendingFrameBuildCount(wr::WindowId aWindowId); + void DecPendingFrameCount(wr::WindowId aWindowId); + + // RenderNotifier implementation + void WrNotifierEvent_WakeUp(WrWindowId aWindowId, bool aCompositeNeeded); + void WrNotifierEvent_NewFrameReady(WrWindowId aWindowId, + bool aCompositeNeeded, + FramePublishId aPublishId); + void WrNotifierEvent_ExternalEvent(WrWindowId aWindowId, size_t aRawEvent); + + /// Can be called from any thread. + WebRenderThreadPool& ThreadPool() { return mThreadPool; } + + /// Thread pool for low priority scene building + /// Can be called from any thread. + WebRenderThreadPool& ThreadPoolLP() { return mThreadPoolLP; } + + /// Returns the cache used to serialize shader programs to disk, if enabled. + /// + /// Can only be called from the render thread. + WebRenderProgramCache* GetProgramCache() { + MOZ_ASSERT(IsInRenderThread()); + return mProgramCache.get(); + } + + /// Can only be called from the render thread. + WebRenderShaders* GetShaders() { + MOZ_ASSERT(IsInRenderThread()); + return mShaders.get(); + } + + /// Can only be called from the render thread. + gl::GLContext* SingletonGL(nsACString& aError); + gl::GLContext* SingletonGL(); + gl::GLContext* SingletonGLForCompositorOGL(); + void ClearSingletonGL(); + RefPtr SharedSurfacePool(); + void ClearSharedSurfacePool(); + + RefPtr GetProgramsForCompositorOGL(); + + /// Can only be called from the render thread. + void HandleDeviceReset(const char* aWhere, GLenum aReason); + /// Can only be called from the render thread. + bool IsHandlingDeviceReset(); + /// Can be called from any thread. + void SimulateDeviceReset(); + + /// Can only be called from the render thread. + void NotifyWebRenderError(WebRenderError aError); + + /// Can only be called from the render thread. + void HandleWebRenderError(WebRenderError aError); + /// Can only be called from the render thread. + bool IsHandlingWebRenderError(); + + /// Can only be called from the render thread. + bool SyncObjectNeeded(); + + size_t RendererCount() const; + size_t ActiveRendererCount() const; + + void BeginRecordingForWindow(wr::WindowId aWindowId, + const TimeStamp& aRecordingStart, + wr::PipelineId aRootPipelineId); + + Maybe EndRecordingForWindow(wr::WindowId aWindowId); + + static void MaybeEnableGLDebugMessage(gl::GLContext* aGLContext); + + private: + enum class RenderTextureOp { + PrepareForUse, + NotifyForUse, + NotifyNotUsed, + }; + class WrNotifierEvent { + public: + enum class Tag { + WakeUp, + NewFrameReady, + ExternalEvent, + }; + const Tag mTag; + + private: + WrNotifierEvent(const Tag aTag, const bool aCompositeNeeded) + : mTag(aTag), mCompositeNeeded(aCompositeNeeded) { + MOZ_ASSERT(mTag == Tag::WakeUp); + } + WrNotifierEvent(const Tag aTag, bool aCompositeNeeded, + FramePublishId aPublishId) + : mTag(aTag), + mCompositeNeeded(aCompositeNeeded), + mPublishId(aPublishId) { + MOZ_ASSERT(mTag == Tag::NewFrameReady); + } + WrNotifierEvent(const Tag aTag, UniquePtr&& aRendererEvent) + : mTag(aTag), mRendererEvent(std::move(aRendererEvent)) { + MOZ_ASSERT(mTag == Tag::ExternalEvent); + } + + const bool mCompositeNeeded = false; + const FramePublishId mPublishId = FramePublishId::INVALID; + UniquePtr mRendererEvent; + + public: + static WrNotifierEvent WakeUp(const bool aCompositeNeeded) { + return WrNotifierEvent(Tag::WakeUp, aCompositeNeeded); + } + + static WrNotifierEvent NewFrameReady(const bool aCompositeNeeded, + const FramePublishId aPublishId) { + return WrNotifierEvent(Tag::NewFrameReady, aCompositeNeeded, aPublishId); + } + + static WrNotifierEvent ExternalEvent( + UniquePtr&& aRendererEvent) { + return WrNotifierEvent(Tag::ExternalEvent, std::move(aRendererEvent)); + } + + bool CompositeNeeded() { + if (mTag == Tag::WakeUp || mTag == Tag::NewFrameReady) { + return mCompositeNeeded; + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return false; + } + FramePublishId PublishId() { + if (mTag == Tag::NewFrameReady) { + return mPublishId; + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return FramePublishId::INVALID; + } + UniquePtr ExternalEvent() { + if (mTag == Tag::ExternalEvent) { + MOZ_ASSERT(mRendererEvent); + return std::move(mRendererEvent); + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return nullptr; + } + }; + + explicit RenderThread(RefPtr aThread); + + void HandleFrameOneDocInner(wr::WindowId aWindowId, bool aRender, + bool aTrackedFrame, + Maybe aPublishId); + + void DeferredRenderTextureHostDestroy(); + void ShutDownTask(); + void InitDeviceTask(); + void HandleFrameOneDoc(wr::WindowId aWindowId, bool aRender, + bool aTrackedFrame, Maybe aPublishId); + void RunEvent(wr::WindowId aWindowId, UniquePtr aEvent); + void PostRunnable(already_AddRefed aRunnable); + + void DoAccumulateMemoryReport(MemoryReport, + const RefPtr&); + + void AddRenderTextureOp(RenderTextureOp aOp, + const wr::ExternalImageId& aExternalImageId); + + void CreateSingletonGL(nsACString& aError); + + void DestroyExternalImages(const std::vector&& aIds); + + struct WindowInfo; + + void PostWrNotifierEvents(WrWindowId aWindowId); + void PostWrNotifierEvents(WrWindowId aWindowId, WindowInfo* aInfo); + void HandleWrNotifierEvents(WrWindowId aWindowId); + void WrNotifierEvent_HandleWakeUp(wr::WindowId aWindowId, + bool aCompositeNeeded); + void WrNotifierEvent_HandleNewFrameReady(wr::WindowId aWindowId, + bool aCompositeNeeded, + FramePublishId aPublishId); + void WrNotifierEvent_HandleExternalEvent( + wr::WindowId aWindowId, UniquePtr aRendererEvent); + + ~RenderThread(); + + RefPtr const mThread; + + WebRenderThreadPool mThreadPool; + WebRenderThreadPool mThreadPoolLP; + + UniquePtr mProgramCache; + UniquePtr mShaders; + RefPtr mProgramsForCompositorOGL; + + // An optional shared GLContext to be used for all + // windows. + RefPtr mSingletonGL; + bool mSingletonGLIsForHardwareWebRender; + + RefPtr mSurfacePool; + + std::map> mRenderers; + + struct PendingFrameInfo { + TimeStamp mStartTime; + VsyncId mStartId; + }; + + struct WindowInfo { + int64_t PendingCount() { return mPendingFrames.size(); } + std::queue mPendingFrames; + uint8_t mPendingFrameBuild = 0; + bool mIsDestroyed = false; + RefPtr mWrNotifierEventsRunnable; + std::queue mPendingWrNotifierEvents; + }; + + DataMutex>> mWindowInfos; + + std::unordered_map>> + mWrNotifierEventsQueues; + + struct ExternalImageIdHashFn { + std::size_t operator()(const wr::ExternalImageId& aId) const { + return HashGeneric(wr::AsUint64(aId)); + } + }; + + Mutex mRenderTextureMapLock; + std::unordered_map, + ExternalImageIdHashFn> + mRenderTextures MOZ_GUARDED_BY(mRenderTextureMapLock); + std::unordered_map, + ExternalImageIdHashFn> + mSyncObjectNeededRenderTextures MOZ_GUARDED_BY(mRenderTextureMapLock); + std::list>> + mRenderTextureOps MOZ_GUARDED_BY(mRenderTextureMapLock); + + // Used to remove all RenderTextureHost that are going to be removed by + // a deferred callback and remove them right away without waiting for the + // callback. On device reset we have to remove all GL related resources right + // away. + std::list> mRenderTexturesDeferred + MOZ_GUARDED_BY(mRenderTextureMapLock); + + RefPtr mRenderTextureOpsRunnable + MOZ_GUARDED_BY(mRenderTextureMapLock); + + // Set from MainThread, read from either MainThread or RenderThread + bool mHasShutdown; + + // Only accessed from the RenderThread + bool mHandlingDeviceReset; + bool mHandlingWebRenderError; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RendererOGL.cpp b/gfx/webrender_bindings/RendererOGL.cpp new file mode 100644 index 0000000000..3c4d13e376 --- /dev/null +++ b/gfx/webrender_bindings/RendererOGL.cpp @@ -0,0 +1,430 @@ +/* -*- 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 "RendererOGL.h" + +#include "base/task.h" +#include "GLContext.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/gfx/Types.h" +#include "mozilla/layers/CompositorBridgeParent.h" +#include "mozilla/layers/CompositorThread.h" +#include "mozilla/layers/LayersTypes.h" +#include "mozilla/layers/ProfilerScreenshots.h" +#include "mozilla/webrender/RenderCompositor.h" +#include "mozilla/webrender/RenderTextureHost.h" +#include "mozilla/widget/CompositorWidget.h" + +namespace mozilla { +namespace wr { + +class RendererRecordedFrame final : public layers::RecordedFrame { + public: + RendererRecordedFrame(const TimeStamp& aTimeStamp, wr::Renderer* aRenderer, + const wr::RecordedFrameHandle aHandle, + const gfx::IntSize& aSize) + : RecordedFrame(aTimeStamp), + mRenderer(aRenderer), + mSize(aSize), + mHandle(aHandle) {} + + already_AddRefed GetSourceSurface() override { + if (!mSurface) { + mSurface = gfx::Factory::CreateDataSourceSurface( + mSize, gfx::SurfaceFormat::B8G8R8A8, /* aZero = */ false); + + gfx::DataSourceSurface::ScopedMap map(mSurface, + gfx::DataSourceSurface::WRITE); + + if (!wr_renderer_map_recorded_frame(mRenderer, mHandle, map.GetData(), + map.GetStride() * mSize.height, + map.GetStride())) { + return nullptr; + } + } + + return do_AddRef(mSurface); + } + + private: + wr::Renderer* mRenderer; + RefPtr mSurface; + gfx::IntSize mSize; + wr::RecordedFrameHandle mHandle; +}; + +wr::WrExternalImage wr_renderer_lock_external_image(void* aObj, + wr::ExternalImageId aId, + uint8_t aChannelIndex) { + RendererOGL* renderer = reinterpret_cast(aObj); + RenderTextureHost* texture = renderer->GetRenderTexture(aId); + MOZ_ASSERT(texture); + if (!texture) { + gfxCriticalNoteOnce << "Failed to lock ExternalImage for extId:" + << AsUint64(aId); + return InvalidToWrExternalImage(); + } + if (auto* gl = renderer->gl()) { + return texture->Lock(aChannelIndex, gl); + } else if (auto* swgl = renderer->swgl()) { + return texture->LockSWGL(aChannelIndex, swgl, renderer->GetCompositor()); + } else { + gfxCriticalNoteOnce + << "No GL or SWGL context available to lock ExternalImage for extId:" + << AsUint64(aId); + return InvalidToWrExternalImage(); + } +} + +void wr_renderer_unlock_external_image(void* aObj, wr::ExternalImageId aId, + uint8_t aChannelIndex) { + RendererOGL* renderer = reinterpret_cast(aObj); + RenderTextureHost* texture = renderer->GetRenderTexture(aId); + MOZ_ASSERT(texture); + if (!texture) { + return; + } + if (renderer->gl()) { + texture->Unlock(); + } else if (renderer->swgl()) { + texture->UnlockSWGL(); + } +} + +RendererOGL::RendererOGL(RefPtr&& aThread, + UniquePtr aCompositor, + wr::WindowId aWindowId, wr::Renderer* aRenderer, + layers::CompositorBridgeParent* aBridge) + : mThread(aThread), + mCompositor(std::move(aCompositor)), + mRenderer(aRenderer), + mBridge(aBridge), + mWindowId(aWindowId), + mDisableNativeCompositor(false), + mLastPipelineInfo(new WebRenderPipelineInfo) { + MOZ_ASSERT(mThread); + MOZ_ASSERT(mCompositor); + MOZ_ASSERT(mRenderer); + MOZ_ASSERT(mBridge); + MOZ_COUNT_CTOR(RendererOGL); +} + +RendererOGL::~RendererOGL() { + MOZ_COUNT_DTOR(RendererOGL); + if (!mCompositor->MakeCurrent()) { + gfxCriticalNote + << "Failed to make render context current during destroying."; + // Leak resources! + } else { + wr_renderer_delete(mRenderer); + } +} + +wr::WrExternalImageHandler RendererOGL::GetExternalImageHandler() { + return wr::WrExternalImageHandler{ + this, + }; +} + +void RendererOGL::SetFramePublishId(FramePublishId aPublishId) { + wr_renderer_set_target_frame_publish_id(mRenderer, aPublishId); +} + +void RendererOGL::Update() { + mCompositor->Update(); + if (mCompositor->MakeCurrent()) { + wr_renderer_update(mRenderer); + FlushPipelineInfo(); + } +} + +static void DoWebRenderDisableNativeCompositor( + layers::CompositorBridgeParent* aBridge) { + aBridge->NotifyWebRenderDisableNativeCompositor(); +} + +RenderedFrameId RendererOGL::UpdateAndRender( + const Maybe& aReadbackSize, + const Maybe& aReadbackFormat, + const Maybe>& aReadbackBuffer, bool* aNeedsYFlip, + RendererStats* aOutStats) { + mozilla::widget::WidgetRenderingContext widgetContext; + +#if defined(XP_MACOSX) + widgetContext.mGL = mCompositor->gl(); +#endif + + if (!mCompositor->GetWidget()->PreRender(&widgetContext)) { + // XXX This could cause oom in webrender since pending_texture_updates is + // not handled. It needs to be addressed. + return RenderedFrameId(); + } + // XXX set clear color if MOZ_WIDGET_ANDROID is defined. + + if (mThread->IsHandlingDeviceReset() || !mCompositor->BeginFrame()) { + CheckGraphicsResetStatus("BeginFrame", /* aForce */ true); + mCompositor->GetWidget()->PostRender(&widgetContext); + return RenderedFrameId(); + } + + auto size = mCompositor->GetBufferSize(); + auto bufferAge = mCompositor->GetBufferAge(); + + wr_renderer_update(mRenderer); + + bool fullRender = mCompositor->RequestFullRender(); + // When we're rendering to an external target, we want to render everything. + if (mCompositor->UsePartialPresent() && + (aReadbackBuffer.isSome() || layers::ProfilerScreenshots::IsEnabled())) { + fullRender = true; + } + if (fullRender) { + wr_renderer_force_redraw(mRenderer); + } + + nsTArray dirtyRects; + bool rendered = wr_renderer_render(mRenderer, size.width, size.height, + bufferAge, aOutStats, &dirtyRects); + FlushPipelineInfo(); + if (!rendered) { + mCompositor->CancelFrame(); + RenderThread::Get()->HandleWebRenderError(WebRenderError::RENDER); + mCompositor->GetWidget()->PostRender(&widgetContext); + return RenderedFrameId(); + } + + if (aReadbackBuffer.isSome()) { + MOZ_ASSERT(aReadbackSize.isSome()); + MOZ_ASSERT(aReadbackFormat.isSome()); + if (!mCompositor->MaybeReadback(aReadbackSize.ref(), aReadbackFormat.ref(), + aReadbackBuffer.ref(), aNeedsYFlip)) { + wr_renderer_readback(mRenderer, aReadbackSize.ref().width, + aReadbackSize.ref().height, aReadbackFormat.ref(), + &aReadbackBuffer.ref()[0], + aReadbackBuffer.ref().length()); + if (aNeedsYFlip) { + *aNeedsYFlip = !mCompositor->SurfaceOriginIsTopLeft(); + } + } + } + + if (size.Width() != 0 && size.Height() != 0) { + if (!mCompositor->MaybeGrabScreenshot(size.ToUnknownSize())) { + mScreenshotGrabber.MaybeGrabScreenshot(this, size.ToUnknownSize()); + } + } + + // Frame recording must happen before EndFrame, as we must ensure we read the + // contents of the back buffer before any calls to SwapBuffers which might + // invalidate it. + MaybeRecordFrame(mLastPipelineInfo); + + RenderedFrameId frameId = mCompositor->EndFrame(dirtyRects); + + mCompositor->GetWidget()->PostRender(&widgetContext); + +#if defined(ENABLE_FRAME_LATENCY_LOG) + if (mFrameStartTime) { + uint32_t latencyMs = + round((TimeStamp::Now() - mFrameStartTime).ToMilliseconds()); + printf_stderr("generate frame latencyMs latencyMs %d\n", latencyMs); + } + // Clear frame start time + mFrameStartTime = TimeStamp(); +#endif + + if (!mCompositor->MaybeProcessScreenshotQueue()) { + mScreenshotGrabber.MaybeProcessQueue(this); + } + + // TODO: Flush pending actions such as texture deletions/unlocks and + // textureHosts recycling. + + return frameId; +} + +bool RendererOGL::EnsureAsyncScreenshot() { + if (mCompositor->SupportAsyncScreenshot()) { + return true; + } + if (!mDisableNativeCompositor) { + layers::CompositorThread()->Dispatch( + NewRunnableFunction("DoWebRenderDisableNativeCompositorRunnable", + &DoWebRenderDisableNativeCompositor, mBridge)); + + mDisableNativeCompositor = true; + gfxCriticalNote << "Disable native compositor for async screenshot"; + } + return false; +} + +void RendererOGL::CheckGraphicsResetStatus(const char* aCaller, bool aForce) { + if (mCompositor) { + auto reason = mCompositor->IsContextLost(aForce); + if (reason != LOCAL_GL_NO_ERROR) { + RenderThread::Get()->HandleDeviceReset(aCaller, reason); + } + } +} + +void RendererOGL::WaitForGPU() { + if (!mCompositor->WaitForGPU()) { + CheckGraphicsResetStatus("WaitForGPU", /* aForce */ true); + } +} + +ipc::FileDescriptor RendererOGL::GetAndResetReleaseFence() { + return mCompositor->GetAndResetReleaseFence(); +} + +RenderedFrameId RendererOGL::GetLastCompletedFrameId() { + return mCompositor->GetLastCompletedFrameId(); +} + +RenderedFrameId RendererOGL::UpdateFrameId() { + return mCompositor->UpdateFrameId(); +} + +void RendererOGL::Pause() { mCompositor->Pause(); } + +bool RendererOGL::Resume() { return mCompositor->Resume(); } + +bool RendererOGL::IsPaused() { return mCompositor->IsPaused(); } + +layers::SyncObjectHost* RendererOGL::GetSyncObject() const { + return mCompositor->GetSyncObject(); +} + +gl::GLContext* RendererOGL::gl() const { return mCompositor->gl(); } + +void* RendererOGL::swgl() const { return mCompositor->swgl(); } + +void RendererOGL::SetFrameStartTime(const TimeStamp& aTime) { + if (mFrameStartTime) { + // frame start time is already set. This could happen when multiple + // generate frame requests are merged by webrender. + return; + } + mFrameStartTime = aTime; +} + +void RendererOGL::BeginRecording(const TimeStamp& aRecordingStart, + wr::PipelineId aRootPipelineId) { + MOZ_ASSERT(!mCompositionRecorder); + + mRootPipelineId = aRootPipelineId; + mCompositionRecorder = + MakeUnique(aRecordingStart); + mCompositor->MaybeRequestAllowFrameRecording(true); +} + +void RendererOGL::MaybeRecordFrame(const WebRenderPipelineInfo* aPipelineInfo) { + if (!mCompositionRecorder || !EnsureAsyncScreenshot()) { + return; + } + + if (!mRenderer || !aPipelineInfo || !DidPaintContent(aPipelineInfo)) { + return; + } + + if (mCompositor->MaybeRecordFrame(*mCompositionRecorder)) { + return; + } + + wr::RecordedFrameHandle handle{0}; + gfx::IntSize size(0, 0); + + if (wr_renderer_record_frame(mRenderer, wr::ImageFormat::BGRA8, &handle, + &size.width, &size.height)) { + RefPtr frame = + new RendererRecordedFrame(TimeStamp::Now(), mRenderer, handle, size); + + mCompositionRecorder->RecordFrame(frame); + } +} + +bool RendererOGL::DidPaintContent(const WebRenderPipelineInfo* aFrameEpochs) { + const wr::WrPipelineInfo& info = aFrameEpochs->Raw(); + bool didPaintContent = false; + + // Check if a non-root pipeline has updated to a new epoch. + // We treat all non-root pipelines as "content" pipelines, even if they're + // not fed by content paints, such as videos (see bug 1665512). + for (const auto& epoch : info.epochs) { + const wr::PipelineId pipelineId = epoch.pipeline_id; + + if (pipelineId == mRootPipelineId) { + continue; + } + + const auto it = mContentPipelineEpochs.find(AsUint64(pipelineId)); + if (it == mContentPipelineEpochs.end() || it->second != epoch.epoch) { + // This pipeline has updated since last render or has newly rendered. + didPaintContent = true; + mContentPipelineEpochs[AsUint64(pipelineId)] = epoch.epoch; + } + } + + for (const auto& removedPipeline : info.removed_pipelines) { + const wr::PipelineId pipelineId = removedPipeline.pipeline_id; + if (pipelineId == mRootPipelineId) { + continue; + } + mContentPipelineEpochs.erase(AsUint64(pipelineId)); + } + + return didPaintContent; +} + +Maybe RendererOGL::EndRecording() { + if (!mCompositionRecorder) { + MOZ_DIAGNOSTIC_ASSERT( + false, "Attempted to get frames from a window that was not recording."); + return Nothing(); + } + + auto maybeRecording = mCompositionRecorder->GetRecording(); + + wr_renderer_release_composition_recorder_structures(mRenderer); + + mCompositor->MaybeRequestAllowFrameRecording(false); + mCompositionRecorder = nullptr; + + return maybeRecording; +} + +void RendererOGL::FlushPipelineInfo() { + RefPtr info = new WebRenderPipelineInfo; + wr_renderer_flush_pipeline_info(mRenderer, &info->Raw()); + mLastPipelineInfo = info; +} + +RenderTextureHost* RendererOGL::GetRenderTexture( + wr::ExternalImageId aExternalImageId) { + return mThread->GetRenderTexture(aExternalImageId); +} + +void RendererOGL::AccumulateMemoryReport(MemoryReport* aReport) { + wr_renderer_accumulate_memory_report(GetRenderer(), aReport, swgl()); + + LayoutDeviceIntSize size = mCompositor->GetBufferSize(); + + // Assume BGRA8 for the format since it's not exposed anywhere, + // and all compositor backends should be using that. + uintptr_t swapChainSize = size.width * size.height * + BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8) * + (mCompositor->UseTripleBuffering() ? 3 : 2); + aReport->swap_chain += swapChainSize; +} + +void RendererOGL::SetProfilerUI(const nsACString& aUI) { + wr_renderer_set_profiler_ui(GetRenderer(), (const uint8_t*)aUI.BeginReading(), + aUI.Length()); +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RendererOGL.h b/gfx/webrender_bindings/RendererOGL.h new file mode 100644 index 0000000000..bf79f70d16 --- /dev/null +++ b/gfx/webrender_bindings/RendererOGL.h @@ -0,0 +1,176 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_LAYERS_RENDEREROGL_H +#define MOZILLA_LAYERS_RENDEREROGL_H + +#include "mozilla/ipc/FileDescriptor.h" +#include "mozilla/layers/CompositorTypes.h" +#include "mozilla/gfx/Point.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/webrender/WebRenderTypes.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "mozilla/webrender/RendererScreenshotGrabber.h" + +namespace mozilla { + +namespace gfx { +class DrawTarget; +} + +namespace gl { +class GLContext; +} + +namespace layers { +class CompositorBridgeParent; +class SyncObjectHost; +} // namespace layers + +namespace widget { +class CompositorWidget; +} + +namespace wr { + +class RenderCompositor; +class RenderTextureHost; + +/// Owns the WebRender renderer and GL context. +/// +/// There is one renderer per window, all owned by the render thread. +/// This class is a similar abstraction to CompositorOGL except that it is used +/// on the render thread instead of the compositor thread. +class RendererOGL { + friend wr::WrExternalImage LockExternalImage(void* aObj, + wr::ExternalImageId aId, + uint8_t aChannelIndex, + wr::ImageRendering); + friend void UnlockExternalImage(void* aObj, wr::ExternalImageId aId, + uint8_t aChannelIndex); + + public: + wr::WrExternalImageHandler GetExternalImageHandler(); + + void SetFramePublishId(FramePublishId aPublishId); + + /// This can be called on the render thread only. + void Update(); + + /// This can be called on the render thread only. + RenderedFrameId UpdateAndRender(const Maybe& aReadbackSize, + const Maybe& aReadbackFormat, + const Maybe>& aReadbackBuffer, + bool* aNeedsYFlip, RendererStats* aOutStats); + + /// This can be called on the render thread only. + void WaitForGPU(); + + /// This can be called on the render thread only. + ipc::FileDescriptor GetAndResetReleaseFence(); + + /// This can be called on the render thread only. + RenderedFrameId GetLastCompletedFrameId(); + + /// This can be called on the render thread only. + RenderedFrameId UpdateFrameId(); + + /// This can be called on the render thread only. + void SetProfilerEnabled(bool aEnabled); + + /// This can be called on the render thread only. + void SetFrameStartTime(const TimeStamp& aTime); + + /// These can be called on the render thread only. + void BeginRecording(const TimeStamp& aRecordingStart, + wr::PipelineId aPipelineId); + void MaybeRecordFrame(const WebRenderPipelineInfo* aPipelineInfo); + + Maybe EndRecording(); + + /// This can be called on the render thread only. + ~RendererOGL(); + + /// This can be called on the render thread only. + RendererOGL(RefPtr&& aThread, + UniquePtr aCompositor, wr::WindowId aWindowId, + wr::Renderer* aRenderer, layers::CompositorBridgeParent* aBridge); + + /// This can be called on the render thread only. + void Pause(); + + /// This can be called on the render thread only. + bool Resume(); + + /// This can be called on the render thread only. + bool IsPaused(); + + /// This can be called on the render thread only. + void CheckGraphicsResetStatus(const char* aCaller, bool aForce); + + layers::SyncObjectHost* GetSyncObject() const; + + layers::CompositorBridgeParent* GetCompositorBridge() { return mBridge; } + + void FlushPipelineInfo(); + + RefPtr GetLastPipelineInfo() const { + return mLastPipelineInfo; + } + + RenderTextureHost* GetRenderTexture(wr::ExternalImageId aExternalImageId); + + RenderCompositor* GetCompositor() { return mCompositor.get(); } + + void AccumulateMemoryReport(MemoryReport* aReport); + + void SetProfilerUI(const nsACString& aUI); + + wr::Renderer* GetRenderer() { return mRenderer; } + + gl::GLContext* gl() const; + + void* swgl() const; + + bool EnsureAsyncScreenshot(); + + protected: + /** + * Determine if any content pipelines updated, and update + * mContentPipelineEpochs. + */ + bool DidPaintContent(const wr::WebRenderPipelineInfo* aFrameEpochs); + + RefPtr mThread; + UniquePtr mCompositor; + UniquePtr mCompositionRecorder; // can be null + wr::Renderer* mRenderer; + layers::CompositorBridgeParent* mBridge; + wr::WindowId mWindowId; + TimeStamp mFrameStartTime; + + bool mDisableNativeCompositor; + + RendererScreenshotGrabber mScreenshotGrabber; + + // The id of the root WebRender pipeline. + // + // All other pipelines are considered content. + wr::PipelineId mRootPipelineId; + + // A mapping of wr::PipelineId to the epochs when last they updated. + // + // We need to use uint64_t here since wr::PipelineId is not default + // constructable. + std::unordered_map mContentPipelineEpochs; + + RefPtr mLastPipelineInfo; +}; + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/RendererScreenshotGrabber.cpp b/gfx/webrender_bindings/RendererScreenshotGrabber.cpp new file mode 100644 index 0000000000..1d001d4727 --- /dev/null +++ b/gfx/webrender_bindings/RendererScreenshotGrabber.cpp @@ -0,0 +1,104 @@ +/* -*- 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 "RendererScreenshotGrabber.h" + +#include "RendererOGL.h" + +#include "mozilla/gfx/2D.h" + +using mozilla::layers::ProfilerScreenshots; + +namespace mozilla { +namespace wr { + +RendererScreenshotGrabber::RendererScreenshotGrabber() { + mMaxScreenshotSize = ProfilerScreenshots::ScreenshotSize(); +} + +void RendererScreenshotGrabber::MaybeGrabScreenshot( + RendererOGL* aRendererOGL, const gfx::IntSize& aWindowSize) { + bool isEnabled = + ProfilerScreenshots::IsEnabled() && aRendererOGL->EnsureAsyncScreenshot(); + + if (isEnabled) { + if (!mProfilerScreenshots) { + mProfilerScreenshots = new ProfilerScreenshots(); + } + + GrabScreenshot(aRendererOGL->GetRenderer(), aWindowSize); + } else if (mProfilerScreenshots) { + Destroy(aRendererOGL->GetRenderer()); + } +} + +void RendererScreenshotGrabber::MaybeProcessQueue(RendererOGL* aRendererOGL) { + bool isEnabled = + ProfilerScreenshots::IsEnabled() && aRendererOGL->EnsureAsyncScreenshot(); + + if (isEnabled) { + if (!mProfilerScreenshots) { + mProfilerScreenshots = new ProfilerScreenshots(); + } + + ProcessQueue(aRendererOGL->GetRenderer()); + } else if (mProfilerScreenshots) { + Destroy(aRendererOGL->GetRenderer()); + } +} + +void RendererScreenshotGrabber::Destroy(Renderer* aRenderer) { + mQueue.Clear(); + mCurrentFrameQueueItem = Nothing(); + mProfilerScreenshots = nullptr; + + wr_renderer_release_profiler_structures(aRenderer); +} + +void RendererScreenshotGrabber::GrabScreenshot( + Renderer* aRenderer, const gfx::IntSize& aWindowSize) { + gfx::IntSize screenshotSize; + + AsyncScreenshotHandle handle = wr_renderer_get_screenshot_async( + aRenderer, 0, 0, aWindowSize.width, aWindowSize.height, + mMaxScreenshotSize.width, mMaxScreenshotSize.height, ImageFormat::BGRA8, + &screenshotSize.width, &screenshotSize.height); + + mCurrentFrameQueueItem = Some(QueueItem{ + TimeStamp::Now(), + handle, + screenshotSize, + aWindowSize, + }); +} + +void RendererScreenshotGrabber::ProcessQueue(Renderer* aRenderer) { + for (const auto& item : mQueue) { + mProfilerScreenshots->SubmitScreenshot( + item.mWindowSize, item.mScreenshotSize, item.mTimeStamp, + [&item, aRenderer](gfx::DataSourceSurface* aTargetSurface) { + gfx::DataSourceSurface::ScopedMap map(aTargetSurface, + gfx::DataSourceSurface::WRITE); + int32_t destStride = map.GetStride(); + + bool success = wr_renderer_map_and_recycle_screenshot( + aRenderer, item.mHandle, map.GetData(), + destStride * aTargetSurface->GetSize().height, destStride); + + return success; + }); + } + + mQueue.Clear(); + + if (mCurrentFrameQueueItem) { + mQueue.AppendElement(*mCurrentFrameQueueItem); + mCurrentFrameQueueItem = Nothing(); + } +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/RendererScreenshotGrabber.h b/gfx/webrender_bindings/RendererScreenshotGrabber.h new file mode 100644 index 0000000000..81f11a392d --- /dev/null +++ b/gfx/webrender_bindings/RendererScreenshotGrabber.h @@ -0,0 +1,101 @@ +/* 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/. */ + +#ifndef mozilla_layers_RendererScreenshotGrabber_h +#define mozilla_layers_RendererScreenshotGrabber_h + +#include "mozilla/TimeStamp.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/gfx/Point.h" +#include "mozilla/layers/ProfilerScreenshots.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "nsTArray.h" + +namespace mozilla { +namespace wr { + +struct Renderer; +class RendererOGL; + +/** + * Used by |RendererOGL| to grab screenshots from WebRender and submit them to + * the Gecko profiler. + * + * If the profiler is not running or the screenshots feature is disabled, no + * work will be done. + */ +class RendererScreenshotGrabber final { + public: + RendererScreenshotGrabber(); + + /** + * Grab a screenshot from WebRender if we are profiling and screenshots are + * enabled. + * + * The captured screenshot will not be mapped until the second call to + * |MaybeProcessQueue| after this call to |MaybeGrabScreenshot|. + */ + void MaybeGrabScreenshot(RendererOGL* aRendererOGL, + const gfx::IntSize& aWindowSize); + + /** + * Process the screenshots pending in the queue if we are profiling and + * screenshots are enabled. + */ + void MaybeProcessQueue(RendererOGL* aRenderer); + + private: + /** + * Drop all our allocated memory when we are no longer profiling. + * + * This will also instruct WebRender to drop all its Gecko profiler + * associated memory. + */ + void Destroy(Renderer* aRenderer); + + /** + * Actually grab a screenshot from WebRender. + */ + void GrabScreenshot(Renderer* aRenderer, const gfx::IntSize& aWindowSize); + + /** + * Process the screenshots pending in the queue. + */ + void ProcessQueue(Renderer* aRenderer); + + struct QueueItem { + mozilla::TimeStamp mTimeStamp; + AsyncScreenshotHandle mHandle; + gfx::IntSize mScreenshotSize; + gfx::IntSize mWindowSize; + }; + + /** + * The maximum size for screenshots, as dictated by + * |ProfilerScrenshots::ScreenshotSize|. + */ + gfx::IntSize mMaxScreenshotSize; + + /** + * The queue of screenshots waiting to be processed and submitted. + */ + nsTArray mQueue; + + /** + * The queue item for the current frame. This will be inserted into the queue + * after a call to |MaybeProcessQueue| so it will be not be processed until + * the next frame. + */ + Maybe mCurrentFrameQueueItem; + + /** + * Our handle to the profiler screenshots object. + */ + RefPtr mProfilerScreenshots; +}; + +} // namespace wr +} // namespace mozilla + +#endif // mozilla_layers_RendererScreenshotGrabber_h diff --git a/gfx/webrender_bindings/WebRenderAPI.cpp b/gfx/webrender_bindings/WebRenderAPI.cpp new file mode 100644 index 0000000000..09a024a897 --- /dev/null +++ b/gfx/webrender_bindings/WebRenderAPI.cpp @@ -0,0 +1,1867 @@ +/* -*- 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 "WebRenderAPI.h" + +#include "mozilla/Logging.h" +#include "mozilla/ipc/ByteBuf.h" +#include "mozilla/webrender/RendererOGL.h" +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/layers/CompositorThread.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/StaticPrefs_webgl.h" +#include "mozilla/ToString.h" +#include "mozilla/webrender/RenderCompositor.h" +#include "mozilla/widget/CompositorWidget.h" +#include "mozilla/layers/SynchronousTask.h" +#include "nsThreadUtils.h" +#include "TextDrawTarget.h" +#include "malloc_decls.h" +#include "GLContext.h" + +static mozilla::LazyLogModule sWrDLLog("wr.dl"); +#define WRDL_LOG(...) \ + MOZ_LOG(sWrDLLog, LogLevel::Debug, ("WRDL(%p): " __VA_ARGS__)) + +namespace mozilla { +using namespace layers; + +namespace wr { + +MOZ_DEFINE_MALLOC_SIZE_OF(WebRenderMallocSizeOf) +MOZ_DEFINE_MALLOC_ENCLOSING_SIZE_OF(WebRenderMallocEnclosingSizeOf) + +class NewRenderer : public RendererEvent { + public: + NewRenderer(wr::DocumentHandle** aDocHandle, + layers::CompositorBridgeParent* aBridge, + WebRenderBackend* aBackend, WebRenderCompositor* aCompositor, + int32_t* aMaxTextureSize, bool* aUseANGLE, bool* aUseDComp, + bool* aUseTripleBuffering, bool* aSupportsExternalBufferTextures, + RefPtr&& aWidget, + layers::SynchronousTask* aTask, LayoutDeviceIntSize aSize, + layers::WindowKind aWindowKind, layers::SyncHandle* aHandle, + nsACString* aError) + : mDocHandle(aDocHandle), + mBackend(aBackend), + mCompositor(aCompositor), + mMaxTextureSize(aMaxTextureSize), + mUseANGLE(aUseANGLE), + mUseDComp(aUseDComp), + mUseTripleBuffering(aUseTripleBuffering), + mSupportsExternalBufferTextures(aSupportsExternalBufferTextures), + mBridge(aBridge), + mCompositorWidget(std::move(aWidget)), + mTask(aTask), + mSize(aSize), + mWindowKind(aWindowKind), + mSyncHandle(aHandle), + mError(aError) { + MOZ_COUNT_CTOR(NewRenderer); + } + + MOZ_COUNTED_DTOR(NewRenderer) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + layers::AutoCompleteTask complete(mTask); + + UniquePtr compositor = + RenderCompositor::Create(std::move(mCompositorWidget), *mError); + if (!compositor) { + if (!mError->IsEmpty()) { + gfxCriticalNote << mError->BeginReading(); + } + return; + } + + compositor->MakeCurrent(); + + *mBackend = compositor->BackendType(); + *mCompositor = compositor->CompositorType(); + *mUseANGLE = compositor->UseANGLE(); + *mUseDComp = compositor->UseDComp(); + *mUseTripleBuffering = compositor->UseTripleBuffering(); + *mSupportsExternalBufferTextures = + compositor->SupportsExternalBufferTextures(); + + // Only allow the panic on GL error functionality in nightly builds, + // since it (deliberately) crashes the GPU process if any GL call + // returns an error code. + bool panic_on_gl_error = false; +#ifdef NIGHTLY_BUILD + panic_on_gl_error = + StaticPrefs::gfx_webrender_panic_on_gl_error_AtStartup(); +#endif + + bool isMainWindow = true; // TODO! + bool supportLowPriorityTransactions = isMainWindow; + bool supportLowPriorityThreadpool = + supportLowPriorityTransactions && + StaticPrefs::gfx_webrender_enable_low_priority_pool(); + wr::Renderer* wrRenderer = nullptr; + char* errorMessage = nullptr; + int picTileWidth = StaticPrefs::gfx_webrender_picture_tile_width(); + int picTileHeight = StaticPrefs::gfx_webrender_picture_tile_height(); + auto* swgl = compositor->swgl(); + auto* gl = (compositor->gl() && !swgl) ? compositor->gl() : nullptr; + auto* progCache = (aRenderThread.GetProgramCache() && !swgl) + ? aRenderThread.GetProgramCache()->Raw() + : nullptr; + auto* shaders = (aRenderThread.GetShaders() && !swgl) + ? aRenderThread.GetShaders()->RawShaders() + : nullptr; + + // Check That if we are not using SWGL, we have at least a GL or GLES 3.0 + // context. + if (gl && !swgl) { + bool versionCheck = + gl->IsAtLeast(gl::ContextProfile::OpenGLCore, 300) || + gl->IsAtLeast(gl::ContextProfile::OpenGLCompatibility, 300) || + gl->IsAtLeast(gl::ContextProfile::OpenGLES, 300); + + if (!versionCheck) { + gfxCriticalNote << "GL context version (" << gl->Version() + << ") insufficent for hardware WebRender"; + + mError->AssignASCII("GL context version insufficient"); + return; + } + } + + if (!wr_window_new( + aWindowId, mSize.width, mSize.height, + mWindowKind == WindowKind::MAIN, supportLowPriorityTransactions, + supportLowPriorityThreadpool, gfx::gfxVars::UseGLSwizzle(), + gfx::gfxVars::UseWebRenderScissoredCacheClears(), swgl, gl, + compositor->SurfaceOriginIsTopLeft(), progCache, shaders, + aRenderThread.ThreadPool().Raw(), + aRenderThread.ThreadPoolLP().Raw(), &WebRenderMallocSizeOf, + &WebRenderMallocEnclosingSizeOf, 0, compositor.get(), + compositor->ShouldUseNativeCompositor(), + compositor->UsePartialPresent(), + compositor->GetMaxPartialPresentRects(), + compositor->ShouldDrawPreviousPartialPresentRegions(), mDocHandle, + &wrRenderer, mMaxTextureSize, &errorMessage, + StaticPrefs::gfx_webrender_enable_gpu_markers_AtStartup(), + panic_on_gl_error, picTileWidth, picTileHeight, + gfx::gfxVars::WebRenderRequiresHardwareDriver(), + StaticPrefs::gfx_webrender_low_quality_pinch_zoom_AtStartup(), + StaticPrefs::gfx_webrender_max_shared_surface_size_AtStartup(), + StaticPrefs::gfx_webrender_enable_subpixel_aa_AtStartup())) { + // wr_window_new puts a message into gfxCriticalNote if it returns false + MOZ_ASSERT(errorMessage); + mError->AssignASCII(errorMessage); + wr_api_free_error_msg(errorMessage); + return; + } + MOZ_ASSERT(wrRenderer); + + RefPtr thread = &aRenderThread; + auto renderer = + MakeUnique(std::move(thread), std::move(compositor), + aWindowId, wrRenderer, mBridge); + if (wrRenderer && renderer) { + wr::WrExternalImageHandler handler = renderer->GetExternalImageHandler(); + wr_renderer_set_external_image_handler(wrRenderer, &handler); + } + + if (renderer) { + layers::SyncObjectHost* syncObj = renderer->GetSyncObject(); + if (syncObj) { + *mSyncHandle = syncObj->GetSyncHandle(); + } + } + + aRenderThread.AddRenderer(aWindowId, std::move(renderer)); + } + + private: + wr::DocumentHandle** mDocHandle; + WebRenderBackend* mBackend; + WebRenderCompositor* mCompositor; + int32_t* mMaxTextureSize; + bool* mUseANGLE; + bool* mUseDComp; + bool* mUseTripleBuffering; + bool* mSupportsExternalBufferTextures; + layers::CompositorBridgeParent* mBridge; + RefPtr mCompositorWidget; + layers::SynchronousTask* mTask; + LayoutDeviceIntSize mSize; + layers::WindowKind mWindowKind; + layers::SyncHandle* mSyncHandle; + nsACString* mError; +}; + +class RemoveRenderer : public RendererEvent { + public: + explicit RemoveRenderer(layers::SynchronousTask* aTask) : mTask(aTask) { + MOZ_COUNT_CTOR(RemoveRenderer); + } + + MOZ_COUNTED_DTOR_OVERRIDE(RemoveRenderer) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + aRenderThread.RemoveRenderer(aWindowId); + layers::AutoCompleteTask complete(mTask); + } + + private: + layers::SynchronousTask* mTask; +}; + +TransactionBuilder::TransactionBuilder(WebRenderAPI* aApi, + bool aUseSceneBuilderThread) + : mUseSceneBuilderThread(aUseSceneBuilderThread), + mApiBackend(aApi->GetBackendType()), + mOwnsData(true) { + mTxn = wr_transaction_new(mUseSceneBuilderThread); +} + +TransactionBuilder::TransactionBuilder(WebRenderAPI* aApi, Transaction* aTxn, + bool aUseSceneBuilderThread, + bool aOwnsData) + : mTxn(aTxn), + mUseSceneBuilderThread(aUseSceneBuilderThread), + mApiBackend(aApi->GetBackendType()), + mOwnsData(aOwnsData) {} + +TransactionBuilder::~TransactionBuilder() { + if (mOwnsData) { + wr_transaction_delete(mTxn); + } +} + +void TransactionBuilder::SetLowPriority(bool aIsLowPriority) { + wr_transaction_set_low_priority(mTxn, aIsLowPriority); +} + +void TransactionBuilder::UpdateEpoch(PipelineId aPipelineId, Epoch aEpoch) { + wr_transaction_update_epoch(mTxn, aPipelineId, aEpoch); +} + +void TransactionBuilder::SetRootPipeline(PipelineId aPipelineId) { + wr_transaction_set_root_pipeline(mTxn, aPipelineId); +} + +void TransactionBuilder::RemovePipeline(PipelineId aPipelineId) { + wr_transaction_remove_pipeline(mTxn, aPipelineId); +} + +void TransactionBuilder::SetDisplayList( + Epoch aEpoch, wr::WrPipelineId pipeline_id, + wr::BuiltDisplayListDescriptor dl_descriptor, + wr::Vec& dl_items_data, wr::Vec& dl_cache_data, + wr::Vec& dl_spatial_tree) { + wr_transaction_set_display_list(mTxn, aEpoch, pipeline_id, dl_descriptor, + &dl_items_data.inner, &dl_cache_data.inner, + &dl_spatial_tree.inner); +} + +void TransactionBuilder::ClearDisplayList(Epoch aEpoch, + wr::WrPipelineId aPipelineId) { + wr_transaction_clear_display_list(mTxn, aEpoch, aPipelineId); +} + +void TransactionBuilder::GenerateFrame(const VsyncId& aVsyncId, + wr::RenderReasons aReasons) { + wr_transaction_generate_frame(mTxn, aVsyncId.mId, aReasons); +} + +void TransactionBuilder::InvalidateRenderedFrame(wr::RenderReasons aReasons) { + wr_transaction_invalidate_rendered_frame(mTxn, aReasons); +} + +bool TransactionBuilder::IsEmpty() const { + return wr_transaction_is_empty(mTxn); +} + +bool TransactionBuilder::IsResourceUpdatesEmpty() const { + return wr_transaction_resource_updates_is_empty(mTxn); +} + +bool TransactionBuilder::IsRenderedFrameInvalidated() const { + return wr_transaction_is_rendered_frame_invalidated(mTxn); +} + +void TransactionBuilder::SetDocumentView( + const LayoutDeviceIntRect& aDocumentRect) { + wr::DeviceIntRect wrDocRect; + wrDocRect.min.x = aDocumentRect.x; + wrDocRect.min.y = aDocumentRect.y; + wrDocRect.max.x = aDocumentRect.x + aDocumentRect.width; + wrDocRect.max.y = aDocumentRect.y + aDocumentRect.height; + wr_transaction_set_document_view(mTxn, &wrDocRect); +} + +TransactionWrapper::TransactionWrapper(Transaction* aTxn) : mTxn(aTxn) {} + +void TransactionWrapper::AppendDynamicProperties( + const nsTArray& aOpacityArray, + const nsTArray& aTransformArray, + const nsTArray& aColorArray) { + wr_transaction_append_dynamic_properties( + mTxn, aOpacityArray.IsEmpty() ? nullptr : aOpacityArray.Elements(), + aOpacityArray.Length(), + aTransformArray.IsEmpty() ? nullptr : aTransformArray.Elements(), + aTransformArray.Length(), + aColorArray.IsEmpty() ? nullptr : aColorArray.Elements(), + aColorArray.Length()); +} + +void TransactionWrapper::AppendTransformProperties( + const nsTArray& aTransformArray) { + wr_transaction_append_transform_properties( + mTxn, aTransformArray.IsEmpty() ? nullptr : aTransformArray.Elements(), + aTransformArray.Length()); +} + +void TransactionWrapper::UpdateScrollPosition( + const wr::ExternalScrollId& aScrollId, + const nsTArray& aSampledOffsets) { + wr_transaction_scroll_layer(mTxn, aScrollId, &aSampledOffsets); +} + +void TransactionWrapper::UpdateIsTransformAsyncZooming(uint64_t aAnimationId, + bool aIsZooming) { + wr_transaction_set_is_transform_async_zooming(mTxn, aAnimationId, aIsZooming); +} + +void TransactionWrapper::AddMinimapData(const wr::ExternalScrollId& aScrollId, + const MinimapData& aMinimapData) { + wr_transaction_add_minimap_data(mTxn, aScrollId, aMinimapData); +} + +/*static*/ +already_AddRefed WebRenderAPI::Create( + layers::CompositorBridgeParent* aBridge, + RefPtr&& aWidget, const wr::WrWindowId& aWindowId, + LayoutDeviceIntSize aSize, layers::WindowKind aWindowKind, + nsACString& aError) { + MOZ_ASSERT(aBridge); + MOZ_ASSERT(aWidget); + static_assert( + sizeof(size_t) == sizeof(uintptr_t), + "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; + bool useTripleBuffering = false; + bool supportsExternalBufferTextures = false; + layers::SyncHandle syncHandle = {}; + + // Dispatch a synchronous task because the DocumentHandle object needs to be + // created on the render thread. If need be we could delay waiting on this + // task until the next time we need to access the DocumentHandle object. + layers::SynchronousTask task("Create Renderer"); + auto event = MakeUnique( + &docHandle, aBridge, &backend, &compositor, &maxTextureSize, &useANGLE, + &useDComp, &useTripleBuffering, &supportsExternalBufferTextures, + std::move(aWidget), &task, aSize, aWindowKind, &syncHandle, &aError); + RenderThread::Get()->PostEvent(aWindowId, std::move(event)); + + task.Wait(); + + if (!docHandle) { + return nullptr; + } + + return RefPtr( + new WebRenderAPI(docHandle, aWindowId, backend, compositor, + maxTextureSize, useANGLE, useDComp, + useTripleBuffering, + supportsExternalBufferTextures, syncHandle)) + .forget(); +} + +already_AddRefed WebRenderAPI::Clone() { + wr::DocumentHandle* docHandle = nullptr; + wr_api_clone(mDocHandle, &docHandle); + + RefPtr renderApi = new WebRenderAPI( + docHandle, mId, mBackend, mCompositor, mMaxTextureSize, mUseANGLE, + mUseDComp, mUseTripleBuffering, mSupportsExternalBufferTextures, + mSyncHandle, this, this); + + return renderApi.forget(); +} + +wr::WrIdNamespace WebRenderAPI::GetNamespace() { + return wr_api_get_namespace(mDocHandle); +} + +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, + wr::WebRenderAPI* aRootApi, wr::WebRenderAPI* aRootDocumentApi) + : mDocHandle(aHandle), + mId(aId), + mBackend(aBackend), + mCompositor(aCompositor), + mMaxTextureSize(aMaxTextureSize), + mUseANGLE(aUseANGLE), + mUseDComp(aUseDComp), + mUseTripleBuffering(aUseTripleBuffering), + mSupportsExternalBufferTextures(aSupportsExternalBufferTextures), + mCaptureSequence(false), + mSyncHandle(aSyncHandle), + mRendererDestroyed(false), + mRootApi(aRootApi), + mRootDocumentApi(aRootDocumentApi) {} + +WebRenderAPI::~WebRenderAPI() { + if (!mRootDocumentApi) { + wr_api_delete_document(mDocHandle); + } + + if (!mRootApi) { + MOZ_RELEASE_ASSERT(mRendererDestroyed); + wr_api_shut_down(mDocHandle); + } + + wr_api_delete(mDocHandle); +} + +void WebRenderAPI::DestroyRenderer() { + MOZ_RELEASE_ASSERT(!mRootApi); + + RenderThread::Get()->SetDestroyed(GetId()); + // Call wr_api_stop_render_backend() before RemoveRenderer. + wr_api_stop_render_backend(mDocHandle); + + layers::SynchronousTask task("Destroy WebRenderAPI"); + auto event = MakeUnique(&task); + RunOnRenderThread(std::move(event)); + task.Wait(); + + mRendererDestroyed = true; +} + +wr::WebRenderAPI* WebRenderAPI::GetRootAPI() { + if (mRootApi) { + return mRootApi; + } + return this; +} + +void WebRenderAPI::UpdateDebugFlags(uint32_t aFlags) { + wr_api_set_debug_flags(mDocHandle, wr::DebugFlags{aFlags}); +} + +void WebRenderAPI::SendTransaction(TransactionBuilder& aTxn) { + if (mRootApi && mRootApi->mRendererDestroyed) { + return; + } + + if (mPendingRemoteTextureInfoList && + !mPendingRemoteTextureInfoList->mList.empty()) { + mPendingWrTransactionEvents.emplace( + WrTransactionEvent::PendingRemoteTextures( + std::move(mPendingRemoteTextureInfoList))); + } + + if (mPendingAsyncImagePipelineOps && + !mPendingAsyncImagePipelineOps->mList.empty()) { + mPendingWrTransactionEvents.emplace( + WrTransactionEvent::PendingAsyncImagePipelineOps( + std::move(mPendingAsyncImagePipelineOps), this, aTxn.Raw(), + aTxn.UseSceneBuilderThread())); + } + + if (!mPendingWrTransactionEvents.empty()) { + mPendingWrTransactionEvents.emplace(WrTransactionEvent::Transaction( + this, aTxn.Take(), aTxn.UseSceneBuilderThread())); + HandleWrTransactionEvents(RemoteTextureWaitType::AsyncWait); + } else { + wr_api_send_transaction(mDocHandle, aTxn.Raw(), + aTxn.UseSceneBuilderThread()); + } +} + +layers::RemoteTextureInfoList* WebRenderAPI::GetPendingRemoteTextureInfoList() { + if (!mRootApi) { + // root api does not support async wait RemoteTexture. + return nullptr; + } + + if (!mPendingRemoteTextureInfoList) { + mPendingRemoteTextureInfoList = MakeUnique(); + } + return mPendingRemoteTextureInfoList.get(); +} + +layers::AsyncImagePipelineOps* WebRenderAPI::GetPendingAsyncImagePipelineOps( + TransactionBuilder& aTxn) { + if (!mRootApi) { + // root api does not support async wait RemoteTexture. + return nullptr; + } + + if (!mPendingAsyncImagePipelineOps || + mPendingAsyncImagePipelineOps->mTransaction != aTxn.Raw()) { + if (mPendingAsyncImagePipelineOps && + !mPendingAsyncImagePipelineOps->mList.empty()) { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + gfxCriticalNoteOnce << "Invalid AsyncImagePipelineOps"; + } + mPendingAsyncImagePipelineOps = + MakeUnique(aTxn.Raw()); + } else { + MOZ_RELEASE_ASSERT(mPendingAsyncImagePipelineOps->mTransaction == + aTxn.Raw()); + } + + return mPendingAsyncImagePipelineOps.get(); +} + +bool WebRenderAPI::CheckIsRemoteTextureReady( + layers::RemoteTextureInfoList* aList, const TimeStamp& aTimeStamp) { + MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread()); + MOZ_ASSERT(aList); + + RefPtr self = this; + auto callback = [self](const layers::RemoteTextureInfo&) { + RefPtr runnable = NewRunnableMethod( + "WebRenderAPI::HandleWrTransactionEvents", self, + &WebRenderAPI::HandleWrTransactionEvents, + RemoteTextureWaitType::AsyncWait); + layers::CompositorThread()->Dispatch(runnable.forget()); + }; + + const auto maxWaitDurationMs = 10000; + const auto now = TimeStamp::Now(); + const auto waitDurationMs = + static_cast((now - aTimeStamp).ToMilliseconds()); + + const auto isTimeout = waitDurationMs > maxWaitDurationMs; + if (isTimeout) { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + gfxCriticalNote << "RemoteTexture ready timeout"; + } + + bool isReady = true; + while (!aList->mList.empty() && isReady) { + auto& front = aList->mList.front(); + isReady &= layers::RemoteTextureMap::Get()->CheckRemoteTextureReady( + front, callback); + if (isTimeout) { + isReady = true; + } + if (isReady) { + aList->mList.pop(); + } + } + + return isReady; +} + +void WebRenderAPI::WaitRemoteTextureReady( + layers::RemoteTextureInfoList* aList) { + MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread()); + MOZ_ASSERT(aList); + + while (!aList->mList.empty()) { + auto& front = aList->mList.front(); + layers::RemoteTextureMap::Get()->WaitRemoteTextureReady(front); + aList->mList.pop(); + } +} + +void WebRenderAPI::FlushPendingWrTransactionEventsWithoutWait() { + HandleWrTransactionEvents(RemoteTextureWaitType::FlushWithoutWait); +} + +void WebRenderAPI::FlushPendingWrTransactionEventsWithWait() { + HandleWrTransactionEvents(RemoteTextureWaitType::FlushWithWait); +} + +void WebRenderAPI::HandleWrTransactionEvents(RemoteTextureWaitType aType) { + auto& events = mPendingWrTransactionEvents; + + while (!events.empty()) { + auto& front = events.front(); + switch (front.mTag) { + case WrTransactionEvent::Tag::Transaction: + wr_api_send_transaction(mDocHandle, front.RawTransaction(), + front.UseSceneBuilderThread()); + break; + case WrTransactionEvent::Tag::PendingRemoteTextures: { + bool isReady = true; + if (aType == RemoteTextureWaitType::AsyncWait) { + isReady = CheckIsRemoteTextureReady(front.RemoteTextureInfoList(), + front.mTimeStamp); + } else if (aType == RemoteTextureWaitType::FlushWithWait) { + WaitRemoteTextureReady(front.RemoteTextureInfoList()); + } else { + MOZ_ASSERT(aType == RemoteTextureWaitType::FlushWithoutWait); + auto* list = front.RemoteTextureInfoList(); + while (!list->mList.empty()) { + auto& front = list->mList.front(); + layers::RemoteTextureMap::Get()->SuppressRemoteTextureReadyCheck( + front.mTextureId, front.mForPid); + list->mList.pop(); + } + } + if (!isReady && (aType != RemoteTextureWaitType::FlushWithoutWait)) { + return; + } + break; + } + case WrTransactionEvent::Tag::PendingAsyncImagePipelineOps: { + auto* list = front.AsyncImagePipelineOps(); + TransactionBuilder& txn = *front.GetTransactionBuilder(); + + list->HandleOps(txn); + break; + } + } + events.pop(); + } +} + +std::vector WebRenderAPI::HitTest(const wr::WorldPoint& aPoint) { + static_assert(gfx::DoesCompositorHitTestInfoFitIntoBits<12>(), + "CompositorHitTestFlags MAX value has to be less than number " + "of bits in uint16_t minus 4 for SideBitsPacked"); + + nsTArray wrResults; + wr_api_hit_test(mDocHandle, aPoint, &wrResults); + + std::vector geckoResults; + for (wr::HitResult wrResult : wrResults) { + WrHitResult geckoResult; + geckoResult.mLayersId = wr::AsLayersId(wrResult.pipeline_id); + geckoResult.mScrollId = + static_cast(wrResult.scroll_id); + geckoResult.mHitInfo.deserialize(wrResult.hit_info & 0x0fff); + geckoResult.mSideBits = static_cast(wrResult.hit_info >> 12); + + if (wrResult.animation_id != 0) { + geckoResult.mAnimationId = Some(wrResult.animation_id); + } else { + geckoResult.mAnimationId = Nothing(); + } + geckoResults.push_back(geckoResult); + } + return geckoResults; +} + +void WebRenderAPI::Readback(const TimeStamp& aStartTime, gfx::IntSize size, + const gfx::SurfaceFormat& aFormat, + const Range& buffer, bool* aNeedsYFlip) { + class Readback : public RendererEvent { + public: + explicit Readback(layers::SynchronousTask* aTask, TimeStamp aStartTime, + gfx::IntSize aSize, const gfx::SurfaceFormat& aFormat, + const Range& aBuffer, bool* aNeedsYFlip) + : mTask(aTask), + mStartTime(aStartTime), + mSize(aSize), + mFormat(aFormat), + mBuffer(aBuffer), + mNeedsYFlip(aNeedsYFlip) { + MOZ_COUNT_CTOR(Readback); + } + + MOZ_COUNTED_DTOR_OVERRIDE(Readback) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + aRenderThread.UpdateAndRender(aWindowId, VsyncId(), mStartTime, + /* aRender */ true, Some(mSize), + wr::SurfaceFormatToImageFormat(mFormat), + Some(mBuffer), mNeedsYFlip); + layers::AutoCompleteTask complete(mTask); + } + + layers::SynchronousTask* mTask; + TimeStamp mStartTime; + gfx::IntSize mSize; + gfx::SurfaceFormat mFormat; + const Range& mBuffer; + bool* mNeedsYFlip; + }; + + // Disable debug flags during readback. See bug 1436020. + UpdateDebugFlags(0); + + layers::SynchronousTask task("Readback"); + auto event = MakeUnique(&task, aStartTime, size, aFormat, buffer, + aNeedsYFlip); + // This event will be passed from wr_backend thread to renderer thread. That + // implies that all frame data have been processed when the renderer runs this + // read-back event. Then, we could make sure this read-back event gets the + // latest result. + RunOnRenderThread(std::move(event)); + + task.Wait(); + + UpdateDebugFlags(gfx::gfxVars::WebRenderDebugFlags()); +} + +void WebRenderAPI::ClearAllCaches() { wr_api_clear_all_caches(mDocHandle); } + +void WebRenderAPI::EnableNativeCompositor(bool aEnable) { + wr_api_enable_native_compositor(mDocHandle, aEnable); +} + +void WebRenderAPI::SetBatchingLookback(uint32_t aCount) { + wr_api_set_batching_lookback(mDocHandle, aCount); +} + +void WebRenderAPI::SetBool(wr::BoolParameter aKey, bool aValue) { + wr_api_set_bool(mDocHandle, aKey, aValue); +} + +void WebRenderAPI::SetInt(wr::IntParameter aKey, int32_t aValue) { + wr_api_set_int(mDocHandle, aKey, aValue); +} + +void WebRenderAPI::SetClearColor(const gfx::DeviceColor& aColor) { + RenderThread::Get()->SetClearColor(mId, ToColorF(aColor)); +} + +void WebRenderAPI::SetProfilerUI(const nsACString& aUIString) { + RenderThread::Get()->SetProfilerUI(mId, aUIString); +} + +void WebRenderAPI::Pause() { + class PauseEvent : public RendererEvent { + public: + explicit PauseEvent(layers::SynchronousTask* aTask) : mTask(aTask) { + MOZ_COUNT_CTOR(PauseEvent); + } + + MOZ_COUNTED_DTOR_OVERRIDE(PauseEvent) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + aRenderThread.Pause(aWindowId); + layers::AutoCompleteTask complete(mTask); + } + + layers::SynchronousTask* mTask; + }; + + layers::SynchronousTask task("Pause"); + auto event = MakeUnique(&task); + // This event will be passed from wr_backend thread to renderer thread. That + // implies that all frame data have been processed when the renderer runs this + // event. + RunOnRenderThread(std::move(event)); + + task.Wait(); +} + +bool WebRenderAPI::Resume() { + class ResumeEvent : public RendererEvent { + public: + explicit ResumeEvent(layers::SynchronousTask* aTask, bool* aResult) + : mTask(aTask), mResult(aResult) { + MOZ_COUNT_CTOR(ResumeEvent); + } + + MOZ_COUNTED_DTOR_OVERRIDE(ResumeEvent) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + *mResult = aRenderThread.Resume(aWindowId); + layers::AutoCompleteTask complete(mTask); + } + + layers::SynchronousTask* mTask; + bool* mResult; + }; + + bool result = false; + layers::SynchronousTask task("Resume"); + auto event = MakeUnique(&task, &result); + // This event will be passed from wr_backend thread to renderer thread. That + // implies that all frame data have been processed when the renderer runs this + // event. + RunOnRenderThread(std::move(event)); + + task.Wait(); + return result; +} + +void WebRenderAPI::NotifyMemoryPressure() { + wr_api_notify_memory_pressure(mDocHandle); +} + +void WebRenderAPI::AccumulateMemoryReport(MemoryReport* aReport) { + wr_api_accumulate_memory_report(mDocHandle, aReport, &WebRenderMallocSizeOf, + &WebRenderMallocEnclosingSizeOf); +} + +void WebRenderAPI::WakeSceneBuilder() { wr_api_wake_scene_builder(mDocHandle); } + +void WebRenderAPI::FlushSceneBuilder() { + wr_api_flush_scene_builder(mDocHandle); +} + +void WebRenderAPI::WaitFlushed() { + class WaitFlushedEvent : public RendererEvent { + public: + explicit WaitFlushedEvent(layers::SynchronousTask* aTask) : mTask(aTask) { + MOZ_COUNT_CTOR(WaitFlushedEvent); + } + + MOZ_COUNTED_DTOR_OVERRIDE(WaitFlushedEvent) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + layers::AutoCompleteTask complete(mTask); + } + + layers::SynchronousTask* mTask; + }; + + layers::SynchronousTask task("WaitFlushed"); + auto event = MakeUnique(&task); + // This event will be passed from wr_backend thread to renderer thread. That + // implies that all frame data have been processed when the renderer runs this + // event. + RunOnRenderThread(std::move(event)); + + task.Wait(); +} + +void WebRenderAPI::Capture() { + // see CaptureBits + // SCENE | FRAME | TILE_CACHE + uint8_t bits = 15; // TODO: get from JavaScript + const char* path = "wr-capture"; // TODO: get from JavaScript + wr_api_capture(mDocHandle, path, bits); +} + +void WebRenderAPI::StartCaptureSequence(const nsACString& aPath, + uint32_t aFlags) { + if (mCaptureSequence) { + wr_api_stop_capture_sequence(mDocHandle); + } + + wr_api_start_capture_sequence(mDocHandle, PromiseFlatCString(aPath).get(), + aFlags); + + mCaptureSequence = true; +} + +void WebRenderAPI::StopCaptureSequence() { + if (mCaptureSequence) { + wr_api_stop_capture_sequence(mDocHandle); + } + + mCaptureSequence = false; +} + +void WebRenderAPI::BeginRecording(const TimeStamp& aRecordingStart, + wr::PipelineId aRootPipelineId) { + class BeginRecordingEvent final : public RendererEvent { + public: + explicit BeginRecordingEvent(const TimeStamp& aRecordingStart, + wr::PipelineId aRootPipelineId) + : mRecordingStart(aRecordingStart), mRootPipelineId(aRootPipelineId) { + MOZ_COUNT_CTOR(BeginRecordingEvent); + } + + ~BeginRecordingEvent() { MOZ_COUNT_DTOR(BeginRecordingEvent); } + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + aRenderThread.BeginRecordingForWindow(aWindowId, mRecordingStart, + mRootPipelineId); + } + + private: + TimeStamp mRecordingStart; + wr::PipelineId mRootPipelineId; + }; + + auto event = + MakeUnique(aRecordingStart, aRootPipelineId); + RunOnRenderThread(std::move(event)); +} + +RefPtr WebRenderAPI::EndRecording() { + class EndRecordingEvent final : public RendererEvent { + public: + explicit EndRecordingEvent() { MOZ_COUNT_CTOR(EndRecordingEvent); } + + MOZ_COUNTED_DTOR(EndRecordingEvent); + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + Maybe recording = + aRenderThread.EndRecordingForWindow(aWindowId); + + if (recording) { + mPromise.Resolve(recording.extract(), __func__); + } else { + mPromise.Reject(NS_ERROR_UNEXPECTED, __func__); + } + } + + RefPtr GetPromise() { + return mPromise.Ensure(__func__); + } + + private: + MozPromiseHolder mPromise; + }; + + auto event = MakeUnique(); + auto promise = event->GetPromise(); + + RunOnRenderThread(std::move(event)); + return promise; +} + +void TransactionBuilder::Clear() { wr_resource_updates_clear(mTxn); } + +Transaction* TransactionBuilder::Take() { + if (!mOwnsData) { + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return nullptr; + } + Transaction* txn = mTxn; + mTxn = wr_transaction_new(mUseSceneBuilderThread); + return txn; +} + +void TransactionBuilder::Notify(wr::Checkpoint aWhen, + UniquePtr aEvent) { + wr_transaction_notify(mTxn, aWhen, + reinterpret_cast(aEvent.release())); +} + +void TransactionBuilder::AddImage(ImageKey key, + const ImageDescriptor& aDescriptor, + wr::Vec& aBytes) { + wr_resource_updates_add_image(mTxn, key, &aDescriptor, &aBytes.inner); +} + +void TransactionBuilder::AddBlobImage(BlobImageKey key, + const ImageDescriptor& aDescriptor, + uint16_t aTileSize, + wr::Vec& aBytes, + const wr::DeviceIntRect& aVisibleRect) { + wr_resource_updates_add_blob_image(mTxn, key, &aDescriptor, aTileSize, + &aBytes.inner, aVisibleRect); +} + +void TransactionBuilder::AddExternalImage(ImageKey key, + const ImageDescriptor& aDescriptor, + ExternalImageId aExtID, + wr::ExternalImageType aImageType, + uint8_t aChannelIndex) { + wr_resource_updates_add_external_image(mTxn, key, &aDescriptor, aExtID, + &aImageType, aChannelIndex); +} + +void TransactionBuilder::AddExternalImageBuffer( + ImageKey aKey, const ImageDescriptor& aDescriptor, + ExternalImageId aHandle) { + auto channelIndex = 0; + AddExternalImage(aKey, aDescriptor, aHandle, wr::ExternalImageType::Buffer(), + channelIndex); +} + +void TransactionBuilder::UpdateImageBuffer(ImageKey aKey, + const ImageDescriptor& aDescriptor, + wr::Vec& aBytes) { + wr_resource_updates_update_image(mTxn, aKey, &aDescriptor, &aBytes.inner); +} + +void TransactionBuilder::UpdateBlobImage(BlobImageKey aKey, + const ImageDescriptor& aDescriptor, + wr::Vec& aBytes, + const wr::DeviceIntRect& aVisibleRect, + const wr::LayoutIntRect& aDirtyRect) { + wr_resource_updates_update_blob_image(mTxn, aKey, &aDescriptor, &aBytes.inner, + aVisibleRect, aDirtyRect); +} + +void TransactionBuilder::UpdateExternalImage(ImageKey aKey, + const ImageDescriptor& aDescriptor, + ExternalImageId aExtID, + wr::ExternalImageType aImageType, + uint8_t aChannelIndex) { + wr_resource_updates_update_external_image(mTxn, aKey, &aDescriptor, aExtID, + &aImageType, aChannelIndex); +} + +void TransactionBuilder::UpdateExternalImageWithDirtyRect( + ImageKey aKey, const ImageDescriptor& aDescriptor, ExternalImageId aExtID, + wr::ExternalImageType aImageType, const wr::DeviceIntRect& aDirtyRect, + uint8_t aChannelIndex) { + wr_resource_updates_update_external_image_with_dirty_rect( + mTxn, aKey, &aDescriptor, aExtID, &aImageType, aChannelIndex, aDirtyRect); +} + +void TransactionBuilder::SetBlobImageVisibleArea( + BlobImageKey aKey, const wr::DeviceIntRect& aArea) { + wr_resource_updates_set_blob_image_visible_area(mTxn, aKey, &aArea); +} + +void TransactionBuilder::DeleteImage(ImageKey aKey) { + wr_resource_updates_delete_image(mTxn, aKey); +} + +void TransactionBuilder::DeleteBlobImage(BlobImageKey aKey) { + wr_resource_updates_delete_blob_image(mTxn, aKey); +} + +void TransactionBuilder::AddRawFont(wr::FontKey aKey, wr::Vec& aBytes, + uint32_t aIndex) { + wr_resource_updates_add_raw_font(mTxn, aKey, &aBytes.inner, aIndex); +} + +void TransactionBuilder::AddFontDescriptor(wr::FontKey aKey, + wr::Vec& aBytes, + uint32_t aIndex) { + wr_resource_updates_add_font_descriptor(mTxn, aKey, &aBytes.inner, aIndex); +} + +void TransactionBuilder::DeleteFont(wr::FontKey aKey) { + wr_resource_updates_delete_font(mTxn, aKey); +} + +void TransactionBuilder::AddFontInstance( + wr::FontInstanceKey aKey, wr::FontKey aFontKey, float aGlyphSize, + const wr::FontInstanceOptions* aOptions, + const wr::FontInstancePlatformOptions* aPlatformOptions, + wr::Vec& aVariations) { + wr_resource_updates_add_font_instance(mTxn, aKey, aFontKey, aGlyphSize, + aOptions, aPlatformOptions, + &aVariations.inner); +} + +void TransactionBuilder::DeleteFontInstance(wr::FontInstanceKey aKey) { + wr_resource_updates_delete_font_instance(mTxn, aKey); +} + +void TransactionBuilder::UpdateQualitySettings( + bool aForceSubpixelAAWherePossible) { + wr_transaction_set_quality_settings(mTxn, aForceSubpixelAAWherePossible); +} + +class FrameStartTime : public RendererEvent { + public: + explicit FrameStartTime(const TimeStamp& aTime) : mTime(aTime) { + MOZ_COUNT_CTOR(FrameStartTime); + } + + MOZ_COUNTED_DTOR_OVERRIDE(FrameStartTime) + + void Run(RenderThread& aRenderThread, WindowId aWindowId) override { + auto renderer = aRenderThread.GetRenderer(aWindowId); + if (renderer) { + renderer->SetFrameStartTime(mTime); + } + } + + private: + TimeStamp mTime; +}; + +void WebRenderAPI::SetFrameStartTime(const TimeStamp& aTime) { + auto event = MakeUnique(aTime); + RunOnRenderThread(std::move(event)); +} + +void WebRenderAPI::RunOnRenderThread(UniquePtr aEvent) { + auto event = reinterpret_cast(aEvent.release()); + wr_api_send_external_event(mDocHandle, event); +} + +DisplayListBuilder::DisplayListBuilder(PipelineId aId, + WebRenderBackend aBackend) + : mCurrentSpaceAndClipChain(wr::RootScrollNodeWithChain()), + mActiveFixedPosTracker(nullptr), + mPipelineId(aId), + mBackend(aBackend), + mDisplayItemCache(nullptr) { + MOZ_COUNT_CTOR(DisplayListBuilder); + mWrState = wr_state_new(aId); + + if (mDisplayItemCache && mDisplayItemCache->IsEnabled()) { + mDisplayItemCache->SetPipelineId(aId); + } +} + +DisplayListBuilder::~DisplayListBuilder() { + MOZ_COUNT_DTOR(DisplayListBuilder); + wr_state_delete(mWrState); +} + +void DisplayListBuilder::Save() { wr_dp_save(mWrState); } +void DisplayListBuilder::Restore() { wr_dp_restore(mWrState); } +void DisplayListBuilder::ClearSave() { wr_dp_clear_save(mWrState); } + +usize DisplayListBuilder::Dump(usize aIndent, const Maybe& aStart, + const Maybe& aEnd) { + return wr_dump_display_list(mWrState, aIndent, aStart.ptrOr(nullptr), + aEnd.ptrOr(nullptr)); +} + +void DisplayListBuilder::DumpSerializedDisplayList() { + wr_dump_serialized_display_list(mWrState); +} + +void DisplayListBuilder::Begin(layers::DisplayItemCache* aCache) { + wr_api_begin_builder(mWrState); + + mScrollIds.clear(); + mCurrentSpaceAndClipChain = wr::RootScrollNodeWithChain(); + mClipChainLeaf = Nothing(); + mSuspendedSpaceAndClipChain = Nothing(); + mSuspendedClipChainLeaf = Nothing(); + mCachedTextDT = nullptr; + mCachedContext = nullptr; + mActiveFixedPosTracker = nullptr; + mDisplayItemCache = aCache; + mCurrentCacheSlot = Nothing(); +} + +void DisplayListBuilder::End(BuiltDisplayList& aOutDisplayList) { + wr_api_end_builder( + mWrState, &aOutDisplayList.dl_desc, &aOutDisplayList.dl_items.inner, + &aOutDisplayList.dl_cache.inner, &aOutDisplayList.dl_spatial_tree.inner); + + mDisplayItemCache = nullptr; +} + +void DisplayListBuilder::End(layers::DisplayListData& aOutTransaction) { + if (mDisplayItemCache && mDisplayItemCache->IsEnabled()) { + wr_dp_set_cache_size(mWrState, mDisplayItemCache->CurrentSize()); + } + + wr::VecU8 dlItems, dlCache, dlSpatialTree; + wr_api_end_builder(mWrState, &aOutTransaction.mDLDesc, &dlItems.inner, + &dlCache.inner, &dlSpatialTree.inner); + aOutTransaction.mDLItems.emplace(dlItems.inner.data, dlItems.inner.length, + dlItems.inner.capacity); + aOutTransaction.mDLCache.emplace(dlCache.inner.data, dlCache.inner.length, + dlCache.inner.capacity); + aOutTransaction.mDLSpatialTree.emplace(dlSpatialTree.inner.data, + dlSpatialTree.inner.length, + dlSpatialTree.inner.capacity); + dlItems.inner.capacity = 0; + dlItems.inner.data = nullptr; + dlCache.inner.capacity = 0; + dlCache.inner.data = nullptr; + dlSpatialTree.inner.capacity = 0; + dlSpatialTree.inner.data = nullptr; +} + +Maybe DisplayListBuilder::PushStackingContext( + const wr::StackingContextParams& aParams, const wr::LayoutRect& aBounds, + const wr::RasterSpace& aRasterSpace) { + MOZ_ASSERT(mClipChainLeaf.isNothing(), + "Non-empty leaf from clip chain given, but not used with SC!"); + + WRDL_LOG( + "PushStackingContext b=%s t=%s id=0x%" PRIx64 "\n", mWrState, + ToString(aBounds).c_str(), + aParams.mTransformPtr ? ToString(*aParams.mTransformPtr).c_str() : "none", + aParams.animation ? aParams.animation->id : 0); + + auto spatialId = wr_dp_push_stacking_context( + mWrState, aBounds, mCurrentSpaceAndClipChain.space, &aParams, + aParams.mTransformPtr, aParams.mFilters.Elements(), + aParams.mFilters.Length(), aParams.mFilterDatas.Elements(), + aParams.mFilterDatas.Length(), aRasterSpace); + + return spatialId.id != 0 ? Some(spatialId) : Nothing(); +} + +void DisplayListBuilder::PopStackingContext(bool aIsReferenceFrame) { + WRDL_LOG("PopStackingContext\n", mWrState); + wr_dp_pop_stacking_context(mWrState, aIsReferenceFrame); +} + +wr::WrClipChainId DisplayListBuilder::DefineClipChain( + const nsTArray& aClips, bool aParentWithCurrentChain) { + CancelGroup(); + + const uint64_t* parent = nullptr; + if (aParentWithCurrentChain && + mCurrentSpaceAndClipChain.clip_chain != wr::ROOT_CLIP_CHAIN) { + parent = &mCurrentSpaceAndClipChain.clip_chain; + } + uint64_t clipchainId = wr_dp_define_clipchain( + mWrState, parent, aClips.Elements(), aClips.Length()); + if (MOZ_LOG_TEST(sWrDLLog, LogLevel::Debug)) { + nsCString message; + message.AppendPrintf("DefineClipChain id=%" PRIu64 + " clipCount=%zu clipIds=[", + clipchainId, aClips.Length()); + for (const auto& clip : aClips) { + message.AppendPrintf("%" PRIuPTR ",", clip.id); + } + message.Append("]"); + WRDL_LOG("%s", mWrState, message.get()); + } + return wr::WrClipChainId{clipchainId}; +} + +wr::WrClipId DisplayListBuilder::DefineImageMaskClip( + const wr::ImageMask& aMask, const nsTArray& aPoints, + wr::FillRule aFillRule) { + CancelGroup(); + + WrClipId clipId = wr_dp_define_image_mask_clip_with_parent_clip_chain( + mWrState, mCurrentSpaceAndClipChain.space, aMask, aPoints.Elements(), + aPoints.Length(), aFillRule); + + return clipId; +} + +wr::WrClipId DisplayListBuilder::DefineRoundedRectClip( + Maybe aSpace, const wr::ComplexClipRegion& aComplex) { + CancelGroup(); + + WrClipId clipId; + if (aSpace) { + clipId = wr_dp_define_rounded_rect_clip(mWrState, *aSpace, aComplex); + } else { + clipId = wr_dp_define_rounded_rect_clip( + mWrState, mCurrentSpaceAndClipChain.space, aComplex); + } + + return clipId; +} + +wr::WrClipId DisplayListBuilder::DefineRectClip(Maybe aSpace, + wr::LayoutRect aClipRect) { + CancelGroup(); + + WrClipId clipId; + if (aSpace) { + clipId = wr_dp_define_rect_clip(mWrState, *aSpace, aClipRect); + } else { + clipId = wr_dp_define_rect_clip(mWrState, mCurrentSpaceAndClipChain.space, + aClipRect); + } + + return clipId; +} + +wr::WrSpatialId DisplayListBuilder::DefineStickyFrame( + const wr::LayoutRect& aContentRect, const float* aTopMargin, + const float* aRightMargin, const float* aBottomMargin, + const float* aLeftMargin, const StickyOffsetBounds& aVerticalBounds, + const StickyOffsetBounds& aHorizontalBounds, + const wr::LayoutVector2D& aAppliedOffset, wr::SpatialTreeItemKey aKey) { + auto spatialId = wr_dp_define_sticky_frame( + mWrState, mCurrentSpaceAndClipChain.space, aContentRect, aTopMargin, + aRightMargin, aBottomMargin, aLeftMargin, aVerticalBounds, + aHorizontalBounds, aAppliedOffset, aKey); + + WRDL_LOG("DefineSticky id=%zu c=%s t=%s r=%s b=%s l=%s v=%s h=%s a=%s\n", + mWrState, spatialId.id, ToString(aContentRect).c_str(), + aTopMargin ? ToString(*aTopMargin).c_str() : "none", + aRightMargin ? ToString(*aRightMargin).c_str() : "none", + aBottomMargin ? ToString(*aBottomMargin).c_str() : "none", + aLeftMargin ? ToString(*aLeftMargin).c_str() : "none", + ToString(aVerticalBounds).c_str(), + ToString(aHorizontalBounds).c_str(), + ToString(aAppliedOffset).c_str()); + + return spatialId; +} + +Maybe DisplayListBuilder::GetScrollIdForDefinedScrollLayer( + layers::ScrollableLayerGuid::ViewID aViewId) const { + if (aViewId == layers::ScrollableLayerGuid::NULL_SCROLL_ID) { + return Some(wr::RootScrollNode()); + } + + auto it = mScrollIds.find(aViewId); + if (it == mScrollIds.end()) { + return Nothing(); + } + + return Some(it->second); +} + +wr::WrSpatialId DisplayListBuilder::DefineScrollLayer( + const layers::ScrollableLayerGuid::ViewID& aViewId, + const Maybe& aParent, const wr::LayoutRect& aContentRect, + const wr::LayoutRect& aClipRect, const wr::LayoutVector2D& aScrollOffset, + wr::APZScrollGeneration aScrollOffsetGeneration, + wr::HasScrollLinkedEffect aHasScrollLinkedEffect, + wr::SpatialTreeItemKey aKey) { + auto it = mScrollIds.find(aViewId); + if (it != mScrollIds.end()) { + return it->second; + } + + // We haven't defined aViewId before, so let's define it now. + wr::WrSpatialId defaultParent = mCurrentSpaceAndClipChain.space; + + auto space = wr_dp_define_scroll_layer( + mWrState, aViewId, aParent ? aParent.ptr() : &defaultParent, aContentRect, + aClipRect, aScrollOffset, aScrollOffsetGeneration, aHasScrollLinkedEffect, + aKey); + + WRDL_LOG("DefineScrollLayer id=%" PRIu64 + "/%zu p=%s co=%s cl=%s generation=%s hasScrollLinkedEffect=%s\n", + mWrState, aViewId, space.id, + aParent ? ToString(aParent->id).c_str() : "(nil)", + ToString(aContentRect).c_str(), ToString(aClipRect).c_str(), + ToString(aScrollOffsetGeneration).c_str(), + ToString(aHasScrollLinkedEffect).c_str()); + + mScrollIds[aViewId] = space; + return space; +} + +void DisplayListBuilder::PushRect(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + bool aForceAntiAliasing, bool aIsCheckerboard, + const wr::ColorF& aColor) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + WRDL_LOG("PushRect b=%s cl=%s c=%s\n", mWrState, ToString(aBounds).c_str(), + ToString(clip).c_str(), ToString(aColor).c_str()); + wr_dp_push_rect(mWrState, aBounds, clip, aIsBackfaceVisible, + aForceAntiAliasing, aIsCheckerboard, + &mCurrentSpaceAndClipChain, aColor); +} + +void DisplayListBuilder::PushRoundedRect(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const wr::ColorF& aColor) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + WRDL_LOG("PushRoundedRect b=%s cl=%s c=%s\n", mWrState, + ToString(aBounds).c_str(), ToString(clip).c_str(), + ToString(aColor).c_str()); + + // Draw the rounded rectangle as a border with rounded corners. We could also + // draw this as a rectangle clipped to a rounded rectangle, but: + // - clips are not cached; borders are + // - a simple border like this will be drawn as an image + // - Processing lots of clips is not WebRender's strong point. + // + // Made the borders thicker than one half the width/height, to avoid + // little white dots at the center at some magnifications. + wr::BorderSide side = {aColor, wr::BorderStyle::Solid}; + float h = aBounds.width() * 0.6f; + float v = aBounds.height() * 0.6f; + wr::LayoutSideOffsets widths = {v, h, v, h}; + wr::BorderRadius radii = {{h, v}, {h, v}, {h, v}, {h, v}}; + + // Anti-aliased borders are required for rounded borders. + wr_dp_push_border(mWrState, aBounds, clip, aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, wr::AntialiasBorder::Yes, + widths, side, side, side, side, radii); +} + +void DisplayListBuilder::PushHitTest( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const layers::ScrollableLayerGuid::ViewID& aScrollId, + const gfx::CompositorHitTestInfo& aHitInfo, SideBits aSideBits) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + WRDL_LOG("PushHitTest b=%s cl=%s\n", mWrState, ToString(aBounds).c_str(), + ToString(clip).c_str()); + + static_assert(gfx::DoesCompositorHitTestInfoFitIntoBits<12>(), + "CompositorHitTestFlags MAX value has to be less than number " + "of bits in uint16_t minus 4 for SideBitsPacked"); + + uint16_t hitInfoBits = static_cast(aHitInfo.serialize()) | + (static_cast(aSideBits) << 12); + + wr_dp_push_hit_test(mWrState, aBounds, clip, aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aScrollId, hitInfoBits); +} + +void DisplayListBuilder::PushRectWithAnimation( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::ColorF& aColor, + const WrAnimationProperty* aAnimation) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + WRDL_LOG("PushRectWithAnimation b=%s cl=%s c=%s\n", mWrState, + ToString(aBounds).c_str(), ToString(clip).c_str(), + ToString(aColor).c_str()); + + wr_dp_push_rect_with_animation(mWrState, aBounds, clip, aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aColor, + aAnimation); +} + +void DisplayListBuilder::PushClearRect(const wr::LayoutRect& aBounds) { + wr::LayoutRect clip = MergeClipLeaf(aBounds); + WRDL_LOG("PushClearRect b=%s c=%s\n", mWrState, ToString(aBounds).c_str(), + ToString(clip).c_str()); + wr_dp_push_clear_rect(mWrState, aBounds, clip, &mCurrentSpaceAndClipChain); +} + +void DisplayListBuilder::PushBackdropFilter( + const wr::LayoutRect& aBounds, const wr::ComplexClipRegion& aRegion, + const nsTArray& aFilters, + const nsTArray& aFilterDatas, bool aIsBackfaceVisible) { + wr::LayoutRect clip = MergeClipLeaf(aBounds); + WRDL_LOG("PushBackdropFilter b=%s c=%s\n", mWrState, + ToString(aBounds).c_str(), ToString(clip).c_str()); + + auto clipId = DefineRoundedRectClip(Nothing(), aRegion); + auto clipChainId = DefineClipChain({clipId}, true); + auto spaceAndClip = + WrSpaceAndClipChain{mCurrentSpaceAndClipChain.space, clipChainId.id}; + + wr_dp_push_backdrop_filter(mWrState, aBounds, clip, aIsBackfaceVisible, + &spaceAndClip, aFilters.Elements(), + aFilters.Length(), aFilterDatas.Elements(), + aFilterDatas.Length()); +} + +void DisplayListBuilder::PushLinearGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutPoint& aStartPoint, + const wr::LayoutPoint& aEndPoint, const nsTArray& aStops, + wr::ExtendMode aExtendMode, const wr::LayoutSize aTileSize, + const wr::LayoutSize aTileSpacing) { + wr_dp_push_linear_gradient( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aStartPoint, aEndPoint, aStops.Elements(), + aStops.Length(), aExtendMode, aTileSize, aTileSpacing); +} + +void DisplayListBuilder::PushRadialGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutPoint& aCenter, + const wr::LayoutSize& aRadius, const nsTArray& aStops, + wr::ExtendMode aExtendMode, const wr::LayoutSize aTileSize, + const wr::LayoutSize aTileSpacing) { + wr_dp_push_radial_gradient( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aCenter, aRadius, aStops.Elements(), + aStops.Length(), aExtendMode, aTileSize, aTileSpacing); +} + +void DisplayListBuilder::PushConicGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutPoint& aCenter, const float aAngle, + const nsTArray& aStops, wr::ExtendMode aExtendMode, + const wr::LayoutSize aTileSize, const wr::LayoutSize aTileSpacing) { + wr_dp_push_conic_gradient(mWrState, aBounds, MergeClipLeaf(aClip), + aIsBackfaceVisible, &mCurrentSpaceAndClipChain, + aCenter, aAngle, aStops.Elements(), aStops.Length(), + aExtendMode, aTileSize, aTileSpacing); +} + +void DisplayListBuilder::PushImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, bool aForceAntiAliasing, + wr::ImageRendering aFilter, wr::ImageKey aImage, bool aPremultipliedAlpha, + const wr::ColorF& aColor, bool aPreferCompositorSurface, + bool aSupportsExternalCompositing) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + WRDL_LOG("PushImage b=%s cl=%s\n", mWrState, ToString(aBounds).c_str(), + ToString(clip).c_str()); + wr_dp_push_image(mWrState, aBounds, clip, aIsBackfaceVisible, + aForceAntiAliasing, &mCurrentSpaceAndClipChain, aFilter, + aImage, aPremultipliedAlpha, aColor, + aPreferCompositorSurface, aSupportsExternalCompositing); +} + +void DisplayListBuilder::PushRepeatingImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSize& aStretchSize, + const wr::LayoutSize& aTileSpacing, wr::ImageRendering aFilter, + wr::ImageKey aImage, bool aPremultipliedAlpha, const wr::ColorF& aColor) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + WRDL_LOG("PushImage b=%s cl=%s s=%s t=%s\n", mWrState, + ToString(aBounds).c_str(), ToString(clip).c_str(), + ToString(aStretchSize).c_str(), ToString(aTileSpacing).c_str()); + wr_dp_push_repeating_image( + mWrState, aBounds, clip, aIsBackfaceVisible, &mCurrentSpaceAndClipChain, + aStretchSize, aTileSpacing, aFilter, aImage, aPremultipliedAlpha, aColor); +} + +void DisplayListBuilder::PushYCbCrPlanarImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::ImageKey aImageChannel1, wr::ImageKey aImageChannel2, + wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace, + wr::WrColorRange aColorRange, wr::ImageRendering aRendering, + bool aPreferCompositorSurface, bool aSupportsExternalCompositing) { + wr_dp_push_yuv_planar_image( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aImageChannel0, aImageChannel1, + aImageChannel2, aColorDepth, aColorSpace, aColorRange, aRendering, + aPreferCompositorSurface, aSupportsExternalCompositing); +} + +void DisplayListBuilder::PushNV12Image( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth, + wr::WrYuvColorSpace aColorSpace, wr::WrColorRange aColorRange, + wr::ImageRendering aRendering, bool aPreferCompositorSurface, + bool aSupportsExternalCompositing) { + wr_dp_push_yuv_NV12_image( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aImageChannel0, aImageChannel1, aColorDepth, + aColorSpace, aColorRange, aRendering, aPreferCompositorSurface, + aSupportsExternalCompositing); +} + +void DisplayListBuilder::PushP010Image( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth, + wr::WrYuvColorSpace aColorSpace, wr::WrColorRange aColorRange, + wr::ImageRendering aRendering, bool aPreferCompositorSurface, + bool aSupportsExternalCompositing) { + wr_dp_push_yuv_P010_image( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aImageChannel0, aImageChannel1, aColorDepth, + aColorSpace, aColorRange, aRendering, aPreferCompositorSurface, + aSupportsExternalCompositing); +} + +void DisplayListBuilder::PushYCbCrInterleavedImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace, + wr::WrColorRange aColorRange, wr::ImageRendering aRendering, + bool aPreferCompositorSurface, bool aSupportsExternalCompositing) { + wr_dp_push_yuv_interleaved_image( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aImageChannel0, aColorDepth, aColorSpace, + aColorRange, aRendering, aPreferCompositorSurface, + aSupportsExternalCompositing); +} + +void DisplayListBuilder::PushIFrame(const LayoutDeviceRect& aDevPxBounds, + bool aIsBackfaceVisible, + PipelineId aPipeline, + bool aIgnoreMissingPipeline) { + // If the incoming bounds size has decimals (As it could when zoom is + // involved), and is pushed straight through here, the compositor would end up + // calculating the destination rect to paint the rendered iframe into + // with those decimal values, rounding the result, instead of snapping. This + // can cause the rendered iframe rect and its destination rect to be + // mismatched, resulting in interpolation artifacts. + auto snapped = aDevPxBounds; + auto tl = snapped.TopLeft().Round(); + auto br = snapped.BottomRight().Round(); + + snapped.SizeTo(LayoutDeviceSize(br.x - tl.x, br.y - tl.y)); + + const auto bounds = wr::ToLayoutRect(snapped); + wr_dp_push_iframe(mWrState, bounds, MergeClipLeaf(bounds), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aPipeline, + aIgnoreMissingPipeline); +} + +void DisplayListBuilder::PushBorder(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const wr::LayoutSideOffsets& aWidths, + const Range& aSides, + const wr::BorderRadius& aRadius, + wr::AntialiasBorder aAntialias) { + MOZ_ASSERT(aSides.length() == 4); + if (aSides.length() != 4) { + return; + } + wr_dp_push_border(mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aAntialias, aWidths, aSides[0], + aSides[1], aSides[2], aSides[3], aRadius); +} + +void DisplayListBuilder::PushBorderImage(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const wr::WrBorderImage& aParams) { + wr_dp_push_border_image(mWrState, aBounds, MergeClipLeaf(aClip), + aIsBackfaceVisible, &mCurrentSpaceAndClipChain, + &aParams); +} + +void DisplayListBuilder::PushBorderGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, + const int32_t aWidth, const int32_t aHeight, bool aFill, + const wr::DeviceIntSideOffsets& aSlice, const wr::LayoutPoint& aStartPoint, + const wr::LayoutPoint& aEndPoint, const nsTArray& aStops, + wr::ExtendMode aExtendMode) { + wr_dp_push_border_gradient( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aWidths, aWidth, aHeight, aFill, aSlice, + aStartPoint, aEndPoint, aStops.Elements(), aStops.Length(), aExtendMode); +} + +void DisplayListBuilder::PushBorderRadialGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill, + const wr::LayoutPoint& aCenter, const wr::LayoutSize& aRadius, + const nsTArray& aStops, wr::ExtendMode aExtendMode) { + wr_dp_push_border_radial_gradient( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aWidths, aFill, aCenter, aRadius, + aStops.Elements(), aStops.Length(), aExtendMode); +} + +void DisplayListBuilder::PushBorderConicGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill, + const wr::LayoutPoint& aCenter, const float aAngle, + const nsTArray& aStops, wr::ExtendMode aExtendMode) { + wr_dp_push_border_conic_gradient( + mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aWidths, aFill, aCenter, aAngle, + aStops.Elements(), aStops.Length(), aExtendMode); +} + +void DisplayListBuilder::PushText(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const wr::ColorF& aColor, + wr::FontInstanceKey aFontKey, + Range aGlyphBuffer, + const wr::GlyphOptions* aGlyphOptions) { + wr_dp_push_text(mWrState, aBounds, MergeClipLeaf(aClip), aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aColor, aFontKey, + &aGlyphBuffer[0], aGlyphBuffer.length(), aGlyphOptions); +} + +void DisplayListBuilder::PushLine(const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const wr::Line& aLine) { + wr::LayoutRect clip = MergeClipLeaf(aClip); + wr_dp_push_line(mWrState, &clip, aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, &aLine.bounds, + aLine.wavyLineThickness, aLine.orientation, &aLine.color, + aLine.style); +} + +void DisplayListBuilder::PushShadow(const wr::LayoutRect& aRect, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const wr::Shadow& aShadow, + bool aShouldInflate) { + // Local clip_rects are translated inside of shadows, as they are assumed to + // be part of the element drawing itself, and not a parent frame clipping it. + // As such, it is not sound to apply the MergeClipLeaf optimization inside of + // shadows. So we disable the optimization when we encounter a shadow. + // Shadows don't span frames, so we don't have to worry about MergeClipLeaf + // being re-enabled mid-shadow. The optimization is restored in PopAllShadows. + SuspendClipLeafMerging(); + wr_dp_push_shadow(mWrState, aRect, aClip, aIsBackfaceVisible, + &mCurrentSpaceAndClipChain, aShadow, aShouldInflate); +} + +void DisplayListBuilder::PopAllShadows() { + wr_dp_pop_all_shadows(mWrState); + ResumeClipLeafMerging(); +} + +void DisplayListBuilder::SuspendClipLeafMerging() { + if (mClipChainLeaf) { + // No one should reinitialize mClipChainLeaf while we're suspended + MOZ_ASSERT(!mSuspendedClipChainLeaf); + + mSuspendedClipChainLeaf = mClipChainLeaf; + mSuspendedSpaceAndClipChain = Some(mCurrentSpaceAndClipChain); + + auto clipId = DefineRectClip(Nothing(), *mClipChainLeaf); + auto clipChainId = DefineClipChain({clipId}, true); + + mCurrentSpaceAndClipChain.clip_chain = clipChainId.id; + mClipChainLeaf = Nothing(); + } +} + +void DisplayListBuilder::ResumeClipLeafMerging() { + if (mSuspendedClipChainLeaf) { + mCurrentSpaceAndClipChain = *mSuspendedSpaceAndClipChain; + mClipChainLeaf = mSuspendedClipChainLeaf; + + mSuspendedClipChainLeaf = Nothing(); + mSuspendedSpaceAndClipChain = Nothing(); + } +} + +void DisplayListBuilder::PushBoxShadow( + const wr::LayoutRect& aRect, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutRect& aBoxBounds, + const wr::LayoutVector2D& aOffset, const wr::ColorF& aColor, + const float& aBlurRadius, const float& aSpreadRadius, + const wr::BorderRadius& aBorderRadius, + const wr::BoxShadowClipMode& aClipMode) { + wr_dp_push_box_shadow(mWrState, aRect, MergeClipLeaf(aClip), + aIsBackfaceVisible, &mCurrentSpaceAndClipChain, + aBoxBounds, aOffset, aColor, aBlurRadius, aSpreadRadius, + aBorderRadius, aClipMode); +} + +void DisplayListBuilder::StartGroup(nsPaintedDisplayItem* aItem) { + if (!mDisplayItemCache || mDisplayItemCache->IsFull()) { + return; + } + + MOZ_ASSERT(!mCurrentCacheSlot); + mCurrentCacheSlot = mDisplayItemCache->AssignSlot(aItem); + + if (mCurrentCacheSlot) { + wr_dp_start_item_group(mWrState); + } +} + +void DisplayListBuilder::CancelGroup(const bool aDiscard) { + if (!mDisplayItemCache || !mCurrentCacheSlot) { + return; + } + + wr_dp_cancel_item_group(mWrState, aDiscard); + mCurrentCacheSlot = Nothing(); +} + +void DisplayListBuilder::FinishGroup() { + if (!mDisplayItemCache || !mCurrentCacheSlot) { + return; + } + + MOZ_ASSERT(mCurrentCacheSlot); + + if (wr_dp_finish_item_group(mWrState, mCurrentCacheSlot.ref())) { + mDisplayItemCache->MarkSlotOccupied(mCurrentCacheSlot.ref(), + CurrentSpaceAndClipChain()); + mDisplayItemCache->Stats().AddCached(); + } + + mCurrentCacheSlot = Nothing(); +} + +bool DisplayListBuilder::ReuseItem(nsPaintedDisplayItem* aItem) { + if (!mDisplayItemCache) { + return false; + } + + mDisplayItemCache->Stats().AddTotal(); + + if (mDisplayItemCache->IsEmpty()) { + return false; + } + + Maybe slot = + mDisplayItemCache->CanReuseItem(aItem, CurrentSpaceAndClipChain()); + + if (slot) { + mDisplayItemCache->Stats().AddReused(); + wr_dp_push_reuse_items(mWrState, slot.ref()); + return true; + } + + return false; +} + +Maybe +DisplayListBuilder::GetContainingFixedPosScrollTarget( + const ActiveScrolledRoot* aAsr) { + return mActiveFixedPosTracker + ? mActiveFixedPosTracker->GetScrollTargetForASR(aAsr) + : Nothing(); +} + +Maybe DisplayListBuilder::GetContainingFixedPosSideBits( + const ActiveScrolledRoot* aAsr) { + return mActiveFixedPosTracker + ? mActiveFixedPosTracker->GetSideBitsForASR(aAsr) + : Nothing(); +} + +DisplayListBuilder::FixedPosScrollTargetTracker::FixedPosScrollTargetTracker( + DisplayListBuilder& aBuilder, const ActiveScrolledRoot* aAsr, + layers::ScrollableLayerGuid::ViewID aScrollId, SideBits aSideBits) + : mParentTracker(aBuilder.mActiveFixedPosTracker), + mBuilder(aBuilder), + mAsr(aAsr), + mScrollId(aScrollId), + mSideBits(aSideBits) { + aBuilder.mActiveFixedPosTracker = this; +} + +DisplayListBuilder::FixedPosScrollTargetTracker:: + ~FixedPosScrollTargetTracker() { + mBuilder.mActiveFixedPosTracker = mParentTracker; +} + +Maybe +DisplayListBuilder::FixedPosScrollTargetTracker::GetScrollTargetForASR( + const ActiveScrolledRoot* aAsr) { + return aAsr == mAsr ? Some(mScrollId) : Nothing(); +} + +Maybe +DisplayListBuilder::FixedPosScrollTargetTracker::GetSideBitsForASR( + const ActiveScrolledRoot* aAsr) { + return aAsr == mAsr ? Some(mSideBits) : Nothing(); +} + +gfxContext* DisplayListBuilder::GetTextContext( + wr::IpcResourceUpdateQueue& aResources, + const layers::StackingContextHelper& aSc, + layers::RenderRootStateManager* aManager, nsDisplayItem* aItem, + nsRect& aBounds, const gfx::Point& aDeviceOffset) { + if (!mCachedTextDT) { + mCachedTextDT = new layout::TextDrawTarget(*this, aResources, aSc, aManager, + aItem, aBounds); + if (mCachedTextDT->IsValid()) { + mCachedContext = MakeUnique(mCachedTextDT, aDeviceOffset); + } + } else { + mCachedTextDT->Reinitialize(aResources, aSc, aManager, aItem, aBounds); + mCachedContext->SetDeviceOffset(aDeviceOffset); + mCachedContext->SetMatrix(gfx::Matrix()); + } + + return mCachedContext.get(); +} + +void DisplayListBuilder::PushInheritedClipChain( + nsDisplayListBuilder* aBuilder, const DisplayItemClipChain* aClipChain) { + if (!aClipChain || mInheritedClipChain == aClipChain) { + return; + } + if (!mInheritedClipChain) { + mInheritedClipChain = aClipChain; + return; + } + + mInheritedClipChain = + aBuilder->CreateClipChainIntersection(mInheritedClipChain, aClipChain); +} + +} // namespace wr +} // namespace mozilla + +extern "C" { + +void wr_transaction_notification_notified(uintptr_t aHandler, + mozilla::wr::Checkpoint aWhen) { + auto handler = reinterpret_cast(aHandler); + handler->Notify(aWhen); + // TODO: it would be better to get a callback when the object is destroyed on + // the rust side and delete then. + delete handler; +} + +void wr_register_thread_local_arena() { +#ifdef MOZ_MEMORY + jemalloc_thread_local_arena(true); +#endif +} + +} // extern C diff --git a/gfx/webrender_bindings/WebRenderAPI.h b/gfx/webrender_bindings/WebRenderAPI.h new file mode 100644 index 0000000000..16a9acc0ab --- /dev/null +++ b/gfx/webrender_bindings/WebRenderAPI.h @@ -0,0 +1,958 @@ +/* -*- 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/. */ + +#ifndef MOZILLA_LAYERS_WEBRENDERAPI_H +#define MOZILLA_LAYERS_WEBRENDERAPI_H + +#include +#include +#include +#include +#include + +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/gfx/CompositorHitTestInfo.h" +#include "mozilla/layers/AsyncImagePipelineOp.h" +#include "mozilla/layers/IpcResourceUpdateQueue.h" +#include "mozilla/layers/RemoteTextureMap.h" +#include "mozilla/layers/ScrollableLayerGuid.h" +#include "mozilla/layers/SyncObject.h" +#include "mozilla/layers/CompositionRecorder.h" +#include "mozilla/MozPromise.h" +#include "mozilla/Range.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/VsyncDispatcher.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "mozilla/webrender/WebRenderTypes.h" +#include "nsString.h" +#include "GLTypes.h" +#include "Units.h" + +class gfxContext; + +#undef None + +namespace mozilla { + +class nsDisplayItem; +class nsPaintedDisplayItem; +class nsDisplayTransform; +class nsDisplayListBuilder; +struct DisplayItemClipChain; + +struct ActiveScrolledRoot; + +namespace widget { +class CompositorWidget; +} + +namespace layers { +class CompositorBridgeParent; +class DisplayItemCache; +class WebRenderBridgeParent; +class RenderRootStateManager; +class StackingContextHelper; +struct DisplayListData; +} // namespace layers + +namespace layout { +class TextDrawTarget; +} + +namespace wr { + +class DisplayListBuilder; +class RendererOGL; +class RendererEvent; +class WebRenderAPI; + +// This isn't part of WR's API, but we define it here to simplify layout's +// logic and data plumbing. +struct Line { + wr::LayoutRect bounds; + float wavyLineThickness; + wr::LineOrientation orientation; + wr::ColorF color; + wr::LineStyle style; +}; + +/// A handler that can be bundled into a transaction and notified at specific +/// points in the rendering pipeline, such as after scene building or after +/// frame building. +/// +/// If for any reason the handler is dropped before reaching the requested +/// point, it is notified with the value Checkpoint::TransactionDropped. +/// So it is safe to assume that the handler will be notified "at some point". +class NotificationHandler { + public: + virtual void Notify(wr::Checkpoint aCheckpoint) = 0; + virtual ~NotificationHandler() = default; +}; + +struct WrHitResult { + layers::LayersId mLayersId; + layers::ScrollableLayerGuid::ViewID mScrollId; + gfx::CompositorHitTestInfo mHitInfo; + SideBits mSideBits; + Maybe mAnimationId; +}; + +class TransactionBuilder final { + public: + explicit TransactionBuilder(WebRenderAPI* aApi, + bool aUseSceneBuilderThread = true); + + TransactionBuilder(WebRenderAPI* aApi, Transaction* aTxn, + bool aUseSceneBuilderThread, bool aOwnsData); + + ~TransactionBuilder(); + + void SetLowPriority(bool aIsLowPriority); + + void UpdateEpoch(PipelineId aPipelineId, Epoch aEpoch); + + void SetRootPipeline(PipelineId aPipelineId); + + void RemovePipeline(PipelineId aPipelineId); + + void SetDisplayList(Epoch aEpoch, wr::WrPipelineId pipeline_id, + wr::BuiltDisplayListDescriptor dl_descriptor, + wr::Vec& dl_items_data, + wr::Vec& dl_cache_data, + wr::Vec& dl_spatial_tree); + + void ClearDisplayList(Epoch aEpoch, wr::WrPipelineId aPipeline); + + void GenerateFrame(const VsyncId& aVsyncId, wr::RenderReasons aReasons); + + void InvalidateRenderedFrame(wr::RenderReasons aReasons); + + void SetDocumentView(const LayoutDeviceIntRect& aDocRect); + + bool IsEmpty() const; + + bool IsResourceUpdatesEmpty() const; + + bool IsRenderedFrameInvalidated() const; + + void AddImage(wr::ImageKey aKey, const ImageDescriptor& aDescriptor, + wr::Vec& aBytes); + + void AddBlobImage(wr::BlobImageKey aKey, const ImageDescriptor& aDescriptor, + uint16_t aTileSize, wr::Vec& aBytes, + const wr::DeviceIntRect& aVisibleRect); + + void AddExternalImageBuffer(ImageKey key, const ImageDescriptor& aDescriptor, + ExternalImageId aHandle); + + void AddExternalImage(ImageKey key, const ImageDescriptor& aDescriptor, + ExternalImageId aExtID, + wr::ExternalImageType aImageType, + uint8_t aChannelIndex = 0); + + void UpdateImageBuffer(wr::ImageKey aKey, const ImageDescriptor& aDescriptor, + wr::Vec& aBytes); + + void UpdateBlobImage(wr::BlobImageKey aKey, + const ImageDescriptor& aDescriptor, + wr::Vec& aBytes, + const wr::DeviceIntRect& aVisibleRect, + const wr::LayoutIntRect& aDirtyRect); + + void UpdateExternalImage(ImageKey aKey, const ImageDescriptor& aDescriptor, + ExternalImageId aExtID, + wr::ExternalImageType aImageType, + uint8_t aChannelIndex = 0); + + void UpdateExternalImageWithDirtyRect(ImageKey aKey, + const ImageDescriptor& aDescriptor, + ExternalImageId aExtID, + wr::ExternalImageType aImageType, + const wr::DeviceIntRect& aDirtyRect, + uint8_t aChannelIndex = 0); + + void SetBlobImageVisibleArea(BlobImageKey aKey, + const wr::DeviceIntRect& aArea); + + void DeleteImage(wr::ImageKey aKey); + + void DeleteBlobImage(wr::BlobImageKey aKey); + + void AddRawFont(wr::FontKey aKey, wr::Vec& aBytes, uint32_t aIndex); + + void AddFontDescriptor(wr::FontKey aKey, wr::Vec& aBytes, + uint32_t aIndex); + + void DeleteFont(wr::FontKey aKey); + + void AddFontInstance(wr::FontInstanceKey aKey, wr::FontKey aFontKey, + float aGlyphSize, + const wr::FontInstanceOptions* aOptions, + const wr::FontInstancePlatformOptions* aPlatformOptions, + wr::Vec& aVariations); + + void DeleteFontInstance(wr::FontInstanceKey aKey); + + void UpdateQualitySettings(bool aForceSubpixelAAWherePossible); + + void Notify(wr::Checkpoint aWhen, UniquePtr aHandler); + + void Clear(); + + Transaction* Take(); + + bool UseSceneBuilderThread() const { return mUseSceneBuilderThread; } + layers::WebRenderBackend GetBackendType() { return mApiBackend; } + Transaction* Raw() { return mTxn; } + + protected: + Transaction* mTxn; + bool mUseSceneBuilderThread; + layers::WebRenderBackend mApiBackend; + bool mOwnsData; +}; + +class TransactionWrapper final { + public: + explicit TransactionWrapper(Transaction* aTxn); + + void AppendDynamicProperties( + const nsTArray& aOpacityArray, + const nsTArray& aTransformArray, + const nsTArray& aColorArray); + void AppendTransformProperties( + const nsTArray& aTransformArray); + void UpdateScrollPosition( + const wr::ExternalScrollId& aScrollId, + const nsTArray& aSampledOffsets); + void UpdateIsTransformAsyncZooming(uint64_t aAnimationId, bool aIsZooming); + void AddMinimapData(const wr::ExternalScrollId& aScrollId, + const MinimapData& aMinimapData); + + private: + Transaction* mTxn; +}; + +class WebRenderAPI final { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderAPI); + + public: + /// This can be called on the compositor thread only. + static already_AddRefed Create( + layers::CompositorBridgeParent* aBridge, + RefPtr&& aWidget, + const wr::WrWindowId& aWindowId, LayoutDeviceIntSize aSize, + layers::WindowKind aWindowKind, nsACString& aError); + + already_AddRefed Clone(); + + void DestroyRenderer(); + + wr::WindowId GetId() const { return mId; } + + /// Do a non-blocking hit-testing query on a shared version of the hit + /// testing information. + std::vector HitTest(const wr::WorldPoint& aPoint); + + void SendTransaction(TransactionBuilder& aTxn); + + void SetFrameStartTime(const TimeStamp& aTime); + + void RunOnRenderThread(UniquePtr aEvent); + + void Readback(const TimeStamp& aStartTime, gfx::IntSize aSize, + const gfx::SurfaceFormat& aFormat, + const Range& aBuffer, bool* aNeedsYFlip); + + void ClearAllCaches(); + void EnableNativeCompositor(bool aEnable); + void SetBatchingLookback(uint32_t aCount); + void SetBool(wr::BoolParameter, bool value); + void SetInt(wr::IntParameter, int32_t value); + + void SetClearColor(const gfx::DeviceColor& aColor); + void SetProfilerUI(const nsACString& aUIString); + + void Pause(); + bool Resume(); + + void WakeSceneBuilder(); + void FlushSceneBuilder(); + + void NotifyMemoryPressure(); + 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; } + bool GetUseTripleBuffering() const { return mUseTripleBuffering; } + bool SupportsExternalBufferTextures() const { + return mSupportsExternalBufferTextures; + } + layers::SyncHandle GetSyncHandle() const { return mSyncHandle; } + + void Capture(); + + void StartCaptureSequence(const nsACString& aPath, uint32_t aFlags); + void StopCaptureSequence(); + + void BeginRecording(const TimeStamp& aRecordingStart, + wr::PipelineId aRootPipelineId); + + typedef MozPromise + EndRecordingPromise; + + RefPtr EndRecording(); + + layers::RemoteTextureInfoList* GetPendingRemoteTextureInfoList(); + layers::AsyncImagePipelineOps* GetPendingAsyncImagePipelineOps( + TransactionBuilder& aTxn); + + void FlushPendingWrTransactionEventsWithoutWait(); + void FlushPendingWrTransactionEventsWithWait(); + + wr::WebRenderAPI* GetRootAPI(); + + 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, + wr::WebRenderAPI* aRootApi = nullptr, + wr::WebRenderAPI* aRootDocumentApi = nullptr); + + ~WebRenderAPI(); + // Should be used only for shutdown handling + void WaitFlushed(); + + void UpdateDebugFlags(uint32_t aFlags); + bool CheckIsRemoteTextureReady(layers::RemoteTextureInfoList* aList, + const TimeStamp& aTimeStamp); + void WaitRemoteTextureReady(layers::RemoteTextureInfoList* aList); + + enum class RemoteTextureWaitType : uint8_t { + AsyncWait = 0, + FlushWithWait = 1, + FlushWithoutWait = 2 + }; + + void HandleWrTransactionEvents(RemoteTextureWaitType aType); + + class WrTransactionEvent { + public: + enum class Tag { + Transaction, + PendingRemoteTextures, + PendingAsyncImagePipelineOps, + }; + const Tag mTag; + const TimeStamp mTimeStamp; + + private: + WrTransactionEvent(const Tag aTag, + UniquePtr&& aTransaction) + : mTag(aTag), + mTimeStamp(TimeStamp::Now()), + mTransaction(std::move(aTransaction)) { + MOZ_ASSERT(mTag == Tag::Transaction); + } + WrTransactionEvent( + const Tag aTag, + UniquePtr&& aPendingRemoteTextures) + : mTag(aTag), + mTimeStamp(TimeStamp::Now()), + mPendingRemoteTextures(std::move(aPendingRemoteTextures)) { + MOZ_ASSERT(mTag == Tag::PendingRemoteTextures); + } + WrTransactionEvent(const Tag aTag, + UniquePtr&& + aPendingAsyncImagePipelineOps, + UniquePtr&& aTransaction) + : mTag(aTag), + mTimeStamp(TimeStamp::Now()), + mPendingAsyncImagePipelineOps( + std::move(aPendingAsyncImagePipelineOps)), + mTransaction(std::move(aTransaction)) { + MOZ_ASSERT(mTag == Tag::PendingAsyncImagePipelineOps); + } + + UniquePtr mPendingRemoteTextures; + UniquePtr mPendingAsyncImagePipelineOps; + UniquePtr mTransaction; + + public: + static WrTransactionEvent Transaction(WebRenderAPI* aApi, + wr::Transaction* aTxn, + bool aUseSceneBuilderThread) { + auto transaction = MakeUnique( + aApi, aTxn, aUseSceneBuilderThread, /* aOwnsData */ true); + return WrTransactionEvent(Tag::Transaction, std::move(transaction)); + } + + static WrTransactionEvent PendingRemoteTextures( + UniquePtr&& aPendingRemoteTextures) { + return WrTransactionEvent(Tag::PendingRemoteTextures, + std::move(aPendingRemoteTextures)); + } + + static WrTransactionEvent PendingAsyncImagePipelineOps( + UniquePtr&& + aPendingAsyncImagePipelineOps, + WebRenderAPI* aApi, wr::Transaction* aTxn, + bool aUseSceneBuilderThread) { + auto transaction = MakeUnique( + aApi, aTxn, aUseSceneBuilderThread, /* aOwnsData */ false); + return WrTransactionEvent(Tag::PendingAsyncImagePipelineOps, + std::move(aPendingAsyncImagePipelineOps), + std::move(transaction)); + } + + wr::Transaction* RawTransaction() { + if (mTag == Tag::Transaction) { + return mTransaction->Raw(); + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return nullptr; + } + + TransactionBuilder* GetTransactionBuilder() { + if (mTag == Tag::PendingAsyncImagePipelineOps) { + return mTransaction.get(); + } + MOZ_CRASH("Should not be called"); + return nullptr; + } + + bool UseSceneBuilderThread() { + if (mTag == Tag::Transaction) { + return mTransaction->UseSceneBuilderThread(); + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return true; + } + + layers::RemoteTextureInfoList* RemoteTextureInfoList() { + if (mTag == Tag::PendingRemoteTextures) { + MOZ_ASSERT(mPendingRemoteTextures); + return mPendingRemoteTextures.get(); + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return nullptr; + } + + layers::AsyncImagePipelineOps* AsyncImagePipelineOps() { + if (mTag == Tag::PendingAsyncImagePipelineOps) { + MOZ_ASSERT(mPendingAsyncImagePipelineOps); + return mPendingAsyncImagePipelineOps.get(); + } + MOZ_ASSERT_UNREACHABLE("unexpected to be called"); + return nullptr; + } + }; + + wr::DocumentHandle* mDocHandle; + wr::WindowId mId; + layers::WebRenderBackend mBackend; + layers::WebRenderCompositor mCompositor; + int32_t mMaxTextureSize; + bool mUseANGLE; + bool mUseDComp; + bool mUseTripleBuffering; + bool mSupportsExternalBufferTextures; + bool mCaptureSequence; + layers::SyncHandle mSyncHandle; + bool mRendererDestroyed; + + UniquePtr mPendingRemoteTextureInfoList; + UniquePtr mPendingAsyncImagePipelineOps; + std::queue mPendingWrTransactionEvents; + + // We maintain alive the root api to know when to shut the render backend + // down, and the root api for the document to know when to delete the + // document. mRootApi is null for the api object that owns the channel (and is + // responsible for shutting it down), and mRootDocumentApi is null for the api + // object owning (and responsible for destroying) a given document. All api + // objects in the same window use the same channel, and some api objects write + // to the same document (but there is only one owner for each channel and for + // each document). + const RefPtr mRootApi; + const RefPtr mRootDocumentApi; + + friend class DisplayListBuilder; + friend class layers::WebRenderBridgeParent; +}; + +// This is a RAII class that automatically sends the transaction on +// destruction. This is useful for code that has multiple exit points and we +// want to ensure that the stuff accumulated in the transaction gets sent +// regardless of which exit we take. Note that if the caller explicitly calls +// mApi->SendTransaction() that's fine too because that empties out the +// TransactionBuilder and leaves it as a valid empty transaction, so calling +// SendTransaction on it again ends up being a no-op. +class MOZ_RAII AutoTransactionSender { + public: + AutoTransactionSender(WebRenderAPI* aApi, TransactionBuilder* aTxn) + : mApi(aApi), mTxn(aTxn) { + MOZ_RELEASE_ASSERT(mApi); + MOZ_RELEASE_ASSERT(aTxn); + } + + ~AutoTransactionSender() { mApi->SendTransaction(*mTxn); } + + private: + WebRenderAPI* mApi; + TransactionBuilder* mTxn; +}; + +/** + * A set of optional parameters for stacking context creation. + */ +struct MOZ_STACK_CLASS StackingContextParams : public WrStackingContextParams { + StackingContextParams() + : WrStackingContextParams{ + WrStackingContextClip::None(), + nullptr, + nullptr, + nullptr, + wr::TransformStyle::Flat, + wr::WrReferenceFrameKind::Transform, + false, + false, + false, + nullptr, + /* prim_flags = */ wr::PrimitiveFlags::IS_BACKFACE_VISIBLE, + wr::MixBlendMode::Normal, + wr::StackingContextFlags{0}} {} + + void SetPreserve3D(bool aPreserve) { + transform_style = + aPreserve ? wr::TransformStyle::Preserve3D : wr::TransformStyle::Flat; + } + + // Fill this in only if this is for the root StackingContextHelper. + nsIFrame* mRootReferenceFrame = nullptr; + nsTArray mFilters; + nsTArray mFilterDatas; + wr::LayoutRect mBounds = wr::ToLayoutRect(LayoutDeviceRect()); + const gfx::Matrix4x4* mBoundTransform = nullptr; + const wr::WrTransformInfo* mTransformPtr = nullptr; + nsDisplayTransform* mDeferredTransformItem = nullptr; + // Whether the stacking context is possibly animated. This alters how + // coordinates are transformed/snapped to invalidate less when transforms + // change frequently. + bool mAnimated = false; + // Whether items should be rasterized in a local space that is (mostly) + // invariant to transforms, i.e. disabling subpixel AA and screen space pixel + // snapping on text runs that would only make sense in screen space. + bool mRasterizeLocally = false; +}; + +/// This is a simple C++ wrapper around WrState defined in the rust bindings. +/// We may want to turn this into a direct wrapper on top of +/// WebRenderFrameBuilder instead, so the interface may change a bit. +class DisplayListBuilder final { + public: + explicit DisplayListBuilder(wr::PipelineId aId, + layers::WebRenderBackend aBackend); + DisplayListBuilder(DisplayListBuilder&&) = default; + + ~DisplayListBuilder(); + + void Save(); + void Restore(); + void ClearSave(); + + usize Dump(usize aIndent, const Maybe& aStart, + const Maybe& aEnd); + void DumpSerializedDisplayList(); + + void Begin(layers::DisplayItemCache* aCache = nullptr); + void End(wr::BuiltDisplayList& aOutDisplayList); + void End(layers::DisplayListData& aOutTransaction); + + Maybe PushStackingContext( + const StackingContextParams& aParams, const wr::LayoutRect& aBounds, + const wr::RasterSpace& aRasterSpace); + void PopStackingContext(bool aIsReferenceFrame); + + wr::WrClipChainId DefineClipChain(const nsTArray& aClips, + bool aParentWithCurrentChain = false); + + wr::WrClipId DefineImageMaskClip(const wr::ImageMask& aMask, + const nsTArray&, + wr::FillRule); + wr::WrClipId DefineRoundedRectClip(Maybe aSpace, + const wr::ComplexClipRegion& aComplex); + wr::WrClipId DefineRectClip(Maybe aSpace, + wr::LayoutRect aClipRect); + + wr::WrSpatialId DefineStickyFrame( + const wr::LayoutRect& aContentRect, const float* aTopMargin, + const float* aRightMargin, const float* aBottomMargin, + const float* aLeftMargin, const StickyOffsetBounds& aVerticalBounds, + const StickyOffsetBounds& aHorizontalBounds, + const wr::LayoutVector2D& aAppliedOffset, wr::SpatialTreeItemKey aKey); + + Maybe GetScrollIdForDefinedScrollLayer( + layers::ScrollableLayerGuid::ViewID aViewId) const; + wr::WrSpatialId DefineScrollLayer( + const layers::ScrollableLayerGuid::ViewID& aViewId, + const Maybe& aParent, const wr::LayoutRect& aContentRect, + const wr::LayoutRect& aClipRect, const wr::LayoutVector2D& aScrollOffset, + wr::APZScrollGeneration aScrollOffsetGeneration, + wr::HasScrollLinkedEffect aHasScrollLinkedEffect, + wr::SpatialTreeItemKey aKey); + + void PushRect(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, bool aForceAntiAliasing, + bool aIsCheckerboard, const wr::ColorF& aColor); + void PushRectWithAnimation(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::ColorF& aColor, + const WrAnimationProperty* aAnimation); + void PushRoundedRect(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::ColorF& aColor); + void PushHitTest(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, + const layers::ScrollableLayerGuid::ViewID& aScrollId, + const gfx::CompositorHitTestInfo& aHitInfo, + SideBits aSideBits); + void PushClearRect(const wr::LayoutRect& aBounds); + + void PushBackdropFilter(const wr::LayoutRect& aBounds, + const wr::ComplexClipRegion& aRegion, + const nsTArray& aFilters, + const nsTArray& aFilterDatas, + bool aIsBackfaceVisible); + + void PushLinearGradient(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::LayoutPoint& aStartPoint, + const wr::LayoutPoint& aEndPoint, + const nsTArray& aStops, + wr::ExtendMode aExtendMode, + const wr::LayoutSize aTileSize, + const wr::LayoutSize aTileSpacing); + + void PushRadialGradient(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::LayoutPoint& aCenter, + const wr::LayoutSize& aRadius, + const nsTArray& aStops, + wr::ExtendMode aExtendMode, + const wr::LayoutSize aTileSize, + const wr::LayoutSize aTileSpacing); + + void PushConicGradient(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::LayoutPoint& aCenter, const float aAngle, + const nsTArray& aStops, + wr::ExtendMode aExtendMode, + const wr::LayoutSize aTileSize, + const wr::LayoutSize aTileSpacing); + + void PushImage(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, bool aForceAntiAliasing, + wr::ImageRendering aFilter, wr::ImageKey aImage, + bool aPremultipliedAlpha = true, + const wr::ColorF& aColor = wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f}, + bool aPreferCompositorSurface = false, + bool aSupportsExternalCompositing = false); + + void PushRepeatingImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSize& aStretchSize, + const wr::LayoutSize& aTileSpacing, wr::ImageRendering aFilter, + wr::ImageKey aImage, bool aPremultipliedAlpha = true, + const wr::ColorF& aColor = wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f}); + + void PushYCbCrPlanarImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::ImageKey aImageChannel1, wr::ImageKey aImageChannel2, + wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace, + wr::WrColorRange aColorRange, wr::ImageRendering aFilter, + bool aPreferCompositorSurface = false, + bool aSupportsExternalCompositing = false); + + void PushNV12Image(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth, + wr::WrYuvColorSpace aColorSpace, + wr::WrColorRange aColorRange, wr::ImageRendering aFilter, + bool aPreferCompositorSurface = false, + bool aSupportsExternalCompositing = false); + + void PushP010Image(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::ImageKey aImageChannel1, wr::WrColorDepth aColorDepth, + wr::WrYuvColorSpace aColorSpace, + wr::WrColorRange aColorRange, wr::ImageRendering aFilter, + bool aPreferCompositorSurface = false, + bool aSupportsExternalCompositing = false); + + void PushYCbCrInterleavedImage( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, wr::ImageKey aImageChannel0, + wr::WrColorDepth aColorDepth, wr::WrYuvColorSpace aColorSpace, + wr::WrColorRange aColorRange, wr::ImageRendering aFilter, + bool aPreferCompositorSurface = false, + bool aSupportsExternalCompositing = false); + + void PushIFrame(const LayoutDeviceRect& aDevPxBounds, bool aIsBackfaceVisible, + wr::PipelineId aPipeline, bool aIgnoreMissingPipeline); + + // XXX WrBorderSides are passed with Range. + // It is just to bypass compiler bug. See Bug 1357734. + void PushBorder(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, + const Range& aSides, + const wr::BorderRadius& aRadius, + wr::AntialiasBorder = wr::AntialiasBorder::Yes); + + void PushBorderImage(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::WrBorderImage& aParams); + + void PushBorderGradient(const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::LayoutSideOffsets& aWidths, + const int32_t aWidth, const int32_t aHeight, + bool aFill, const wr::DeviceIntSideOffsets& aSlice, + const wr::LayoutPoint& aStartPoint, + const wr::LayoutPoint& aEndPoint, + const nsTArray& aStops, + wr::ExtendMode aExtendMode); + + void PushBorderRadialGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill, + const wr::LayoutPoint& aCenter, const wr::LayoutSize& aRadius, + const nsTArray& aStops, wr::ExtendMode aExtendMode); + + void PushBorderConicGradient( + const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutSideOffsets& aWidths, bool aFill, + const wr::LayoutPoint& aCenter, const float aAngle, + const nsTArray& aStops, wr::ExtendMode aExtendMode); + + void PushText(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::ColorF& aColor, + wr::FontInstanceKey aFontKey, + Range aGlyphBuffer, + const wr::GlyphOptions* aGlyphOptions = nullptr); + + void PushLine(const wr::LayoutRect& aClip, bool aIsBackfaceVisible, + const wr::Line& aLine); + + void PushShadow(const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::Shadow& aShadow, + bool aShouldInflate); + + void PopAllShadows(); + + void PushBoxShadow(const wr::LayoutRect& aRect, const wr::LayoutRect& aClip, + bool aIsBackfaceVisible, const wr::LayoutRect& aBoxBounds, + const wr::LayoutVector2D& aOffset, + const wr::ColorF& aColor, const float& aBlurRadius, + const float& aSpreadRadius, + const wr::BorderRadius& aBorderRadius, + const wr::BoxShadowClipMode& aClipMode); + + /** + * Notifies the DisplayListBuilder that it can group together WR display items + * that are pushed until |CancelGroup()| or |FinishGroup()| call. + */ + void StartGroup(nsPaintedDisplayItem* aItem); + + /** + * Cancels grouping of the display items and discards all the display items + * pushed between the |StartGroup()| and |CancelGroup()| calls. + */ + void CancelGroup(const bool aDiscard = false); + + /** + * Finishes the display item group. The group is stored in WebRender backend, + * and can be reused with |ReuseItem()|, if the Gecko display item is reused. + */ + void FinishGroup(); + + /** + * Try to reuse the previously created WebRender display items for the given + * Gecko display item |aItem|. + * Returns true if the items were reused, otherwise returns false. + */ + bool ReuseItem(nsPaintedDisplayItem* aItem); + + uint64_t CurrentClipChainId() const { + return mCurrentSpaceAndClipChain.clip_chain; + } + + const wr::WrSpaceAndClipChain& CurrentSpaceAndClipChain() const { + return mCurrentSpaceAndClipChain; + } + + const wr::PipelineId& CurrentPipelineId() const { return mPipelineId; } + layers::WebRenderBackend GetBackendType() const { return mBackend; } + + // Checks to see if the innermost enclosing fixed pos item has the same + // ASR. If so, it returns the scroll target for that fixed-pos item. + // Otherwise, it returns Nothing(). + Maybe GetContainingFixedPosScrollTarget( + const ActiveScrolledRoot* aAsr); + + Maybe GetContainingFixedPosSideBits(const ActiveScrolledRoot* aAsr); + + gfxContext* GetTextContext(wr::IpcResourceUpdateQueue& aResources, + const layers::StackingContextHelper& aSc, + layers::RenderRootStateManager* aManager, + nsDisplayItem* aItem, nsRect& aBounds, + const gfx::Point& aDeviceOffset); + + // Try to avoid using this when possible. + wr::WrState* Raw() { return mWrState; } + + void SetClipChainLeaf(const Maybe& aClipRect) { + mClipChainLeaf = aClipRect; + } + + // Used for opacity flattening. When we flatten away an opacity item, + // we push the opacity value onto the builder. + // Descendant items should pull the inherited opacity during + // their CreateWebRenderCommands implementation. This can only happen if all + // descendant items reported supporting this functionality, via + // nsDisplayItem::CanApplyOpacity. + float GetInheritedOpacity() { return mInheritedOpacity; } + void SetInheritedOpacity(float aOpacity) { mInheritedOpacity = aOpacity; } + const DisplayItemClipChain* GetInheritedClipChain() { + return mInheritedClipChain; + } + void PushInheritedClipChain(nsDisplayListBuilder* aBuilder, + const DisplayItemClipChain* aClipChain); + void SetInheritedClipChain(const DisplayItemClipChain* aClipChain) { + mInheritedClipChain = aClipChain; + } + + layers::DisplayItemCache* GetDisplayItemCache() { return mDisplayItemCache; } + + // A chain of RAII objects, each holding a (ASR, ViewID, SideBits) tuple of + // data. The topmost object is pointed to by the mActiveFixedPosTracker + // pointer in the wr::DisplayListBuilder. + class MOZ_RAII FixedPosScrollTargetTracker final { + public: + FixedPosScrollTargetTracker(DisplayListBuilder& aBuilder, + const ActiveScrolledRoot* aAsr, + layers::ScrollableLayerGuid::ViewID aScrollId, + SideBits aSideBits); + ~FixedPosScrollTargetTracker(); + Maybe GetScrollTargetForASR( + const ActiveScrolledRoot* aAsr); + Maybe GetSideBitsForASR(const ActiveScrolledRoot* aAsr); + + private: + FixedPosScrollTargetTracker* mParentTracker; + DisplayListBuilder& mBuilder; + const ActiveScrolledRoot* mAsr; + layers::ScrollableLayerGuid::ViewID mScrollId; + SideBits mSideBits; + }; + + protected: + wr::LayoutRect MergeClipLeaf(const wr::LayoutRect& aClip) { + if (mClipChainLeaf) { + return wr::IntersectLayoutRect(*mClipChainLeaf, aClip); + } + return aClip; + } + + // See the implementation of PushShadow for details on these methods. + void SuspendClipLeafMerging(); + void ResumeClipLeafMerging(); + + wr::WrState* mWrState; + + // Track each scroll id that we encountered. We use this structure to + // ensure that we don't define a particular scroll layer multiple times, + // as that results in undefined behaviour in WR. + std::unordered_map + mScrollIds; + + wr::WrSpaceAndClipChain mCurrentSpaceAndClipChain; + + // Contains the current leaf of the clip chain to be merged with the + // display item's clip rect when pushing an item. May be set to Nothing() if + // there is no clip rect to merge with. + Maybe mClipChainLeaf; + + // Versions of the above that are on hold while SuspendClipLeafMerging is on + // (see the implementation of PushShadow for details). + Maybe mSuspendedSpaceAndClipChain; + Maybe mSuspendedClipChainLeaf; + + RefPtr mCachedTextDT; + mozilla::UniquePtr mCachedContext; + + FixedPosScrollTargetTracker* mActiveFixedPosTracker; + + wr::PipelineId mPipelineId; + layers::WebRenderBackend mBackend; + + layers::DisplayItemCache* mDisplayItemCache; + Maybe mCurrentCacheSlot; + float mInheritedOpacity = 1.0f; + const DisplayItemClipChain* mInheritedClipChain = nullptr; + + friend class WebRenderAPI; + friend class SpaceAndClipChainHelper; +}; + +// This is a RAII class that overrides the current Wr's SpatialId and +// ClipChainId. +class MOZ_RAII SpaceAndClipChainHelper final { + public: + SpaceAndClipChainHelper(DisplayListBuilder& aBuilder, + wr::WrSpaceAndClipChain aSpaceAndClipChain) + : mBuilder(aBuilder), + mOldSpaceAndClipChain(aBuilder.mCurrentSpaceAndClipChain) { + aBuilder.mCurrentSpaceAndClipChain = aSpaceAndClipChain; + } + SpaceAndClipChainHelper(DisplayListBuilder& aBuilder, + wr::WrSpatialId aSpatialId) + : mBuilder(aBuilder), + mOldSpaceAndClipChain(aBuilder.mCurrentSpaceAndClipChain) { + aBuilder.mCurrentSpaceAndClipChain.space = aSpatialId; + } + SpaceAndClipChainHelper(DisplayListBuilder& aBuilder, + wr::WrClipChainId aClipChainId) + : mBuilder(aBuilder), + mOldSpaceAndClipChain(aBuilder.mCurrentSpaceAndClipChain) { + aBuilder.mCurrentSpaceAndClipChain.clip_chain = aClipChainId.id; + } + + ~SpaceAndClipChainHelper() { + mBuilder.mCurrentSpaceAndClipChain = mOldSpaceAndClipChain; + } + + private: + SpaceAndClipChainHelper(const SpaceAndClipChainHelper&) = delete; + + DisplayListBuilder& mBuilder; + wr::WrSpaceAndClipChain mOldSpaceAndClipChain; +}; + +Maybe SurfaceFormatToImageFormat(gfx::SurfaceFormat aFormat); + +} // namespace wr +} // namespace mozilla + +#endif diff --git a/gfx/webrender_bindings/WebRenderTypes.cpp b/gfx/webrender_bindings/WebRenderTypes.cpp new file mode 100644 index 0000000000..3fa81d2a81 --- /dev/null +++ b/gfx/webrender_bindings/WebRenderTypes.cpp @@ -0,0 +1,110 @@ +/* -*- 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 "WebRenderTypes.h" + +#include "mozilla/ipc/ByteBuf.h" +#include "nsStyleConsts.h" + +namespace mozilla { +namespace wr { + +WindowId NewWindowId() { + static uint64_t sNextId = 1; + + WindowId id; + id.mHandle = sNextId++; + return id; +} + +BorderStyle ToBorderStyle(StyleBorderStyle aStyle) { + switch (aStyle) { + case StyleBorderStyle::None: + return wr::BorderStyle::None; + case StyleBorderStyle::Solid: + return wr::BorderStyle::Solid; + case StyleBorderStyle::Double: + return wr::BorderStyle::Double; + case StyleBorderStyle::Dotted: + return wr::BorderStyle::Dotted; + case StyleBorderStyle::Dashed: + return wr::BorderStyle::Dashed; + case StyleBorderStyle::Hidden: + return wr::BorderStyle::Hidden; + case StyleBorderStyle::Groove: + return wr::BorderStyle::Groove; + case StyleBorderStyle::Ridge: + return wr::BorderStyle::Ridge; + case StyleBorderStyle::Inset: + return wr::BorderStyle::Inset; + case StyleBorderStyle::Outset: + return wr::BorderStyle::Outset; + } + return wr::BorderStyle::None; +} + +wr::RepeatMode ToRepeatMode(StyleBorderImageRepeat aRepeat) { + switch (aRepeat) { + case StyleBorderImageRepeat::Stretch: + return wr::RepeatMode::Stretch; + case StyleBorderImageRepeat::Repeat: + return wr::RepeatMode::Repeat; + case StyleBorderImageRepeat::Round: + return wr::RepeatMode::Round; + case StyleBorderImageRepeat::Space: + return wr::RepeatMode::Space; + default: + MOZ_ASSERT(false); + } + + return wr::RepeatMode::Stretch; +} + +ImageRendering ToImageRendering(StyleImageRendering aImageRendering) { + switch (aImageRendering) { + case StyleImageRendering::Auto: + case StyleImageRendering::Smooth: + case StyleImageRendering::Optimizequality: + return wr::ImageRendering::Auto; + case StyleImageRendering::CrispEdges: + // FIXME(bug 1728831): Historically we've returned Pixelated here, but + // this should arguably pass CrispEdges to WebRender? + // return wr::ImageRendering::CrispEdges; + [[fallthrough]]; + case StyleImageRendering::Optimizespeed: + case StyleImageRendering::Pixelated: + return wr::ImageRendering::Pixelated; + } + return wr::ImageRendering::Auto; +} + +void Assign_WrVecU8(wr::WrVecU8& aVec, mozilla::ipc::ByteBuf&& aOther) { + aVec.data = aOther.mData; + aVec.length = aOther.mLen; + aVec.capacity = aOther.mCapacity; + aOther.mData = nullptr; + aOther.mLen = 0; + aOther.mCapacity = 0; +} + +WrSpatialId RootScrollNode() { return wr_root_scroll_node_id(); } + +WrSpaceAndClipChain RootScrollNodeWithChain() { + WrSpaceAndClipChain sacc; + sacc.clip_chain = wr::ROOT_CLIP_CHAIN; + sacc.space = wr_root_scroll_node_id(); + return sacc; +} + +WrSpaceAndClipChain InvalidScrollNodeWithChain() { + WrSpaceAndClipChain sacc; + sacc.clip_chain = std::numeric_limits::max(); + sacc.space = wr_root_scroll_node_id(); + return sacc; +} + +} // namespace wr +} // namespace mozilla diff --git a/gfx/webrender_bindings/WebRenderTypes.h b/gfx/webrender_bindings/WebRenderTypes.h new file mode 100644 index 0000000000..3216a0afd6 --- /dev/null +++ b/gfx/webrender_bindings/WebRenderTypes.h @@ -0,0 +1,920 @@ +/* -*- 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/. */ + +#ifndef GFX_WEBRENDERTYPES_H +#define GFX_WEBRENDERTYPES_H + +#include "ImageTypes.h" +#include "mozilla/webrender/webrender_ffi.h" +#include "mozilla/EnumSet.h" +#include "mozilla/Maybe.h" +#include "mozilla/gfx/Matrix.h" +#include "mozilla/gfx/Types.h" +#include "mozilla/gfx/Tools.h" +#include "mozilla/gfx/Rect.h" +#include "mozilla/layers/LayersTypes.h" +#include "mozilla/PodOperations.h" +#include "mozilla/Range.h" +#include "mozilla/ScrollGeneration.h" +#include "Units.h" +#include "nsIWidgetListener.h" + +namespace mozilla { + +enum class StyleBorderStyle : uint8_t; +enum class StyleBorderImageRepeat : uint8_t; +enum class StyleImageRendering : uint8_t; + +namespace ipc { +class ByteBuf; +} // namespace ipc + +namespace wr { + +// Using uintptr_t in C++ code for "size" types seems weird, so let's use a +// better-sounding typedef. The name comes from the fact that we generally +// have to deal with uintptr_t because that's what rust's usize maps to. +typedef uintptr_t usize; + +typedef wr::WrWindowId WindowId; +typedef wr::WrRemovedPipeline RemovedPipeline; + +class RenderedFrameIdType {}; +typedef layers::BaseTransactionId RenderedFrameId; + +typedef mozilla::Maybe MaybeIdNamespace; +typedef mozilla::Maybe MaybeImageMask; +typedef Maybe MaybeExternalImageId; + +typedef Maybe MaybeFontInstanceOptions; +typedef Maybe MaybeFontInstancePlatformOptions; + +struct ExternalImageKeyPair { + ImageKey key; + ExternalImageId id; +}; + +/* Generate a brand new window id and return it. */ +WindowId NewWindowId(); + +inline bool WindowSizeSanityCheck(int32_t aWidth, int32_t aHeight) { + if (aWidth < 0 || aWidth > wr::MAX_RENDER_TASK_SIZE || aHeight < 0 || + aHeight > wr::MAX_RENDER_TASK_SIZE) { + return false; + } + return true; +} + +inline DebugFlags NewDebugFlags(uint32_t aFlags) { return {aFlags}; } + +inline Maybe SurfaceFormatToImageFormat( + gfx::SurfaceFormat aFormat) { + switch (aFormat) { + case gfx::SurfaceFormat::R8G8B8X8: + // WebRender not support RGBX8. Assert here. + MOZ_ASSERT(false); + return Nothing(); + case gfx::SurfaceFormat::R8G8B8A8: + return Some(wr::ImageFormat::RGBA8); + case gfx::SurfaceFormat::B8G8R8X8: + // TODO: WebRender will have a BGRA + opaque flag for this but does not + // have it yet (cf. issue #732). + case gfx::SurfaceFormat::B8G8R8A8: + return Some(wr::ImageFormat::BGRA8); + case gfx::SurfaceFormat::A8: + return Some(wr::ImageFormat::R8); + case gfx::SurfaceFormat::A16: + return Some(wr::ImageFormat::R16); + case gfx::SurfaceFormat::R8G8: + return Some(wr::ImageFormat::RG8); + case gfx::SurfaceFormat::R16G16: + return Some(wr::ImageFormat::RG16); + case gfx::SurfaceFormat::UNKNOWN: + default: + return Nothing(); + } +} + +inline gfx::SurfaceFormat ImageFormatToSurfaceFormat(ImageFormat aFormat) { + switch (aFormat) { + case ImageFormat::BGRA8: + return gfx::SurfaceFormat::B8G8R8A8; + case ImageFormat::R8: + return gfx::SurfaceFormat::A8; + case ImageFormat::R16: + return gfx::SurfaceFormat::A16; + default: + return gfx::SurfaceFormat::UNKNOWN; + } +} + +// This extra piece of data is used to differentiate when spatial nodes that are +// created by Gecko that have the same mFrame and PerFrameKey. This currently +// only occurs with sticky display list items that are also zoomable, which +// results in Gecko creating both a sticky spatial node, and then a property +// animated reference frame for APZ +enum class SpatialKeyKind : uint32_t { + Transform, + Perspective, + Scroll, + Sticky, + ImagePipeline, + APZ, +}; + +// Construct a unique, persistent spatial key based on the frame tree pointer, +// per-frame key and a spatial key kind. For now, this covers all the ways Gecko +// creates spatial nodes. In future, we may need to be more clever with the +// SpatialKeyKind. +inline wr::SpatialTreeItemKey SpatialKey(uint64_t aFrame, uint32_t aPerFrameKey, + SpatialKeyKind aKind) { + return wr::SpatialTreeItemKey{ + aFrame, uint64_t(aPerFrameKey) | (uint64_t(aKind) << 32)}; +} + +struct ImageDescriptor : public wr::WrImageDescriptor { + // We need a default constructor for ipdl serialization. + ImageDescriptor() { + format = (ImageFormat)0; + width = 0; + height = 0; + stride = 0; + opacity = OpacityType::HasAlphaChannel; + prefer_compositor_surface = false; + } + + ImageDescriptor(const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat, + bool aPreferCompositorSurface = false) { + format = wr::SurfaceFormatToImageFormat(aFormat).valueOr((ImageFormat)0); + width = aSize.width; + height = aSize.height; + stride = 0; + opacity = gfx::IsOpaque(aFormat) ? OpacityType::Opaque + : OpacityType::HasAlphaChannel; + prefer_compositor_surface = aPreferCompositorSurface; + } + + ImageDescriptor(const gfx::IntSize& aSize, uint32_t aByteStride, + gfx::SurfaceFormat aFormat, + bool aPreferCompositorSurface = false) { + format = wr::SurfaceFormatToImageFormat(aFormat).valueOr((ImageFormat)0); + width = aSize.width; + height = aSize.height; + stride = aByteStride; + opacity = gfx::IsOpaque(aFormat) ? OpacityType::Opaque + : OpacityType::HasAlphaChannel; + prefer_compositor_surface = aPreferCompositorSurface; + } + + ImageDescriptor(const gfx::IntSize& aSize, uint32_t aByteStride, + gfx::SurfaceFormat aFormat, OpacityType aOpacity, + bool aPreferCompositorSurface = false) { + format = wr::SurfaceFormatToImageFormat(aFormat).valueOr((ImageFormat)0); + width = aSize.width; + height = aSize.height; + stride = aByteStride; + opacity = aOpacity; + prefer_compositor_surface = aPreferCompositorSurface; + } +}; + +inline uint64_t AsUint64(const NativeSurfaceId& aId) { + return static_cast(aId._0); +} + +// Whenever possible, use wr::WindowId instead of manipulating uint64_t. +inline uint64_t AsUint64(const WindowId& aId) { + return static_cast(aId.mHandle); +} + +// Whenever possible, use wr::ImageKey instead of manipulating uint64_t. +inline uint64_t AsUint64(const ImageKey& aId) { + return (static_cast(aId.mNamespace.mHandle) << 32) + + static_cast(aId.mHandle); +} + +inline ImageKey AsImageKey(const uint64_t& aId) { + ImageKey imageKey; + imageKey.mNamespace.mHandle = aId >> 32; + imageKey.mHandle = aId; + return imageKey; +} + +// Whenever possible, use wr::FontKey instead of manipulating uint64_t. +inline uint64_t AsUint64(const FontKey& aId) { + return (static_cast(aId.mNamespace.mHandle) << 32) + + static_cast(aId.mHandle); +} + +inline FontKey AsFontKey(const uint64_t& aId) { + FontKey fontKey; + fontKey.mNamespace.mHandle = aId >> 32; + fontKey.mHandle = aId; + return fontKey; +} + +// Whenever possible, use wr::FontInstanceKey instead of manipulating uint64_t. +inline uint64_t AsUint64(const FontInstanceKey& aId) { + return (static_cast(aId.mNamespace.mHandle) << 32) + + static_cast(aId.mHandle); +} + +inline FontInstanceKey AsFontInstanceKey(const uint64_t& aId) { + FontInstanceKey instanceKey; + instanceKey.mNamespace.mHandle = aId >> 32; + instanceKey.mHandle = aId; + return instanceKey; +} + +// Whenever possible, use wr::PipelineId instead of manipulating uint64_t. +inline uint64_t AsUint64(const PipelineId& aId) { + return (static_cast(aId.mNamespace) << 32) + + static_cast(aId.mHandle); +} + +inline PipelineId AsPipelineId(const uint64_t& aId) { + PipelineId pipeline; + pipeline.mNamespace = aId >> 32; + pipeline.mHandle = aId; + return pipeline; +} + +inline mozilla::layers::LayersId AsLayersId(const PipelineId& aId) { + return mozilla::layers::LayersId{AsUint64(aId)}; +} + +inline PipelineId AsPipelineId(const mozilla::layers::LayersId& aId) { + return AsPipelineId(uint64_t(aId)); +} + +ImageRendering ToImageRendering(StyleImageRendering); + +static inline FontRenderMode ToFontRenderMode(gfx::AntialiasMode aMode, + bool aPermitSubpixelAA = true) { + switch (aMode) { + case gfx::AntialiasMode::NONE: + return FontRenderMode::Mono; + case gfx::AntialiasMode::GRAY: + return FontRenderMode::Alpha; + case gfx::AntialiasMode::SUBPIXEL: + default: + return aPermitSubpixelAA ? FontRenderMode::Subpixel + : FontRenderMode::Alpha; + } +} + +static inline MixBlendMode ToMixBlendMode(gfx::CompositionOp compositionOp) { + switch (compositionOp) { + case gfx::CompositionOp::OP_MULTIPLY: + return MixBlendMode::Multiply; + case gfx::CompositionOp::OP_SCREEN: + return MixBlendMode::Screen; + case gfx::CompositionOp::OP_OVERLAY: + return MixBlendMode::Overlay; + case gfx::CompositionOp::OP_DARKEN: + return MixBlendMode::Darken; + case gfx::CompositionOp::OP_LIGHTEN: + return MixBlendMode::Lighten; + case gfx::CompositionOp::OP_COLOR_DODGE: + return MixBlendMode::ColorDodge; + case gfx::CompositionOp::OP_COLOR_BURN: + return MixBlendMode::ColorBurn; + case gfx::CompositionOp::OP_HARD_LIGHT: + return MixBlendMode::HardLight; + case gfx::CompositionOp::OP_SOFT_LIGHT: + return MixBlendMode::SoftLight; + case gfx::CompositionOp::OP_DIFFERENCE: + return MixBlendMode::Difference; + case gfx::CompositionOp::OP_EXCLUSION: + return MixBlendMode::Exclusion; + case gfx::CompositionOp::OP_HUE: + return MixBlendMode::Hue; + case gfx::CompositionOp::OP_SATURATION: + return MixBlendMode::Saturation; + case gfx::CompositionOp::OP_COLOR: + return MixBlendMode::Color; + case gfx::CompositionOp::OP_LUMINOSITY: + return MixBlendMode::Luminosity; + case gfx::CompositionOp::OP_ADD: + return MixBlendMode::PlusLighter; + default: + return MixBlendMode::Normal; + } +} + +static inline wr::ColorF ToColorF(const gfx::DeviceColor& color) { + wr::ColorF c; + c.r = color.r; + c.g = color.g; + c.b = color.b; + c.a = color.a; + return c; +} + +static inline wr::LayoutPoint ToLayoutPoint( + const mozilla::LayoutDevicePoint& point) { + wr::LayoutPoint p; + p.x = point.x; + p.y = point.y; + return p; +} + +static inline wr::LayoutPoint ToLayoutPoint( + const mozilla::LayoutDeviceIntPoint& point) { + return ToLayoutPoint(LayoutDevicePoint(point)); +} + +static inline wr::WorldPoint ToWorldPoint(const mozilla::ScreenPoint& point) { + wr::WorldPoint p; + p.x = point.x; + p.y = point.y; + return p; +} + +static inline wr::LayoutVector2D ToLayoutVector2D( + const mozilla::LayoutDevicePoint& point) { + wr::LayoutVector2D p; + p.x = point.x; + p.y = point.y; + return p; +} + +static inline wr::LayoutVector2D ToLayoutVector2D( + const mozilla::LayoutDeviceIntPoint& point) { + return ToLayoutVector2D(LayoutDevicePoint(point)); +} + +static inline wr::LayoutRect ToLayoutRect( + const mozilla::LayoutDeviceRect& rect) { + wr::LayoutRect r; + r.min.x = rect.X(); + r.min.y = rect.Y(); + r.max.x = rect.X() + rect.Width(); + r.max.y = rect.Y() + rect.Height(); + return r; +} + +static inline wr::LayoutRect ToLayoutRect(const gfx::Rect& rect) { + wr::LayoutRect r; + r.min.x = rect.X(); + r.min.y = rect.Y(); + r.max.x = rect.X() + rect.Width(); + r.max.y = rect.Y() + rect.Height(); + return r; +} + +static inline wr::DeviceIntRect ToDeviceIntRect( + const mozilla::ImageIntRect& rect) { + wr::DeviceIntRect r; + r.min.x = rect.X(); + r.min.y = rect.Y(); + r.max.x = rect.X() + rect.Width(); + r.max.y = rect.Y() + rect.Height(); + return r; +} + +// TODO: should be const LayoutDeviceIntRect instead of ImageIntRect +static inline wr::LayoutIntRect ToLayoutIntRect( + const mozilla::ImageIntRect& rect) { + wr::LayoutIntRect r; + r.min.x = rect.X(); + r.min.y = rect.Y(); + r.max.x = rect.X() + rect.Width(); + r.max.y = rect.Y() + rect.Height(); + return r; +} + +static inline wr::LayoutRect ToLayoutRect( + const mozilla::LayoutDeviceIntRect& rect) { + return ToLayoutRect(IntRectToRect(rect)); +} + +static inline wr::LayoutRect IntersectLayoutRect(const wr::LayoutRect& aRect, + const wr::LayoutRect& aOther) { + wr::LayoutRect r; + r.min.x = std::max(aRect.min.x, aOther.min.x); + r.min.y = std::max(aRect.min.y, aOther.min.y); + r.max.x = std::min(aRect.max.x, aOther.max.x); + r.max.y = std::min(aRect.max.y, aOther.max.y); + + if (r.max.x < r.min.x || r.max.y < r.min.y) { + r.max.x = r.min.x; + r.max.y = r.min.y; + } + return r; +} + +static inline wr::LayoutSize ToLayoutSize( + const mozilla::LayoutDeviceSize& size) { + wr::LayoutSize ls; + ls.width = size.width; + ls.height = size.height; + return ls; +} + +static inline wr::ComplexClipRegion ToComplexClipRegion( + const gfx::RoundedRect& rect) { + wr::ComplexClipRegion ret; + ret.rect = ToLayoutRect(rect.rect); + ret.radii.top_left = ToLayoutSize(LayoutDeviceSize::FromUnknownSize( + rect.corners.radii[mozilla::eCornerTopLeft])); + ret.radii.top_right = ToLayoutSize(LayoutDeviceSize::FromUnknownSize( + rect.corners.radii[mozilla::eCornerTopRight])); + ret.radii.bottom_left = ToLayoutSize(LayoutDeviceSize::FromUnknownSize( + rect.corners.radii[mozilla::eCornerBottomLeft])); + ret.radii.bottom_right = ToLayoutSize(LayoutDeviceSize::FromUnknownSize( + rect.corners.radii[mozilla::eCornerBottomRight])); + ret.mode = wr::ClipMode::Clip; + return ret; +} + +static inline wr::ComplexClipRegion SimpleRadii(const wr::LayoutRect& aRect, + float aRadii) { + wr::ComplexClipRegion ret; + wr::LayoutSize radii{aRadii, aRadii}; + ret.rect = aRect; + ret.radii.top_left = radii; + ret.radii.top_right = radii; + ret.radii.bottom_left = radii; + ret.radii.bottom_right = radii; + ret.mode = wr::ClipMode::Clip; + return ret; +} + +static inline wr::LayoutSize ToLayoutSize( + const mozilla::LayoutDeviceIntSize& size) { + return ToLayoutSize(LayoutDeviceSize(size)); +} + +template +static inline wr::LayoutTransform ToLayoutTransform( + const gfx::Matrix4x4Typed& m) { + wr::LayoutTransform transform; + transform.m11 = m._11; + transform.m12 = m._12; + transform.m13 = m._13; + transform.m14 = m._14; + transform.m21 = m._21; + transform.m22 = m._22; + transform.m23 = m._23; + transform.m24 = m._24; + transform.m31 = m._31; + transform.m32 = m._32; + transform.m33 = m._33; + transform.m34 = m._34; + transform.m41 = m._41; + transform.m42 = m._42; + transform.m43 = m._43; + transform.m44 = m._44; + return transform; +} + +wr::BorderStyle ToBorderStyle(StyleBorderStyle style); + +static inline wr::BorderSide ToBorderSide(const gfx::DeviceColor& color, + StyleBorderStyle style) { + wr::BorderSide bs; + bs.color = ToColorF(color); + bs.style = ToBorderStyle(style); + return bs; +} + +static inline wr::BorderRadius EmptyBorderRadius() { + wr::BorderRadius br; + PodZero(&br); + return br; +} + +static inline wr::BorderRadius ToBorderRadius( + const LayoutDeviceSize& topLeft, const LayoutDeviceSize& topRight, + const LayoutDeviceSize& bottomLeft, const LayoutDeviceSize& bottomRight) { + wr::BorderRadius br; + br.top_left = ToLayoutSize(topLeft); + br.top_right = ToLayoutSize(topRight); + br.bottom_left = ToLayoutSize(bottomLeft); + br.bottom_right = ToLayoutSize(bottomRight); + return br; +} + +static inline wr::BorderRadius ToBorderRadius( + const gfx::RectCornerRadii& aRadii) { + return ToBorderRadius(LayoutDeviceSize::FromUnknownSize(aRadii[0]), + LayoutDeviceSize::FromUnknownSize(aRadii[1]), + LayoutDeviceSize::FromUnknownSize(aRadii[3]), + LayoutDeviceSize::FromUnknownSize(aRadii[2])); +} + +static inline wr::ComplexClipRegion ToComplexClipRegion( + const nsRect& aRect, const nscoord* aRadii, int32_t aAppUnitsPerDevPixel) { + wr::ComplexClipRegion ret; + ret.rect = + ToLayoutRect(LayoutDeviceRect::FromAppUnits(aRect, aAppUnitsPerDevPixel)); + ret.radii = ToBorderRadius( + LayoutDeviceSize::FromAppUnits( + nsSize(aRadii[eCornerTopLeftX], aRadii[eCornerTopLeftY]), + aAppUnitsPerDevPixel), + LayoutDeviceSize::FromAppUnits( + nsSize(aRadii[eCornerTopRightX], aRadii[eCornerTopRightY]), + aAppUnitsPerDevPixel), + LayoutDeviceSize::FromAppUnits( + nsSize(aRadii[eCornerBottomLeftX], aRadii[eCornerBottomLeftY]), + aAppUnitsPerDevPixel), + LayoutDeviceSize::FromAppUnits( + nsSize(aRadii[eCornerBottomRightX], aRadii[eCornerBottomRightY]), + aAppUnitsPerDevPixel)); + ret.mode = ClipMode::Clip; + return ret; +} + +static inline wr::LayoutSideOffsets ToBorderWidths(float top, float right, + float bottom, float left) { + wr::LayoutSideOffsets bw; + bw.top = top; + bw.right = right; + bw.bottom = bottom; + bw.left = left; + return bw; +} + +static inline wr::DeviceIntSideOffsets ToDeviceIntSideOffsets(int32_t top, + int32_t right, + int32_t bottom, + int32_t left) { + wr::DeviceIntSideOffsets offset; + offset.top = top; + offset.right = right; + offset.bottom = bottom; + offset.left = left; + return offset; +} + +static inline wr::LayoutSideOffsets ToLayoutSideOffsets(float top, float right, + float bottom, + float left) { + wr::LayoutSideOffsets offset; + offset.top = top; + offset.right = right; + offset.bottom = bottom; + offset.left = left; + return offset; +} + +wr::RepeatMode ToRepeatMode(StyleBorderImageRepeat); + +template +static inline wr::WrTransformProperty ToWrTransformProperty( + uint64_t id, const gfx::Matrix4x4Typed& transform) { + wr::WrTransformProperty prop; + prop.id = id; + prop.value = ToLayoutTransform(transform); + return prop; +} + +static inline wr::WrOpacityProperty ToWrOpacityProperty(uint64_t id, + const float opacity) { + wr::WrOpacityProperty prop; + prop.id = id; + prop.value = opacity; + return prop; +} + +static inline wr::WrColorProperty ToWrColorProperty( + uint64_t id, const gfx::DeviceColor& color) { + wr::WrColorProperty prop; + prop.id = id; + prop.value = ToColorF(color); + return prop; +} + +// Whenever possible, use wr::ExternalImageId instead of manipulating uint64_t. +inline uint64_t AsUint64(const ExternalImageId& aId) { + return static_cast(aId._0); +} + +static inline ExternalImageId ToExternalImageId(uint64_t aID) { + ExternalImageId Id; + Id._0 = aID; + return Id; +} + +static inline wr::WrExternalImage RawDataToWrExternalImage(const uint8_t* aBuff, + size_t size) { + return wr::WrExternalImage{ + wr::WrExternalImageType::RawData, 0, 0.0f, 0.0f, 0.0f, 0.0f, aBuff, size}; +} + +static inline wr::WrExternalImage NativeTextureToWrExternalImage( + uint32_t aHandle, float u0, float v0, float u1, float v1) { + return wr::WrExternalImage{wr::WrExternalImageType::NativeTexture, + aHandle, + u0, + v0, + u1, + v1, + nullptr, + 0}; +} + +static inline wr::WrExternalImage InvalidToWrExternalImage() { + return wr::WrExternalImage{ + wr::WrExternalImageType::Invalid, 0, 0, 0, 0, 0, nullptr, 0}; +} + +inline wr::ByteSlice RangeToByteSlice(mozilla::Range aRange) { + return wr::ByteSlice{aRange.begin().get(), aRange.length()}; +} + +inline mozilla::Range ByteSliceToRange(wr::ByteSlice aWrSlice) { + return mozilla::Range(aWrSlice.buffer, aWrSlice.len); +} + +inline mozilla::Range MutByteSliceToRange(wr::MutByteSlice aWrSlice) { + return mozilla::Range(aWrSlice.buffer, aWrSlice.len); +} + +void Assign_WrVecU8(wr::WrVecU8& aVec, mozilla::ipc::ByteBuf&& aOther); + +template +struct Vec; + +template <> +struct Vec final { + wr::WrVecU8 inner; + Vec() { SetEmpty(); } + Vec(Vec&) = delete; + Vec(Vec&& src) { + inner = src.inner; + src.SetEmpty(); + } + + explicit Vec(mozilla::ipc::ByteBuf&& aSrc) { + Assign_WrVecU8(inner, std::move(aSrc)); + } + + Vec& operator=(Vec&& src) { + inner = src.inner; + src.SetEmpty(); + return *this; + } + + wr::WrVecU8 Extract() { + wr::WrVecU8 ret = inner; + SetEmpty(); + return ret; + } + + void SetEmpty() { + inner.data = (uint8_t*)1; + inner.capacity = 0; + inner.length = 0; + } + + uint8_t* Data() { return inner.data; } + + size_t Length() { return inner.length; } + + size_t Capacity() { return inner.capacity; } + + Range GetRange() { return Range(Data(), Length()); } + + void PushBytes(Range aBytes) { + wr_vec_u8_push_bytes(&inner, RangeToByteSlice(aBytes)); + } + + void Reserve(size_t aLength) { wr_vec_u8_reserve(&inner, aLength); } + + ~Vec() { + if (inner.data) { + wr_vec_u8_free(inner); + } + } +}; + +struct ByteBuffer { + ByteBuffer(size_t aLength, uint8_t* aData) + : mLength(aLength), mData(aData), mOwned(false) {} + + // XXX: this is a bit of hack that assumes + // the allocators are the same + explicit ByteBuffer(VecU8&& vec) { + if (vec.inner.capacity) { + mLength = vec.inner.length; + mData = vec.inner.data; + vec.inner.data = nullptr; + vec.inner.capacity = 0; + mOwned = true; + } else { + mOwned = false; + mData = nullptr; + mLength = 0; + } + } + + ByteBuffer(ByteBuffer&& aFrom) + : mLength(aFrom.mLength), mData(aFrom.mData), mOwned(aFrom.mOwned) { + aFrom.mLength = 0; + aFrom.mData = nullptr; + aFrom.mOwned = false; + } + + ByteBuffer(ByteBuffer& aFrom) + : mLength(aFrom.mLength), mData(aFrom.mData), mOwned(aFrom.mOwned) { + aFrom.mLength = 0; + aFrom.mData = nullptr; + aFrom.mOwned = false; + } + + ByteBuffer() : mLength(0), mData(nullptr), mOwned(false) {} + + bool Allocate(size_t aLength) { + MOZ_ASSERT(mData == nullptr); + mData = (uint8_t*)malloc(aLength); + if (!mData) { + return false; + } + mLength = aLength; + mOwned = true; + return true; + } + + ~ByteBuffer() { + if (mData && mOwned) { + free(mData); + } + } + + const Range AsSlice() const { + return Range(mData, mLength); + } + + Range AsSlice() { return Range(mData, mLength); } + + bool operator==(const ByteBuffer& other) const { + return mLength == other.mLength && !(memcmp(mData, other.mData, mLength)); + } + + size_t mLength; + uint8_t* mData; + bool mOwned; +}; + +struct BuiltDisplayList { + wr::VecU8 dl_items; + wr::VecU8 dl_cache; + wr::VecU8 dl_spatial_tree; + wr::BuiltDisplayListDescriptor dl_desc; +}; + +// Corresponds to a clip id for a clip chain in webrender. Similar to +// WrClipId but a separate struct so we don't get them mixed up in C++. +struct WrClipChainId { + uint64_t id; + + bool operator==(const WrClipChainId& other) const { return id == other.id; } + + static WrClipChainId Empty() { + WrClipChainId id = {0}; + return id; + } +}; + +WrSpatialId RootScrollNode(); +WrSpaceAndClipChain RootScrollNodeWithChain(); +WrSpaceAndClipChain InvalidScrollNodeWithChain(); + +enum class WebRenderError : int8_t { + INITIALIZE = 0, + MAKE_CURRENT, + RENDER, + NEW_SURFACE, + BEGIN_DRAW, + VIDEO_OVERLAY, + VIDEO_HW_OVERLAY, + VIDEO_SW_OVERLAY, + EXCESSIVE_RESETS, + + Sentinel /* this must be last for serialization purposes. */ +}; + +static inline wr::WrYuvColorSpace ToWrYuvColorSpace( + gfx::YUVColorSpace aYUVColorSpace) { + switch (aYUVColorSpace) { + case gfx::YUVColorSpace::BT601: + return wr::WrYuvColorSpace::Rec601; + case gfx::YUVColorSpace::BT709: + return wr::WrYuvColorSpace::Rec709; + case gfx::YUVColorSpace::BT2020: + return wr::WrYuvColorSpace::Rec2020; + case gfx::YUVColorSpace::Identity: + return wr::WrYuvColorSpace::Identity; + default: + MOZ_ASSERT_UNREACHABLE("Tried to convert invalid YUVColorSpace."); + } + return wr::WrYuvColorSpace::Rec601; +} + +// TODO: Use YUVRangedColorSpace instead of assuming ColorRange::LIMITED. +static inline wr::YuvRangedColorSpace ToWrYuvRangedColorSpace( + gfx::YUVRangedColorSpace aFrom) { + switch (aFrom) { + case gfx::YUVRangedColorSpace::BT601_Narrow: + return wr::YuvRangedColorSpace::Rec601Narrow; + case gfx::YUVRangedColorSpace::BT601_Full: + return wr::YuvRangedColorSpace::Rec601Full; + case gfx::YUVRangedColorSpace::BT709_Narrow: + return wr::YuvRangedColorSpace::Rec709Narrow; + case gfx::YUVRangedColorSpace::BT709_Full: + return wr::YuvRangedColorSpace::Rec709Full; + case gfx::YUVRangedColorSpace::BT2020_Narrow: + return wr::YuvRangedColorSpace::Rec2020Narrow; + case gfx::YUVRangedColorSpace::BT2020_Full: + return wr::YuvRangedColorSpace::Rec2020Full; + case gfx::YUVRangedColorSpace::GbrIdentity: + break; + default: + MOZ_ASSERT_UNREACHABLE("Tried to convert invalid YUVColorSpace."); + break; + } + return wr::YuvRangedColorSpace::GbrIdentity; +} + +static inline wr::WrColorDepth ToWrColorDepth(gfx::ColorDepth aColorDepth) { + switch (aColorDepth) { + case gfx::ColorDepth::COLOR_8: + return wr::WrColorDepth::Color8; + case gfx::ColorDepth::COLOR_10: + return wr::WrColorDepth::Color10; + case gfx::ColorDepth::COLOR_12: + return wr::WrColorDepth::Color12; + case gfx::ColorDepth::COLOR_16: + return wr::WrColorDepth::Color16; + default: + MOZ_ASSERT_UNREACHABLE("Tried to convert invalid color depth value."); + } + return wr::WrColorDepth::Color8; +} + +static inline wr::WrColorRange ToWrColorRange(gfx::ColorRange aColorRange) { + switch (aColorRange) { + case gfx::ColorRange::LIMITED: + return wr::WrColorRange::Limited; + case gfx::ColorRange::FULL: + return wr::WrColorRange::Full; + default: + MOZ_ASSERT_UNREACHABLE("Tried to convert invalid color range value."); + return wr ::WrColorRange::Limited; + } +} + +static inline wr::SyntheticItalics DegreesToSyntheticItalics(float aDegrees) { + wr::SyntheticItalics synthetic_italics; + synthetic_italics.angle = + int16_t(std::min(std::max(aDegrees, -89.0f), 89.0f) * 256.0f); + return synthetic_italics; +} + +static inline wr::WindowSizeMode ToWrWindowSizeMode(nsSizeMode aSizeMode) { + switch (aSizeMode) { + case nsSizeMode_Normal: + return wr::WindowSizeMode::Normal; + case nsSizeMode_Minimized: + return wr::WindowSizeMode::Minimized; + case nsSizeMode_Maximized: + return wr::WindowSizeMode::Maximized; + case nsSizeMode_Fullscreen: + return wr::WindowSizeMode::Fullscreen; + default: + MOZ_ASSERT_UNREACHABLE("Tried to convert invalid size mode."); + return wr::WindowSizeMode::Invalid; + } +} + +static inline wr::APZScrollGeneration ToWrAPZScrollGeneration( + const mozilla::APZScrollGeneration& aGeneration) { + return wr::APZScrollGeneration(aGeneration.Raw()); +} + +static inline wr::HasScrollLinkedEffect ToWrHasScrollLinkedEffect( + bool aHasScrollLinkedEffect) { + return aHasScrollLinkedEffect ? wr::HasScrollLinkedEffect::Yes + : wr::HasScrollLinkedEffect::No; +} + +enum class ExternalImageSource : uint8_t { Unknown = 0, SharedSurfaces, Last }; + +} // namespace wr +} // namespace mozilla + +namespace std { +template <> +struct hash { + std::size_t operator()(mozilla::wr::WrSpatialId const& aKey) const noexcept { + return std::hash{}(aKey.id); + } +}; +} // namespace std + +#endif /* GFX_WEBRENDERTYPES_H */ diff --git a/gfx/webrender_bindings/cbindgen.toml b/gfx/webrender_bindings/cbindgen.toml new file mode 100644 index 0000000000..c11ddebe41 --- /dev/null +++ b/gfx/webrender_bindings/cbindgen.toml @@ -0,0 +1,55 @@ +header = """/* 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/. */""" +autogen_warning = """/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen. + * To generate this file: + * 1. Get the latest cbindgen using `cargo install --force cbindgen` + * a. Alternatively, you can clone `https://github.com/eqrion/cbindgen` and use a tagged release + * 2. Run `rustup run nightly cbindgen toolkit/library/rust/ --lockfile Cargo.lock --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h` + */""" +include_version = true +braces = "SameLine" +line_length = 100 +tab_width = 2 +language = "C++" +namespaces = ["mozilla", "wr"] + +[export] +item_types = ["globals", "enums", "structs", "unions", "typedefs", "opaque", "functions", "constants"] +include = ["POLYGON_CLIP_VERTEX_MAX"] + +[parse] +parse_deps = true +extra_bindings = ["webrender_api"] +include = ["log", "euclid", "webrender", "webrender_api"] + +[fn] +args = "Vertical" +rename_args = "GeckoCase" + +[struct] +associated_constants_in_body = true +derive_eq = true +derive_ostream = true + +[enum] +add_sentinel = true +derive_helper_methods = true +derive_ostream = true + +[macro_expansion] +bitflags = true + +[defines] +"target_os = windows" = "XP_WIN" +"target_os = macos" = "XP_MACOSX" +"target_os = android" = "ANDROID" + +[export.rename] +"ThinVec" = "nsTArray" + +[export.body] +"Box2D" = """ + inline T width() const { return max.x - min.x; } + inline T height() const { return max.y - min.y; } +""" diff --git a/gfx/webrender_bindings/moz.build b/gfx/webrender_bindings/moz.build new file mode 100644 index 0000000000..f17c77e4cb --- /dev/null +++ b/gfx/webrender_bindings/moz.build @@ -0,0 +1,137 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "Graphics: WebRender") + +EXPORTS.mozilla.webrender += [ + "RenderBufferTextureHost.h", + "RenderCompositor.h", + "RenderCompositorEGL.h", + "RenderCompositorLayersSWGL.h", + "RenderCompositorOGL.h", + "RenderCompositorOGLSWGL.h", + "RenderCompositorSWGL.h", + "RenderEGLImageTextureHost.h", + "RendererOGL.h", + "RendererScreenshotGrabber.h", + "RenderExternalTextureHost.h", + "RenderSharedSurfaceTextureHost.h", + "RenderTextureHost.h", + "RenderTextureHostSWGL.h", + "RenderTextureHostWrapper.h", + "RenderThread.h", + "webrender_ffi.h", + "WebRenderAPI.h", + "WebRenderTypes.h", +] + +UNIFIED_SOURCES += [ + "Moz2DImageRenderer.cpp", + "RenderBufferTextureHost.cpp", + "RenderCompositor.cpp", + "RenderCompositorEGL.cpp", + "RenderCompositorLayersSWGL.cpp", + "RenderCompositorOGL.cpp", + "RenderCompositorOGLSWGL.cpp", + "RenderCompositorSWGL.cpp", + "RenderEGLImageTextureHost.cpp", + "RendererOGL.cpp", + "RendererScreenshotGrabber.cpp", + "RenderExternalTextureHost.cpp", + "RenderSharedSurfaceTextureHost.cpp", + "RenderTextureHost.cpp", + "RenderTextureHostSWGL.cpp", + "RenderTextureHostWrapper.cpp", + "RenderThread.cpp", + "WebRenderAPI.cpp", + "WebRenderTypes.cpp", +] + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa": + EXPORTS.mozilla.webrender += [ + "RenderCompositorNative.h", + "RenderMacIOSurfaceTextureHost.h", + ] + UNIFIED_SOURCES += [ + "RenderCompositorNative.cpp", + "RenderMacIOSurfaceTextureHost.cpp", + ] + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android": + EXPORTS.mozilla.webrender += [ + "RenderAndroidHardwareBufferTextureHost.h", + "RenderAndroidSurfaceTextureHost.h", + ] + UNIFIED_SOURCES += [ + "RenderAndroidHardwareBufferTextureHost.cpp", + "RenderAndroidSurfaceTextureHost.cpp", + ] + +if CONFIG["MOZ_ENABLE_D3D10_LAYER"]: + DEFINES["MOZ_ENABLE_D3D10_LAYER"] = True + EXPORTS.mozilla.webrender += [ + "DCLayerTree.h", + "RenderCompositorANGLE.h", + "RenderCompositorD3D11SWGL.h", + "RenderD3D11TextureHost.h", + "RenderDcompSurfaceTextureHost.h", + ] + UNIFIED_SOURCES += [ + "DCLayerTree.cpp", + "RenderCompositorANGLE.cpp", + "RenderCompositorD3D11SWGL.cpp", + "RenderD3D11TextureHost.cpp", + ] + SOURCES += [ + "RenderDcompSurfaceTextureHost.cpp", + ] + +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk": + EXPORTS.mozilla.webrender += [ + "RenderDMABUFTextureHost.h", + ] + SOURCES += [ + "RenderDMABUFTextureHost.cpp", + ] + +if CONFIG["MOZ_WAYLAND"]: + EXPORTS.mozilla.webrender += [ + "RenderCompositorNative.h", + ] + SOURCES += [ + "RenderCompositorNative.cpp", + ] + +if CONFIG["MOZ_WIDGET_TOOLKIT"] in ("android", "gtk"): + CXXFLAGS += CONFIG["CAIRO_FT_CFLAGS"] + +if CONFIG["COMPILE_ENVIRONMENT"]: + EXPORTS.mozilla.webrender += [ + "!webrender_ffi_generated.h", + ] + + CbindgenHeader( + "webrender_ffi_generated.h", + inputs=[ + "/gfx/webrender_bindings", + "/gfx/wr/webrender", + "/gfx/wr/webrender_api", + ], + ) + + +include("/ipc/chromium/chromium-config.mozbuild") + +FINAL_LIBRARY = "xul" + +LOCAL_INCLUDES += [ + "/gfx/cairo/cairo/src", +] +if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk": + CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"] + +CXXFLAGS += ["-Werror=switch"] diff --git a/gfx/webrender_bindings/rustfmt.toml b/gfx/webrender_bindings/rustfmt.toml new file mode 100644 index 0000000000..1d15550e6c --- /dev/null +++ b/gfx/webrender_bindings/rustfmt.toml @@ -0,0 +1,16 @@ +ideal_width = 80 +max_width = 120 + +newline_style = "Unix" +normalize_comments = false + +force_explicit_abi = true +fn_args_density = "Vertical" + +chain_indent = "Visual" +chain_one_line_max = 90 + +struct_lit_multiline_style = "ForceMulti" + +match_block_trailing_comma = true +where_trailing_comma = true diff --git a/gfx/webrender_bindings/src/bindings.rs b/gfx/webrender_bindings/src/bindings.rs new file mode 100644 index 0000000000..1f3bca644a --- /dev/null +++ b/gfx/webrender_bindings/src/bindings.rs @@ -0,0 +1,4046 @@ +/* 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/. */ + +#![allow(clippy::missing_safety_doc)] +#![allow(clippy::not_unsafe_ptr_arg_deref)] + +use gleam::gl; +use std::cell::RefCell; +#[cfg(not(target_os = "macos"))] +use std::ffi::OsString; +use std::ffi::{CStr, CString}; +use std::io::Cursor; +use std::marker::PhantomData; +use std::ops::Range; +#[cfg(target_os = "android")] +use std::os::raw::c_int; +use std::os::raw::{c_char, c_float, c_void}; +#[cfg(not(any(target_os = "macos", target_os = "windows")))] +use std::os::unix::ffi::OsStringExt; +#[cfg(target_os = "windows")] +use std::os::windows::ffi::OsStringExt; +use std::path::PathBuf; +use std::rc::Rc; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; +use std::time::Duration; +use std::{env, mem, ptr, slice}; +use thin_vec::ThinVec; + +use euclid::SideOffsets2D; +use moz2d_renderer::Moz2dBlobImageHandler; +use nsstring::nsAString; +use num_cpus; +use program_cache::{remove_disk_cache, WrProgramCache}; +use rayon; +use tracy_rs::register_thread_with_profiler; +use webrender::sw_compositor::SwCompositor; +use webrender::{ + api::units::*, api::*, create_webrender_instance, render_api::*, set_profiler_hooks, AsyncPropertySampler, + AsyncScreenshotHandle, Compositor, CompositorCapabilities, CompositorConfig, CompositorSurfaceTransform, + DebugFlags, Device, MappableCompositor, MappedTileInfo, NativeSurfaceId, NativeSurfaceInfo, NativeTileId, + PartialPresentCompositor, PipelineInfo, ProfilerHooks, RecordedFrameHandle, Renderer, RendererStats, + SWGLCompositeSurfaceInfo, SceneBuilderHooks, ShaderPrecacheFlags, Shaders, SharedShaders, TextureCacheConfig, + UploadMethod, WebRenderOptions, WindowVisibility, ONE_TIME_USAGE_HINT, +}; +use wr_malloc_size_of::MallocSizeOfOps; + +extern "C" { + #[cfg(target_os = "android")] + fn __android_log_write(prio: c_int, tag: *const c_char, text: *const c_char) -> c_int; +} + +/// The unique id for WR resource identification. +static NEXT_NAMESPACE_ID: AtomicUsize = AtomicUsize::new(1); + +/// Special value handled in this wrapper layer to signify a redundant clip chain. +pub const ROOT_CLIP_CHAIN: u64 = !0; + +fn next_namespace_id() -> IdNamespace { + IdNamespace(NEXT_NAMESPACE_ID.fetch_add(1, Ordering::Relaxed) as u32) +} + +/// Whether a border should be antialiased. +#[repr(C)] +#[derive(Eq, PartialEq, Copy, Clone)] +pub enum AntialiasBorder { + No = 0, + Yes, +} + +/// Used to indicate if an image is opaque, or has an alpha channel. +#[repr(u8)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum OpacityType { + Opaque = 0, + HasAlphaChannel = 1, +} + +/// cbindgen:field-names=[mHandle] +/// cbindgen:derive-lt=true +/// cbindgen:derive-lte=true +/// cbindgen:derive-neq=true +type WrEpoch = Epoch; +/// cbindgen:field-names=[mHandle] +/// cbindgen:derive-lt=true +/// cbindgen:derive-lte=true +/// cbindgen:derive-neq=true +pub type WrIdNamespace = IdNamespace; + +/// cbindgen:field-names=[mNamespace, mHandle] +type WrDocumentId = DocumentId; +/// cbindgen:field-names=[mNamespace, mHandle] +type WrPipelineId = PipelineId; +/// cbindgen:field-names=[mNamespace, mHandle] +/// cbindgen:derive-neq=true +type WrImageKey = ImageKey; +/// cbindgen:field-names=[mNamespace, mHandle] +pub type WrFontKey = FontKey; +/// cbindgen:field-names=[mNamespace, mHandle] +pub type WrFontInstanceKey = FontInstanceKey; +/// cbindgen:field-names=[mNamespace, mHandle] +type WrYuvColorSpace = YuvColorSpace; +/// cbindgen:field-names=[mNamespace, mHandle] +type WrColorDepth = ColorDepth; +/// cbindgen:field-names=[mNamespace, mHandle] +type WrColorRange = ColorRange; + +#[inline] +fn clip_chain_id_to_webrender(id: u64, pipeline_id: WrPipelineId) -> ClipChainId { + if id == ROOT_CLIP_CHAIN { + ClipChainId::INVALID + } else { + ClipChainId(id, pipeline_id) + } +} + +#[repr(C)] +pub struct WrSpaceAndClipChain { + space: WrSpatialId, + clip_chain: u64, +} + +impl WrSpaceAndClipChain { + fn to_webrender(&self, pipeline_id: WrPipelineId) -> SpaceAndClipInfo { + //Warning: special case here to support dummy clip chain + SpaceAndClipInfo { + spatial_id: self.space.to_webrender(pipeline_id), + clip_chain_id: clip_chain_id_to_webrender(self.clip_chain, pipeline_id), + } + } +} + +#[repr(C)] +pub enum WrStackingContextClip { + None, + ClipChain(u64), +} + +impl WrStackingContextClip { + fn to_webrender(&self, pipeline_id: WrPipelineId) -> Option { + match *self { + WrStackingContextClip::None => None, + WrStackingContextClip::ClipChain(id) => { + if id == ROOT_CLIP_CHAIN { + None + } else { + Some(ClipChainId(id, pipeline_id)) + } + }, + } + } +} + +unsafe fn make_slice<'a, T>(ptr: *const T, len: usize) -> &'a [T] { + if ptr.is_null() { + &[] + } else { + slice::from_raw_parts(ptr, len) + } +} + +unsafe fn make_slice_mut<'a, T>(ptr: *mut T, len: usize) -> &'a mut [T] { + if ptr.is_null() { + &mut [] + } else { + slice::from_raw_parts_mut(ptr, len) + } +} + +pub struct DocumentHandle { + api: RenderApi, + document_id: DocumentId, + // One of the two options below is Some and the other None at all times. + // It would be nice to model with an enum, however it is tricky to express + // moving a variant's content into another variant without moving the + // containing enum. + hit_tester_request: Option, + hit_tester: Option>, +} + +impl DocumentHandle { + pub fn new( + api: RenderApi, + hit_tester: Option>, + size: DeviceIntSize, + id: u32, + ) -> DocumentHandle { + let doc = api.add_document_with_id(size, id); + let hit_tester_request = if hit_tester.is_none() { + // Request the hit tester early to reduce the likelihood of blocking on the + // first hit testing query. + Some(api.request_hit_tester(doc)) + } else { + None + }; + + DocumentHandle { + api, + document_id: doc, + hit_tester_request, + hit_tester, + } + } + + fn ensure_hit_tester(&mut self) -> &Arc { + if let Some(ref ht) = self.hit_tester { + return ht; + } + self.hit_tester = Some(self.hit_tester_request.take().unwrap().resolve()); + self.hit_tester.as_ref().unwrap() + } +} + +#[repr(C)] +pub struct WrVecU8 { + data: *mut u8, + length: usize, + capacity: usize, +} + +impl WrVecU8 { + fn into_vec(self) -> Vec { + unsafe { Vec::from_raw_parts(self.data, self.length, self.capacity) } + } + + // Equivalent to `into_vec` but clears self instead of consuming the value. + fn flush_into_vec(&mut self) -> Vec { + self.convert_into_vec::() + } + + // Like flush_into_vec, but also does an unsafe conversion to the desired type. + fn convert_into_vec(&mut self) -> Vec { + let vec = unsafe { + Vec::from_raw_parts( + self.data as *mut T, + self.length / mem::size_of::(), + self.capacity / mem::size_of::(), + ) + }; + self.data = ptr::null_mut(); + self.length = 0; + self.capacity = 0; + vec + } + + fn from_vec(mut v: Vec) -> WrVecU8 { + let w = WrVecU8 { + data: v.as_mut_ptr(), + length: v.len(), + capacity: v.capacity(), + }; + mem::forget(v); + w + } + + fn reserve(&mut self, len: usize) { + let mut vec = self.flush_into_vec(); + vec.reserve(len); + *self = Self::from_vec(vec); + } + + fn push_bytes(&mut self, bytes: &[u8]) { + let mut vec = self.flush_into_vec(); + vec.extend_from_slice(bytes); + *self = Self::from_vec(vec); + } +} + +#[no_mangle] +pub extern "C" fn wr_vec_u8_push_bytes(v: &mut WrVecU8, bytes: ByteSlice) { + v.push_bytes(bytes.as_slice()); +} + +#[no_mangle] +pub extern "C" fn wr_vec_u8_reserve(v: &mut WrVecU8, len: usize) { + v.reserve(len); +} + +#[no_mangle] +pub extern "C" fn wr_vec_u8_free(v: WrVecU8) { + v.into_vec(); +} + +#[repr(C)] +pub struct ByteSlice<'a> { + buffer: *const u8, + len: usize, + _phantom: PhantomData<&'a ()>, +} + +impl<'a> ByteSlice<'a> { + pub fn new(slice: &'a [u8]) -> ByteSlice<'a> { + ByteSlice { + buffer: slice.as_ptr(), + len: slice.len(), + _phantom: PhantomData, + } + } + + pub fn as_slice(&self) -> &'a [u8] { + unsafe { make_slice(self.buffer, self.len) } + } +} + +#[repr(C)] +pub struct MutByteSlice<'a> { + buffer: *mut u8, + len: usize, + _phantom: PhantomData<&'a ()>, +} + +impl<'a> MutByteSlice<'a> { + pub fn new(slice: &'a mut [u8]) -> MutByteSlice<'a> { + let len = slice.len(); + MutByteSlice { + buffer: slice.as_mut_ptr(), + len, + _phantom: PhantomData, + } + } + + pub fn as_mut_slice(&mut self) -> &'a mut [u8] { + unsafe { make_slice_mut(self.buffer, self.len) } + } +} + +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub struct WrImageDescriptor { + pub format: ImageFormat, + pub width: i32, + pub height: i32, + pub stride: i32, + pub opacity: OpacityType, + // TODO(gw): Remove this flag (use prim flags instead). + pub prefer_compositor_surface: bool, +} + +impl<'a> From<&'a WrImageDescriptor> for ImageDescriptor { + fn from(desc: &'a WrImageDescriptor) -> ImageDescriptor { + let mut flags = ImageDescriptorFlags::empty(); + + if desc.opacity == OpacityType::Opaque { + flags |= ImageDescriptorFlags::IS_OPAQUE; + } + + ImageDescriptor { + size: DeviceIntSize::new(desc.width, desc.height), + stride: if desc.stride != 0 { Some(desc.stride) } else { None }, + format: desc.format, + offset: 0, + flags, + } + } +} + +#[repr(u32)] +#[allow(dead_code)] +enum WrExternalImageType { + RawData, + NativeTexture, + Invalid, +} + +#[repr(C)] +struct WrExternalImage { + image_type: WrExternalImageType, + + // external texture handle + handle: u32, + // external texture coordinate + u0: f32, + v0: f32, + u1: f32, + v1: f32, + + // external image buffer + buff: *const u8, + size: usize, +} + +extern "C" { + fn wr_renderer_lock_external_image( + renderer: *mut c_void, + external_image_id: ExternalImageId, + channel_index: u8, + ) -> WrExternalImage; + fn wr_renderer_unlock_external_image(renderer: *mut c_void, external_image_id: ExternalImageId, channel_index: u8); +} + +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct WrExternalImageHandler { + external_image_obj: *mut c_void, +} + +impl ExternalImageHandler for WrExternalImageHandler { + fn lock(&mut self, id: ExternalImageId, channel_index: u8) -> ExternalImage { + let image = unsafe { wr_renderer_lock_external_image(self.external_image_obj, id, channel_index) }; + ExternalImage { + uv: TexelRect::new(image.u0, image.v0, image.u1, image.v1), + source: match image.image_type { + WrExternalImageType::NativeTexture => ExternalImageSource::NativeTexture(image.handle), + WrExternalImageType::RawData => { + ExternalImageSource::RawData(unsafe { make_slice(image.buff, image.size) }) + }, + WrExternalImageType::Invalid => ExternalImageSource::Invalid, + }, + } + } + + fn unlock(&mut self, id: ExternalImageId, channel_index: u8) { + unsafe { + wr_renderer_unlock_external_image(self.external_image_obj, id, channel_index); + } + } +} + +#[repr(C)] +#[derive(Clone, Copy)] +// Used for ComponentTransfer only +pub struct WrFilterData { + funcR_type: ComponentTransferFuncType, + R_values: *mut c_float, + R_values_count: usize, + funcG_type: ComponentTransferFuncType, + G_values: *mut c_float, + G_values_count: usize, + funcB_type: ComponentTransferFuncType, + B_values: *mut c_float, + B_values_count: usize, + funcA_type: ComponentTransferFuncType, + A_values: *mut c_float, + A_values_count: usize, +} + +#[repr(u32)] +#[derive(Debug)] +pub enum WrAnimationType { + Transform = 0, + Opacity = 1, + BackgroundColor = 2, +} + +#[repr(C)] +pub struct WrAnimationProperty { + effect_type: WrAnimationType, + id: u64, + key: SpatialTreeItemKey, +} + +/// cbindgen:derive-eq=false +#[repr(C)] +#[derive(Debug)] +pub struct WrAnimationPropertyValue { + pub id: u64, + pub value: T, +} + +pub type WrTransformProperty = WrAnimationPropertyValue; +pub type WrOpacityProperty = WrAnimationPropertyValue; +pub type WrColorProperty = WrAnimationPropertyValue; + +/// cbindgen:field-names=[mHandle] +/// cbindgen:derive-lt=true +/// cbindgen:derive-lte=true +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub struct WrWindowId(u64); + +#[repr(C)] +#[derive(Debug)] +pub struct WrComputedTransformData { + pub scale_from: LayoutSize, + pub vertical_flip: bool, + pub rotation: WrRotation, + pub key: SpatialTreeItemKey, +} + +#[repr(C)] +pub struct WrTransformInfo { + pub transform: LayoutTransform, + pub key: SpatialTreeItemKey, +} + +fn get_proc_address(glcontext_ptr: *mut c_void, name: &str) -> *const c_void { + extern "C" { + fn get_proc_address_from_glcontext(glcontext_ptr: *mut c_void, procname: *const c_char) -> *const c_void; + } + + let symbol_name = CString::new(name).unwrap(); + let symbol = unsafe { get_proc_address_from_glcontext(glcontext_ptr, symbol_name.as_ptr()) }; + symbol as *const _ +} + +#[repr(C)] +pub enum TelemetryProbe { + SceneBuildTime = 0, + SceneSwapTime = 1, + FrameBuildTime = 2, +} + +extern "C" { + fn is_in_compositor_thread() -> bool; + fn is_in_render_thread() -> bool; + fn is_in_main_thread() -> bool; + fn is_glcontext_gles(glcontext_ptr: *mut c_void) -> bool; + fn is_glcontext_angle(glcontext_ptr: *mut c_void) -> bool; + fn gfx_wr_resource_path_override() -> *const c_char; + fn gfx_wr_use_optimized_shaders() -> bool; + // TODO: make gfx_critical_error() work. + // We still have problem to pass the error message from render/render_backend + // thread to main thread now. + #[allow(dead_code)] + fn gfx_critical_error(msg: *const c_char); + fn gfx_critical_note(msg: *const c_char); + fn gfx_wr_set_crash_annotation(annotation: CrashAnnotation, value: *const c_char); + fn gfx_wr_clear_crash_annotation(annotation: CrashAnnotation); +} + +struct CppNotifier { + window_id: WrWindowId, +} + +unsafe impl Send for CppNotifier {} + +extern "C" { + fn wr_notifier_wake_up(window_id: WrWindowId, composite_needed: bool); + fn wr_notifier_new_frame_ready(window_id: WrWindowId, composite_needed: bool, publish_id: FramePublishId); + fn wr_notifier_external_event(window_id: WrWindowId, raw_event: usize); + fn wr_schedule_render(window_id: WrWindowId, reasons: RenderReasons); + // NOTE: This moves away from pipeline_info. + fn wr_finished_scene_build(window_id: WrWindowId, pipeline_info: &mut WrPipelineInfo); + + fn wr_transaction_notification_notified(handler: usize, when: Checkpoint); +} + +impl RenderNotifier for CppNotifier { + fn clone(&self) -> Box { + Box::new(CppNotifier { + window_id: self.window_id, + }) + } + + fn wake_up(&self, composite_needed: bool) { + unsafe { + wr_notifier_wake_up(self.window_id, composite_needed); + } + } + + fn new_frame_ready(&self, _: DocumentId, _scrolled: bool, composite_needed: bool, publish_id: FramePublishId) { + unsafe { + wr_notifier_new_frame_ready(self.window_id, composite_needed, publish_id); + } + } + + fn external_event(&self, event: ExternalEvent) { + unsafe { + wr_notifier_external_event(self.window_id, event.unwrap()); + } + } +} + +struct MozCrashAnnotator; + +unsafe impl Send for MozCrashAnnotator {} + +impl CrashAnnotator for MozCrashAnnotator { + fn set(&self, annotation: CrashAnnotation, value: &std::ffi::CStr) { + unsafe { + gfx_wr_set_crash_annotation(annotation, value.as_ptr()); + } + } + + fn clear(&self, annotation: CrashAnnotation) { + unsafe { + gfx_wr_clear_crash_annotation(annotation); + } + } + + fn box_clone(&self) -> Box { + Box::new(MozCrashAnnotator) + } +} + +#[no_mangle] +pub extern "C" fn wr_renderer_set_clear_color(renderer: &mut Renderer, color: ColorF) { + renderer.set_clear_color(color); +} + +#[no_mangle] +pub extern "C" fn wr_renderer_set_external_image_handler( + renderer: &mut Renderer, + external_image_handler: &mut WrExternalImageHandler, +) { + renderer.set_external_image_handler(Box::new(*external_image_handler)); +} + +#[no_mangle] +pub extern "C" fn wr_renderer_update(renderer: &mut Renderer) { + renderer.update(); +} + +#[no_mangle] +pub extern "C" fn wr_renderer_set_target_frame_publish_id(renderer: &mut Renderer, publish_id: FramePublishId) { + renderer.set_target_frame_publish_id(publish_id); +} + +#[no_mangle] +pub extern "C" fn wr_renderer_render( + renderer: &mut Renderer, + width: i32, + height: i32, + buffer_age: usize, + out_stats: &mut RendererStats, + out_dirty_rects: &mut ThinVec, +) -> bool { + match renderer.render(DeviceIntSize::new(width, height), buffer_age) { + Ok(results) => { + *out_stats = results.stats; + out_dirty_rects.extend(results.dirty_rects); + true + }, + Err(errors) => { + for e in errors { + warn!(" Failed to render: {:?}", e); + let msg = CString::new(format!("wr_renderer_render: {:?}", e)).unwrap(); + unsafe { + gfx_critical_note(msg.as_ptr()); + } + } + false + }, + } +} + +#[no_mangle] +pub extern "C" fn wr_renderer_force_redraw(renderer: &mut Renderer) { + renderer.force_redraw(); +} + +#[no_mangle] +pub extern "C" fn wr_renderer_record_frame( + renderer: &mut Renderer, + image_format: ImageFormat, + out_handle: &mut RecordedFrameHandle, + out_width: &mut i32, + out_height: &mut i32, +) -> bool { + if let Some((handle, size)) = renderer.record_frame(image_format) { + *out_handle = handle; + *out_width = size.width; + *out_height = size.height; + + true + } else { + false + } +} + +#[no_mangle] +pub extern "C" fn wr_renderer_map_recorded_frame( + renderer: &mut Renderer, + handle: RecordedFrameHandle, + dst_buffer: *mut u8, + dst_buffer_len: usize, + dst_stride: usize, +) -> bool { + renderer.map_recorded_frame( + handle, + unsafe { make_slice_mut(dst_buffer, dst_buffer_len) }, + dst_stride, + ) +} + +#[no_mangle] +pub extern "C" fn wr_renderer_release_composition_recorder_structures(renderer: &mut Renderer) { + renderer.release_composition_recorder_structures(); +} + +#[no_mangle] +pub extern "C" fn wr_renderer_get_screenshot_async( + renderer: &mut Renderer, + window_x: i32, + window_y: i32, + window_width: i32, + window_height: i32, + buffer_width: i32, + buffer_height: i32, + image_format: ImageFormat, + screenshot_width: *mut i32, + screenshot_height: *mut i32, +) -> AsyncScreenshotHandle { + assert!(!screenshot_width.is_null()); + assert!(!screenshot_height.is_null()); + + let (handle, size) = renderer.get_screenshot_async( + DeviceIntRect::from_origin_and_size( + DeviceIntPoint::new(window_x, window_y), + DeviceIntSize::new(window_width, window_height), + ), + DeviceIntSize::new(buffer_width, buffer_height), + image_format, + ); + + unsafe { + *screenshot_width = size.width; + *screenshot_height = size.height; + } + + handle +} + +#[no_mangle] +pub extern "C" fn wr_renderer_map_and_recycle_screenshot( + renderer: &mut Renderer, + handle: AsyncScreenshotHandle, + dst_buffer: *mut u8, + dst_buffer_len: usize, + dst_stride: usize, +) -> bool { + renderer.map_and_recycle_screenshot( + handle, + unsafe { make_slice_mut(dst_buffer, dst_buffer_len) }, + dst_stride, + ) +} + +#[no_mangle] +pub extern "C" fn wr_renderer_release_profiler_structures(renderer: &mut Renderer) { + renderer.release_profiler_structures(); +} + +// Call wr_renderer_render() before calling this function. +#[no_mangle] +pub unsafe extern "C" fn wr_renderer_readback( + renderer: &mut Renderer, + width: i32, + height: i32, + format: ImageFormat, + dst_buffer: *mut u8, + buffer_size: usize, +) { + assert!(is_in_render_thread()); + + let mut slice = make_slice_mut(dst_buffer, buffer_size); + renderer.read_pixels_into(FramebufferIntSize::new(width, height).into(), format, &mut slice); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_renderer_set_profiler_ui(renderer: &mut Renderer, ui_str: *const u8, ui_str_len: usize) { + let slice = std::slice::from_raw_parts(ui_str, ui_str_len); + if let Ok(ui_str) = std::str::from_utf8(slice) { + renderer.set_profiler_ui(ui_str); + } +} + +#[no_mangle] +pub unsafe extern "C" fn wr_renderer_delete(renderer: *mut Renderer) { + let renderer = Box::from_raw(renderer); + renderer.deinit(); + // let renderer go out of scope and get dropped +} + +#[no_mangle] +pub unsafe extern "C" fn wr_renderer_accumulate_memory_report( + renderer: &mut Renderer, + report: &mut MemoryReport, + swgl: *mut c_void, +) { + *report += renderer.report_memory(swgl); +} + +// cbindgen doesn't support tuples, so we have a little struct instead, with +// an Into implementation to convert from the tuple to the struct. +#[repr(C)] +pub struct WrPipelineEpoch { + pipeline_id: WrPipelineId, + document_id: WrDocumentId, + epoch: WrEpoch, +} + +impl<'a> From<(&'a (WrPipelineId, WrDocumentId), &'a WrEpoch)> for WrPipelineEpoch { + fn from(tuple: (&(WrPipelineId, WrDocumentId), &WrEpoch)) -> WrPipelineEpoch { + WrPipelineEpoch { + pipeline_id: (tuple.0).0, + document_id: (tuple.0).1, + epoch: *tuple.1, + } + } +} + +#[repr(C)] +pub struct WrPipelineIdAndEpoch { + pipeline_id: WrPipelineId, + epoch: WrEpoch, +} + +impl<'a> From<(&WrPipelineId, &WrEpoch)> for WrPipelineIdAndEpoch { + fn from(tuple: (&WrPipelineId, &WrEpoch)) -> WrPipelineIdAndEpoch { + WrPipelineIdAndEpoch { + pipeline_id: *tuple.0, + epoch: *tuple.1, + } + } +} + +#[repr(C)] +pub struct WrRemovedPipeline { + pipeline_id: WrPipelineId, + document_id: WrDocumentId, +} + +impl<'a> From<&'a (WrPipelineId, WrDocumentId)> for WrRemovedPipeline { + fn from(tuple: &(WrPipelineId, WrDocumentId)) -> WrRemovedPipeline { + WrRemovedPipeline { + pipeline_id: tuple.0, + document_id: tuple.1, + } + } +} + +#[repr(C)] +pub struct WrPipelineInfo { + /// This contains an entry for each pipeline that was rendered, along with + /// the epoch at which it was rendered. Rendered pipelines include the root + /// pipeline and any other pipelines that were reachable via IFrame display + /// items from the root pipeline. + epochs: ThinVec, + /// This contains an entry for each pipeline that was removed during the + /// last transaction. These pipelines would have been explicitly removed by + /// calling remove_pipeline on the transaction object; the pipeline showing + /// up in this array means that the data structures have been torn down on + /// the webrender side, and so any remaining data structures on the caller + /// side can now be torn down also. + removed_pipelines: ThinVec, +} + +impl WrPipelineInfo { + fn new(info: &PipelineInfo) -> Self { + WrPipelineInfo { + epochs: info.epochs.iter().map(WrPipelineEpoch::from).collect(), + removed_pipelines: info.removed_pipelines.iter().map(WrRemovedPipeline::from).collect(), + } + } +} + +#[no_mangle] +pub unsafe extern "C" fn wr_renderer_flush_pipeline_info(renderer: &mut Renderer, out: &mut WrPipelineInfo) { + let info = renderer.flush_pipeline_info(); + *out = WrPipelineInfo::new(&info); +} + +extern "C" { + pub fn gecko_profiler_thread_is_being_profiled() -> bool; +} + +pub fn gecko_profiler_start_marker(name: &str) { + use gecko_profiler::{gecko_profiler_category, MarkerOptions, MarkerTiming, ProfilerTime, Tracing}; + gecko_profiler::add_marker( + name, + gecko_profiler_category!(Graphics), + MarkerOptions { + timing: MarkerTiming::interval_start(ProfilerTime::now()), + ..Default::default() + }, + Tracing("Webrender".to_string()), + ); +} +pub fn gecko_profiler_end_marker(name: &str) { + use gecko_profiler::{gecko_profiler_category, MarkerOptions, MarkerTiming, ProfilerTime, Tracing}; + gecko_profiler::add_marker( + name, + gecko_profiler_category!(Graphics), + MarkerOptions { + timing: MarkerTiming::interval_end(ProfilerTime::now()), + ..Default::default() + }, + Tracing("Webrender".to_string()), + ); +} + +pub fn gecko_profiler_event_marker(name: &str) { + use gecko_profiler::{gecko_profiler_category, Tracing}; + gecko_profiler::add_marker( + name, + gecko_profiler_category!(Graphics), + Default::default(), + Tracing("Webrender".to_string()), + ); +} + +pub fn gecko_profiler_add_text_marker(name: &str, text: &str, microseconds: f64) { + use gecko_profiler::{gecko_profiler_category, MarkerOptions, MarkerTiming, ProfilerTime}; + if !gecko_profiler::can_accept_markers() { + return; + } + + let now = ProfilerTime::now(); + let start = now.clone().subtract_microseconds(microseconds); + gecko_profiler::add_text_marker( + name, + gecko_profiler_category!(Graphics), + MarkerOptions { + timing: MarkerTiming::interval(start, now), + ..Default::default() + }, + text, + ); +} + +/// Simple implementation of the WR ProfilerHooks trait to allow profile +/// markers to be seen in the Gecko profiler. +struct GeckoProfilerHooks; + +impl ProfilerHooks for GeckoProfilerHooks { + fn register_thread(&self, thread_name: &str) { + gecko_profiler::register_thread(thread_name); + } + + fn unregister_thread(&self) { + gecko_profiler::unregister_thread(); + } + + fn begin_marker(&self, label: &str) { + gecko_profiler_start_marker(label); + } + + fn end_marker(&self, label: &str) { + gecko_profiler_end_marker(label); + } + + fn event_marker(&self, label: &str) { + gecko_profiler_event_marker(label); + } + + fn add_text_marker(&self, label: &str, text: &str, duration: Duration) { + let micros = duration.as_micros() as f64; + gecko_profiler_add_text_marker(label, text, micros); + } + + fn thread_is_being_profiled(&self) -> bool { + unsafe { gecko_profiler_thread_is_being_profiled() } + } +} + +static PROFILER_HOOKS: GeckoProfilerHooks = GeckoProfilerHooks {}; + +#[allow(improper_ctypes)] // this is needed so that rustc doesn't complain about passing the &mut Transaction to an extern function +extern "C" { + // These callbacks are invoked from the scene builder thread (aka the APZ + // updater thread) + fn apz_register_updater(window_id: WrWindowId); + fn apz_pre_scene_swap(window_id: WrWindowId); + fn apz_post_scene_swap(window_id: WrWindowId, pipeline_info: &WrPipelineInfo); + fn apz_run_updater(window_id: WrWindowId); + fn apz_deregister_updater(window_id: WrWindowId); + + // These callbacks are invoked from the render backend thread (aka the APZ + // sampler thread) + fn apz_register_sampler(window_id: WrWindowId); + fn apz_sample_transforms(window_id: WrWindowId, generated_frame_id: *const u64, transaction: &mut Transaction); + fn apz_deregister_sampler(window_id: WrWindowId); + + fn omta_register_sampler(window_id: WrWindowId); + fn omta_sample(window_id: WrWindowId, transaction: &mut Transaction); + fn omta_deregister_sampler(window_id: WrWindowId); +} + +struct APZCallbacks { + window_id: WrWindowId, +} + +impl APZCallbacks { + pub fn new(window_id: WrWindowId) -> Self { + APZCallbacks { window_id } + } +} + +impl SceneBuilderHooks for APZCallbacks { + fn register(&self) { + unsafe { apz_register_updater(self.window_id) } + } + + fn pre_scene_build(&self) { + gecko_profiler_start_marker("SceneBuilding"); + } + + fn pre_scene_swap(&self) { + unsafe { + apz_pre_scene_swap(self.window_id); + } + } + + fn post_scene_swap(&self, _document_ids: &Vec, info: PipelineInfo) { + let mut info = WrPipelineInfo::new(&info); + unsafe { + apz_post_scene_swap(self.window_id, &info); + } + + // After a scene swap we should schedule a render for the next vsync, + // otherwise there's no guarantee that the new scene will get rendered + // anytime soon + unsafe { wr_finished_scene_build(self.window_id, &mut info) } + gecko_profiler_end_marker("SceneBuilding"); + } + + fn post_resource_update(&self, _document_ids: &Vec) { + unsafe { wr_schedule_render(self.window_id, RenderReasons::POST_RESOURCE_UPDATES_HOOK) } + gecko_profiler_end_marker("SceneBuilding"); + } + + fn post_empty_scene_build(&self) { + gecko_profiler_end_marker("SceneBuilding"); + } + + fn poke(&self) { + unsafe { apz_run_updater(self.window_id) } + } + + fn deregister(&self) { + unsafe { apz_deregister_updater(self.window_id) } + } +} + +struct SamplerCallback { + window_id: WrWindowId, +} + +impl SamplerCallback { + pub fn new(window_id: WrWindowId) -> Self { + SamplerCallback { window_id } + } +} + +impl AsyncPropertySampler for SamplerCallback { + fn register(&self) { + unsafe { + apz_register_sampler(self.window_id); + omta_register_sampler(self.window_id); + } + } + + fn sample(&self, _document_id: DocumentId, generated_frame_id: Option) -> Vec { + let generated_frame_id_value; + let generated_frame_id: *const u64 = match generated_frame_id { + Some(id) => { + generated_frame_id_value = id; + &generated_frame_id_value + }, + None => ptr::null_mut(), + }; + let mut transaction = Transaction::new(); + // Reset the pending properties first because omta_sample and apz_sample_transforms + // may be failed to reset them due to null samplers. + transaction.reset_dynamic_properties(); + unsafe { + apz_sample_transforms(self.window_id, generated_frame_id, &mut transaction); + omta_sample(self.window_id, &mut transaction); + }; + transaction.get_frame_ops() + } + + fn deregister(&self) { + unsafe { + apz_deregister_sampler(self.window_id); + omta_deregister_sampler(self.window_id); + } + } +} + +extern "C" { + fn wr_register_thread_local_arena(); +} + +pub struct WrThreadPool(Arc); + +#[no_mangle] +pub extern "C" fn wr_thread_pool_new(low_priority: bool) -> *mut WrThreadPool { + // Clamp the number of workers between 1 and 4/8. We get diminishing returns + // with high worker counts and extra overhead because of rayon and font + // management. + + // We clamp to 4 high priority threads because contention and memory usage + // make it not worth going higher + let max = if low_priority { 8 } else { 4 }; + let num_threads = num_cpus::get().min(max); + + let priority_tag = if low_priority { "LP" } else { "" }; + + let worker = rayon::ThreadPoolBuilder::new() + .thread_name(move |idx| format!("WRWorker{}#{}", priority_tag, idx)) + .num_threads(num_threads) + .start_handler(move |idx| { + unsafe { + wr_register_thread_local_arena(); + } + let name = format!("WRWorker{}#{}", priority_tag, idx); + register_thread_with_profiler(name.clone()); + gecko_profiler::register_thread(&name); + }) + .exit_handler(|_idx| { + gecko_profiler::unregister_thread(); + }) + .build(); + + let workers = Arc::new(worker.unwrap()); + + Box::into_raw(Box::new(WrThreadPool(workers))) +} + +#[no_mangle] +pub unsafe extern "C" fn wr_thread_pool_delete(thread_pool: *mut WrThreadPool) { + mem::drop(Box::from_raw(thread_pool)); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_program_cache_new( + prof_path: &nsAString, + thread_pool: *mut WrThreadPool, +) -> *mut WrProgramCache { + let workers = &(*thread_pool).0; + let program_cache = WrProgramCache::new(prof_path, workers); + Box::into_raw(Box::new(program_cache)) +} + +#[no_mangle] +pub unsafe extern "C" fn wr_program_cache_delete(program_cache: *mut WrProgramCache) { + mem::drop(Box::from_raw(program_cache)); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_try_load_startup_shaders_from_disk(program_cache: *mut WrProgramCache) { + (*program_cache).try_load_startup_shaders_from_disk(); +} + +#[no_mangle] +pub unsafe extern "C" fn remove_program_binary_disk_cache(prof_path: &nsAString) -> bool { + match remove_disk_cache(prof_path) { + Ok(_) => true, + Err(_) => { + error!("Failed to remove program binary disk cache"); + false + }, + } +} + +// This matches IsEnvSet in gfxEnv.h +fn env_var_to_bool(key: &'static str) -> bool { + env::var(key).ok().map_or(false, |v| !v.is_empty()) +} + +// Call MakeCurrent before this. +fn wr_device_new(gl_context: *mut c_void, pc: Option<&mut WrProgramCache>) -> Device { + assert!(unsafe { is_in_render_thread() }); + + let gl; + if unsafe { is_glcontext_gles(gl_context) } { + gl = unsafe { gl::GlesFns::load_with(|symbol| get_proc_address(gl_context, symbol)) }; + } else { + gl = unsafe { gl::GlFns::load_with(|symbol| get_proc_address(gl_context, symbol)) }; + } + + let version = gl.get_string(gl::VERSION); + + info!("WebRender - OpenGL version new {}", version); + + let upload_method = if unsafe { is_glcontext_angle(gl_context) } { + UploadMethod::Immediate + } else { + UploadMethod::PixelBuffer(ONE_TIME_USAGE_HINT) + }; + + let resource_override_path = unsafe { + let override_charptr = gfx_wr_resource_path_override(); + if override_charptr.is_null() { + None + } else { + match CStr::from_ptr(override_charptr).to_str() { + Ok(override_str) => Some(PathBuf::from(override_str)), + _ => None, + } + } + }; + + let use_optimized_shaders = unsafe { gfx_wr_use_optimized_shaders() }; + + let cached_programs = pc.map(|cached_programs| Rc::clone(cached_programs.rc_get())); + + Device::new( + gl, + Some(Box::new(MozCrashAnnotator)), + resource_override_path, + use_optimized_shaders, + upload_method, + 512 * 512, + cached_programs, + true, + true, + None, + false, + false, + ) +} + +extern "C" { + fn wr_compositor_create_surface( + compositor: *mut c_void, + id: NativeSurfaceId, + virtual_offset: DeviceIntPoint, + tile_size: DeviceIntSize, + is_opaque: bool, + ); + fn wr_compositor_create_external_surface(compositor: *mut c_void, id: NativeSurfaceId, is_opaque: bool); + fn wr_compositor_create_backdrop_surface(compositor: *mut c_void, id: NativeSurfaceId, color: ColorF); + fn wr_compositor_destroy_surface(compositor: *mut c_void, id: NativeSurfaceId); + fn wr_compositor_create_tile(compositor: *mut c_void, id: NativeSurfaceId, x: i32, y: i32); + fn wr_compositor_destroy_tile(compositor: *mut c_void, id: NativeSurfaceId, x: i32, y: i32); + fn wr_compositor_attach_external_image( + compositor: *mut c_void, + id: NativeSurfaceId, + external_image: ExternalImageId, + ); + fn wr_compositor_bind( + compositor: *mut c_void, + id: NativeTileId, + offset: &mut DeviceIntPoint, + fbo_id: &mut u32, + dirty_rect: DeviceIntRect, + valid_rect: DeviceIntRect, + ); + fn wr_compositor_unbind(compositor: *mut c_void); + fn wr_compositor_begin_frame(compositor: *mut c_void); + fn wr_compositor_add_surface( + compositor: *mut c_void, + id: NativeSurfaceId, + transform: &CompositorSurfaceTransform, + clip_rect: DeviceIntRect, + image_rendering: ImageRendering, + ); + fn wr_compositor_start_compositing( + compositor: *mut c_void, + clear_color: ColorF, + dirty_rects: *const DeviceIntRect, + num_dirty_rects: usize, + opaque_rects: *const DeviceIntRect, + num_opaque_rects: usize, + ); + fn wr_compositor_end_frame(compositor: *mut c_void); + fn wr_compositor_enable_native_compositor(compositor: *mut c_void, enable: bool); + fn wr_compositor_deinit(compositor: *mut c_void); + fn wr_compositor_get_capabilities(compositor: *mut c_void, caps: *mut CompositorCapabilities); + fn wr_compositor_get_window_visibility(compositor: *mut c_void, caps: *mut WindowVisibility); + fn wr_compositor_map_tile( + compositor: *mut c_void, + id: NativeTileId, + dirty_rect: DeviceIntRect, + valid_rect: DeviceIntRect, + data: &mut *mut c_void, + stride: &mut i32, + ); + fn wr_compositor_unmap_tile(compositor: *mut c_void); + + fn wr_partial_present_compositor_set_buffer_damage_region( + compositor: *mut c_void, + rects: *const DeviceIntRect, + n_rects: usize, + ); +} + +pub struct WrCompositor(*mut c_void); + +impl Compositor for WrCompositor { + fn create_surface( + &mut self, + _device: &mut Device, + id: NativeSurfaceId, + virtual_offset: DeviceIntPoint, + tile_size: DeviceIntSize, + is_opaque: bool, + ) { + unsafe { + wr_compositor_create_surface(self.0, id, virtual_offset, tile_size, is_opaque); + } + } + + fn create_external_surface(&mut self, _device: &mut Device, id: NativeSurfaceId, is_opaque: bool) { + unsafe { + wr_compositor_create_external_surface(self.0, id, is_opaque); + } + } + + fn create_backdrop_surface(&mut self, _device: &mut Device, id: NativeSurfaceId, color: ColorF) { + unsafe { + wr_compositor_create_backdrop_surface(self.0, id, color); + } + } + + fn destroy_surface(&mut self, _device: &mut Device, id: NativeSurfaceId) { + unsafe { + wr_compositor_destroy_surface(self.0, id); + } + } + + fn create_tile(&mut self, _device: &mut Device, id: NativeTileId) { + unsafe { + wr_compositor_create_tile(self.0, id.surface_id, id.x, id.y); + } + } + + fn destroy_tile(&mut self, _device: &mut Device, id: NativeTileId) { + unsafe { + wr_compositor_destroy_tile(self.0, id.surface_id, id.x, id.y); + } + } + + fn attach_external_image(&mut self, _device: &mut Device, id: NativeSurfaceId, external_image: ExternalImageId) { + unsafe { + wr_compositor_attach_external_image(self.0, id, external_image); + } + } + + fn bind( + &mut self, + _device: &mut Device, + id: NativeTileId, + dirty_rect: DeviceIntRect, + valid_rect: DeviceIntRect, + ) -> NativeSurfaceInfo { + let mut surface_info = NativeSurfaceInfo { + origin: DeviceIntPoint::zero(), + fbo_id: 0, + }; + + unsafe { + wr_compositor_bind( + self.0, + id, + &mut surface_info.origin, + &mut surface_info.fbo_id, + dirty_rect, + valid_rect, + ); + } + + surface_info + } + + fn unbind(&mut self, _device: &mut Device) { + unsafe { + wr_compositor_unbind(self.0); + } + } + + fn begin_frame(&mut self, _device: &mut Device) { + unsafe { + wr_compositor_begin_frame(self.0); + } + } + + fn add_surface( + &mut self, + _device: &mut Device, + id: NativeSurfaceId, + transform: CompositorSurfaceTransform, + clip_rect: DeviceIntRect, + image_rendering: ImageRendering, + ) { + unsafe { + wr_compositor_add_surface(self.0, id, &transform, clip_rect, image_rendering); + } + } + + fn start_compositing( + &mut self, + _device: &mut Device, + clear_color: ColorF, + dirty_rects: &[DeviceIntRect], + opaque_rects: &[DeviceIntRect], + ) { + unsafe { + wr_compositor_start_compositing( + self.0, + clear_color, + dirty_rects.as_ptr(), + dirty_rects.len(), + opaque_rects.as_ptr(), + opaque_rects.len(), + ); + } + } + + fn end_frame(&mut self, _device: &mut Device) { + unsafe { + wr_compositor_end_frame(self.0); + } + } + + fn enable_native_compositor(&mut self, _device: &mut Device, enable: bool) { + unsafe { + wr_compositor_enable_native_compositor(self.0, enable); + } + } + + fn deinit(&mut self, _device: &mut Device) { + unsafe { + wr_compositor_deinit(self.0); + } + } + + fn get_capabilities(&self, _device: &mut Device) -> CompositorCapabilities { + unsafe { + let mut caps: CompositorCapabilities = Default::default(); + wr_compositor_get_capabilities(self.0, &mut caps); + caps + } + } + + fn get_window_visibility(&self, _device: &mut Device) -> WindowVisibility { + unsafe { + let mut visibility: WindowVisibility = Default::default(); + wr_compositor_get_window_visibility(self.0, &mut visibility); + visibility + } + } +} + +extern "C" { + fn wr_swgl_lock_composite_surface( + ctx: *mut c_void, + external_image_id: ExternalImageId, + composite_info: *mut SWGLCompositeSurfaceInfo, + ) -> bool; + fn wr_swgl_unlock_composite_surface(ctx: *mut c_void, external_image_id: ExternalImageId); +} + +impl MappableCompositor for WrCompositor { + /// Map a tile's underlying buffer so it can be used as the backing for + /// a SWGL framebuffer. This is intended to be a replacement for 'bind' + /// in any compositors that intend to directly interoperate with SWGL + /// while supporting some form of native layers. + fn map_tile( + &mut self, + _device: &mut Device, + id: NativeTileId, + dirty_rect: DeviceIntRect, + valid_rect: DeviceIntRect, + ) -> Option { + let mut tile_info = MappedTileInfo { + data: ptr::null_mut(), + stride: 0, + }; + + unsafe { + wr_compositor_map_tile( + self.0, + id, + dirty_rect, + valid_rect, + &mut tile_info.data, + &mut tile_info.stride, + ); + } + + if !tile_info.data.is_null() && tile_info.stride != 0 { + Some(tile_info) + } else { + None + } + } + + /// Unmap a tile that was was previously mapped via map_tile to signal + /// that SWGL is done rendering to the buffer. + fn unmap_tile(&mut self, _device: &mut Device) { + unsafe { + wr_compositor_unmap_tile(self.0); + } + } + + fn lock_composite_surface( + &mut self, + _device: &mut Device, + ctx: *mut c_void, + external_image_id: ExternalImageId, + composite_info: *mut SWGLCompositeSurfaceInfo, + ) -> bool { + unsafe { wr_swgl_lock_composite_surface(ctx, external_image_id, composite_info) } + } + fn unlock_composite_surface(&mut self, _device: &mut Device, ctx: *mut c_void, external_image_id: ExternalImageId) { + unsafe { wr_swgl_unlock_composite_surface(ctx, external_image_id) } + } +} + +pub struct WrPartialPresentCompositor(*mut c_void); + +impl PartialPresentCompositor for WrPartialPresentCompositor { + fn set_buffer_damage_region(&mut self, rects: &[DeviceIntRect]) { + unsafe { + wr_partial_present_compositor_set_buffer_damage_region(self.0, rects.as_ptr(), rects.len()); + } + } +} + +/// A wrapper around a strong reference to a Shaders object. +pub struct WrShaders(SharedShaders); + +// Call MakeCurrent before this. +#[no_mangle] +pub extern "C" fn wr_window_new( + window_id: WrWindowId, + window_width: i32, + window_height: i32, + is_main_window: bool, + support_low_priority_transactions: bool, + support_low_priority_threadpool: bool, + allow_texture_swizzling: bool, + allow_scissored_cache_clears: bool, + swgl_context: *mut c_void, + gl_context: *mut c_void, + surface_origin_is_top_left: bool, + program_cache: Option<&mut WrProgramCache>, + shaders: Option<&mut WrShaders>, + thread_pool: *mut WrThreadPool, + thread_pool_low_priority: *mut WrThreadPool, + size_of_op: VoidPtrToSizeFn, + enclosing_size_of_op: VoidPtrToSizeFn, + document_id: u32, + compositor: *mut c_void, + use_native_compositor: bool, + use_partial_present: bool, + max_partial_present_rects: usize, + draw_previous_partial_present_regions: bool, + out_handle: &mut *mut DocumentHandle, + out_renderer: &mut *mut Renderer, + out_max_texture_size: *mut i32, + out_err: &mut *mut c_char, + enable_gpu_markers: bool, + panic_on_gl_error: bool, + picture_tile_width: i32, + picture_tile_height: i32, + reject_software_rasterizer: bool, + low_quality_pinch_zoom: bool, + max_shared_surface_size: i32, + enable_subpixel_aa: bool, +) -> bool { + assert!(unsafe { is_in_render_thread() }); + + // Ensure the WR profiler callbacks are hooked up to the Gecko profiler. + set_profiler_hooks(Some(&PROFILER_HOOKS)); + + let software = !swgl_context.is_null(); + let (gl, sw_gl) = if software { + let ctx = swgl::Context::from(swgl_context); + ctx.make_current(); + (Rc::new(ctx) as Rc, Some(ctx)) + } else { + let gl = unsafe { + if gl_context.is_null() { + panic!("Native GL context required when not using SWGL!"); + } else if is_glcontext_gles(gl_context) { + gl::GlesFns::load_with(|symbol| get_proc_address(gl_context, symbol)) + } else { + gl::GlFns::load_with(|symbol| get_proc_address(gl_context, symbol)) + } + }; + (gl, None) + }; + + let version = gl.get_string(gl::VERSION); + + info!("WebRender - OpenGL version new {}", version); + + let workers = unsafe { Arc::clone(&(*thread_pool).0) }; + let workers_low_priority = unsafe { + if support_low_priority_threadpool { + Arc::clone(&(*thread_pool_low_priority).0) + } else { + Arc::clone(&(*thread_pool).0) + } + }; + + let upload_method = if !gl_context.is_null() && unsafe { is_glcontext_angle(gl_context) } { + UploadMethod::Immediate + } else { + UploadMethod::PixelBuffer(ONE_TIME_USAGE_HINT) + }; + + let precache_flags = if env_var_to_bool("MOZ_WR_PRECACHE_SHADERS") { + ShaderPrecacheFlags::FULL_COMPILE + } else { + ShaderPrecacheFlags::empty() + }; + + let cached_programs = program_cache.map(|program_cache| Rc::clone(&program_cache.rc_get())); + + let color = if cfg!(target_os = "android") { + // The color is for avoiding black flash before receiving display list. + ColorF::new(1.0, 1.0, 1.0, 1.0) + } else { + ColorF::new(0.0, 0.0, 0.0, 0.0) + }; + + let compositor_config = if software { + CompositorConfig::Native { + compositor: Box::new(SwCompositor::new( + sw_gl.unwrap(), + Box::new(WrCompositor(compositor)), + use_native_compositor, + )), + } + } else if use_native_compositor { + CompositorConfig::Native { + compositor: Box::new(WrCompositor(compositor)), + } + } else { + CompositorConfig::Draw { + max_partial_present_rects, + draw_previous_partial_present_regions, + partial_present: if use_partial_present { + Some(Box::new(WrPartialPresentCompositor(compositor))) + } else { + None + }, + } + }; + + let picture_tile_size = if picture_tile_width > 0 && picture_tile_height > 0 { + Some(DeviceIntSize::new(picture_tile_width, picture_tile_height)) + } else { + None + }; + + let texture_cache_config = if is_main_window { + TextureCacheConfig::DEFAULT + } else { + TextureCacheConfig { + color8_linear_texture_size: 512, + color8_nearest_texture_size: 512, + color8_glyph_texture_size: 512, + alpha8_texture_size: 512, + alpha8_glyph_texture_size: 512, + alpha16_texture_size: 512, + } + }; + + let opts = WebRenderOptions { + enable_aa: true, + enable_subpixel_aa, + support_low_priority_transactions, + allow_texture_swizzling, + blob_image_handler: Some(Box::new(Moz2dBlobImageHandler::new( + workers.clone(), + workers_low_priority, + ))), + crash_annotator: Some(Box::new(MozCrashAnnotator)), + workers: Some(workers), + size_of_op: Some(size_of_op), + enclosing_size_of_op: Some(enclosing_size_of_op), + cached_programs, + resource_override_path: unsafe { + let override_charptr = gfx_wr_resource_path_override(); + if override_charptr.is_null() { + None + } else { + match CStr::from_ptr(override_charptr).to_str() { + Ok(override_str) => Some(PathBuf::from(override_str)), + _ => None, + } + } + }, + use_optimized_shaders: unsafe { gfx_wr_use_optimized_shaders() }, + renderer_id: Some(window_id.0), + upload_method, + scene_builder_hooks: Some(Box::new(APZCallbacks::new(window_id))), + sampler: Some(Box::new(SamplerCallback::new(window_id))), + max_internal_texture_size: Some(8192), // We want to tile if larger than this + clear_color: color, + precache_flags, + namespace_alloc_by_client: true, + // Font namespace must be allocated by the client + shared_font_namespace: Some(next_namespace_id()), + // SWGL doesn't support the GL_ALWAYS depth comparison function used by + // `clear_caches_with_quads`, but scissored clears work well. + clear_caches_with_quads: !software && !allow_scissored_cache_clears, + // SWGL supports KHR_blend_equation_advanced safely, but we haven't yet + // tested other HW platforms determine if it is safe to allow them. + allow_advanced_blend_equation: software, + surface_origin_is_top_left, + compositor_config, + enable_gpu_markers, + panic_on_gl_error, + picture_tile_size, + texture_cache_config, + reject_software_rasterizer, + low_quality_pinch_zoom, + max_shared_surface_size, + ..Default::default() + }; + + let window_size = DeviceIntSize::new(window_width, window_height); + let notifier = Box::new(CppNotifier { window_id }); + let (renderer, sender) = match create_webrender_instance(gl, notifier, opts, shaders.map(|sh| &sh.0)) { + Ok((renderer, sender)) => (renderer, sender), + Err(e) => { + warn!(" Failed to create a Renderer: {:?}", e); + let msg = CString::new(format!("wr_window_new: {:?}", e)).unwrap(); + unsafe { + gfx_critical_note(msg.as_ptr()); + } + *out_err = msg.into_raw(); + return false; + }, + }; + + unsafe { + *out_max_texture_size = renderer.get_max_texture_size(); + } + *out_handle = Box::into_raw(Box::new(DocumentHandle::new( + sender.create_api_by_client(next_namespace_id()), + None, + window_size, + document_id, + ))); + *out_renderer = Box::into_raw(Box::new(renderer)); + + true +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_free_error_msg(msg: *mut c_char) { + if !msg.is_null() { + drop(CString::from_raw(msg)); + } +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_delete_document(dh: &mut DocumentHandle) { + dh.api.delete_document(dh.document_id); +} + +#[no_mangle] +pub extern "C" fn wr_api_clone(dh: &mut DocumentHandle, out_handle: &mut *mut DocumentHandle) { + assert!(unsafe { is_in_compositor_thread() }); + + let hit_tester = dh.ensure_hit_tester().clone(); + + let handle = DocumentHandle { + api: dh.api.create_sender().create_api_by_client(next_namespace_id()), + document_id: dh.document_id, + hit_tester: Some(hit_tester), + hit_tester_request: None, + }; + *out_handle = Box::into_raw(Box::new(handle)); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_delete(dh: *mut DocumentHandle) { + let _ = Box::from_raw(dh); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_stop_render_backend(dh: &mut DocumentHandle) { + dh.api.stop_render_backend(); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_shut_down(dh: &mut DocumentHandle) { + dh.api.shut_down(true); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_notify_memory_pressure(dh: &mut DocumentHandle) { + dh.api.notify_memory_pressure(); +} + +#[no_mangle] +pub extern "C" fn wr_api_set_debug_flags(dh: &mut DocumentHandle, flags: DebugFlags) { + dh.api.set_debug_flags(flags); +} + +#[no_mangle] +pub extern "C" fn wr_api_set_bool(dh: &mut DocumentHandle, param_name: BoolParameter, val: bool) { + dh.api.set_parameter(Parameter::Bool(param_name, val)); +} + +#[no_mangle] +pub extern "C" fn wr_api_set_int(dh: &mut DocumentHandle, param_name: IntParameter, val: i32) { + dh.api.set_parameter(Parameter::Int(param_name, val)); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_accumulate_memory_report( + dh: &mut DocumentHandle, + report: &mut MemoryReport, + // we manually expand VoidPtrToSizeFn here because cbindgen otherwise fails to fold the Option + // https://github.com/eqrion/cbindgen/issues/552 + size_of_op: unsafe extern "C" fn(ptr: *const c_void) -> usize, + enclosing_size_of_op: Option usize>, +) { + let ops = MallocSizeOfOps::new(size_of_op, enclosing_size_of_op); + *report += dh.api.report_memory(ops); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_clear_all_caches(dh: &mut DocumentHandle) { + dh.api.send_debug_cmd(DebugCommand::ClearCaches(ClearCache::all())); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_enable_native_compositor(dh: &mut DocumentHandle, enable: bool) { + dh.api.send_debug_cmd(DebugCommand::EnableNativeCompositor(enable)); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_set_batching_lookback(dh: &mut DocumentHandle, count: u32) { + dh.api.send_debug_cmd(DebugCommand::SetBatchingLookback(count)); +} + +fn make_transaction(do_async: bool) -> Transaction { + let mut transaction = Transaction::new(); + // Ensure that we either use async scene building or not based on the + // gecko pref, regardless of what the default is. We can remove this once + // the scene builder thread is enabled everywhere and working well. + if do_async { + transaction.use_scene_builder_thread(); + } else { + transaction.skip_scene_builder(); + } + transaction +} + +#[no_mangle] +pub extern "C" fn wr_transaction_new(do_async: bool) -> *mut Transaction { + Box::into_raw(Box::new(make_transaction(do_async))) +} + +#[no_mangle] +pub extern "C" fn wr_transaction_delete(txn: *mut Transaction) { + unsafe { + let _ = Box::from_raw(txn); + } +} + +#[no_mangle] +pub extern "C" fn wr_transaction_set_low_priority(txn: &mut Transaction, low_priority: bool) { + txn.set_low_priority(low_priority); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_is_empty(txn: &Transaction) -> bool { + txn.is_empty() +} + +#[no_mangle] +pub extern "C" fn wr_transaction_resource_updates_is_empty(txn: &Transaction) -> bool { + txn.resource_updates.is_empty() +} + +#[no_mangle] +pub extern "C" fn wr_transaction_is_rendered_frame_invalidated(txn: &Transaction) -> bool { + txn.invalidate_rendered_frame +} + +#[no_mangle] +pub extern "C" fn wr_transaction_notify(txn: &mut Transaction, when: Checkpoint, event: usize) { + struct GeckoNotification(usize); + impl NotificationHandler for GeckoNotification { + fn notify(&self, when: Checkpoint) { + unsafe { + wr_transaction_notification_notified(self.0, when); + } + } + } + + let handler = Box::new(GeckoNotification(event)); + txn.notify(NotificationRequest::new(when, handler)); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_update_epoch(txn: &mut Transaction, pipeline_id: WrPipelineId, epoch: WrEpoch) { + txn.update_epoch(pipeline_id, epoch); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_set_root_pipeline(txn: &mut Transaction, pipeline_id: WrPipelineId) { + txn.set_root_pipeline(pipeline_id); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_remove_pipeline(txn: &mut Transaction, pipeline_id: WrPipelineId) { + txn.remove_pipeline(pipeline_id); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_set_display_list( + txn: &mut Transaction, + epoch: WrEpoch, + pipeline_id: WrPipelineId, + dl_descriptor: BuiltDisplayListDescriptor, + dl_items_data: &mut WrVecU8, + dl_cache_data: &mut WrVecU8, + dl_spatial_tree_data: &mut WrVecU8, +) { + let payload = DisplayListPayload { + items_data: dl_items_data.flush_into_vec(), + cache_data: dl_cache_data.flush_into_vec(), + spatial_tree: dl_spatial_tree_data.flush_into_vec(), + }; + + let dl = BuiltDisplayList::from_data(payload, dl_descriptor); + + txn.set_display_list(epoch, (pipeline_id, dl)); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_set_document_view(txn: &mut Transaction, doc_rect: &DeviceIntRect) { + txn.set_document_view(*doc_rect); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_generate_frame(txn: &mut Transaction, id: u64, reasons: RenderReasons) { + txn.generate_frame(id, reasons); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_invalidate_rendered_frame(txn: &mut Transaction, reasons: RenderReasons) { + txn.invalidate_rendered_frame(reasons); +} + +fn wr_animation_properties_into_vec( + animation_array: *const WrAnimationPropertyValue, + array_count: usize, + vec: &mut Vec>, +) where + T: Copy, +{ + if array_count > 0 { + debug_assert!( + vec.capacity() - vec.len() >= array_count, + "The Vec should have fufficient free capacity" + ); + let slice = unsafe { make_slice(animation_array, array_count) }; + + for element in slice.iter() { + let prop = PropertyValue { + key: PropertyBindingKey::new(element.id), + value: element.value, + }; + + vec.push(prop); + } + } +} + +#[no_mangle] +pub extern "C" fn wr_transaction_append_dynamic_properties( + txn: &mut Transaction, + opacity_array: *const WrOpacityProperty, + opacity_count: usize, + transform_array: *const WrTransformProperty, + transform_count: usize, + color_array: *const WrColorProperty, + color_count: usize, +) { + if opacity_count == 0 && transform_count == 0 && color_count == 0 { + return; + } + + let mut properties = DynamicProperties { + transforms: Vec::with_capacity(transform_count), + floats: Vec::with_capacity(opacity_count), + colors: Vec::with_capacity(color_count), + }; + + wr_animation_properties_into_vec(transform_array, transform_count, &mut properties.transforms); + + wr_animation_properties_into_vec(opacity_array, opacity_count, &mut properties.floats); + + wr_animation_properties_into_vec(color_array, color_count, &mut properties.colors); + + txn.append_dynamic_properties(properties); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_append_transform_properties( + txn: &mut Transaction, + transform_array: *const WrTransformProperty, + transform_count: usize, +) { + if transform_count == 0 { + return; + } + + let mut transforms = Vec::with_capacity(transform_count); + wr_animation_properties_into_vec(transform_array, transform_count, &mut transforms); + + txn.append_dynamic_transform_properties(transforms); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_scroll_layer( + txn: &mut Transaction, + scroll_id: ExternalScrollId, + sampled_scroll_offsets: &ThinVec, +) { + txn.set_scroll_offsets(scroll_id, sampled_scroll_offsets.to_vec()); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_set_is_transform_async_zooming( + txn: &mut Transaction, + animation_id: u64, + is_zooming: bool, +) { + txn.set_is_transform_async_zooming(is_zooming, PropertyBindingId::new(animation_id)); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_add_minimap_data( + txn: &mut Transaction, + scroll_id: ExternalScrollId, + minimap_data: MinimapData, +) { + txn.set_minimap_data(scroll_id, minimap_data); +} + +#[no_mangle] +pub extern "C" fn wr_transaction_set_quality_settings(txn: &mut Transaction, force_subpixel_aa_where_possible: bool) { + txn.set_quality_settings(QualitySettings { + force_subpixel_aa_where_possible, + }); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_add_image( + txn: &mut Transaction, + image_key: WrImageKey, + descriptor: &WrImageDescriptor, + bytes: &mut WrVecU8, +) { + txn.add_image( + image_key, + descriptor.into(), + ImageData::new(bytes.flush_into_vec()), + None, + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_add_blob_image( + txn: &mut Transaction, + image_key: BlobImageKey, + descriptor: &WrImageDescriptor, + tile_size: u16, + bytes: &mut WrVecU8, + visible_rect: DeviceIntRect, +) { + // If we're at risk of generating an excessive number of tiles, try making + // them larger so as to reduce the total number. This helps avoid swamping + // the Moz2dBlobRasterizer with too many parallel requests. + const TILE_COUNT_LIMIT: i64 = 8192; + const TILE_SIZE_LIMIT: u16 = 2048; + let mut adjusted = tile_size; + // Rather than some tricky computation involving the image dimensions, just + // keep doubling tile_size until the estimated count is reasonable, or size + // gets too big. The size limit means this loop won't execute more than a + // handful of times even in extreme cases. + while adjusted < TILE_SIZE_LIMIT + && ((descriptor.height / adjusted as i32 + 1) as i64 * (descriptor.width / adjusted as i32 + 1) as i64) + > TILE_COUNT_LIMIT + { + adjusted = adjusted * 2; + } + + txn.add_blob_image( + image_key, + descriptor.into(), + Arc::new(bytes.flush_into_vec()), + visible_rect, + if descriptor.format == ImageFormat::BGRA8 || adjusted > tile_size { + Some(adjusted) + } else { + None + }, + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_add_external_image( + txn: &mut Transaction, + image_key: WrImageKey, + descriptor: &WrImageDescriptor, + external_image_id: ExternalImageId, + image_type: &ExternalImageType, + channel_index: u8, +) { + txn.add_image( + image_key, + descriptor.into(), + ImageData::External(ExternalImageData { + id: external_image_id, + channel_index, + image_type: *image_type, + }), + None, + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_update_image( + txn: &mut Transaction, + key: WrImageKey, + descriptor: &WrImageDescriptor, + bytes: &mut WrVecU8, +) { + txn.update_image( + key, + descriptor.into(), + ImageData::new(bytes.flush_into_vec()), + &DirtyRect::All, + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_set_blob_image_visible_area( + txn: &mut Transaction, + key: BlobImageKey, + area: &DeviceIntRect, +) { + txn.set_blob_image_visible_area(key, *area); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_update_external_image( + txn: &mut Transaction, + key: WrImageKey, + descriptor: &WrImageDescriptor, + external_image_id: ExternalImageId, + image_type: &ExternalImageType, + channel_index: u8, +) { + txn.update_image( + key, + descriptor.into(), + ImageData::External(ExternalImageData { + id: external_image_id, + channel_index, + image_type: *image_type, + }), + &DirtyRect::All, + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_update_external_image_with_dirty_rect( + txn: &mut Transaction, + key: WrImageKey, + descriptor: &WrImageDescriptor, + external_image_id: ExternalImageId, + image_type: &ExternalImageType, + channel_index: u8, + dirty_rect: DeviceIntRect, +) { + txn.update_image( + key, + descriptor.into(), + ImageData::External(ExternalImageData { + id: external_image_id, + channel_index, + image_type: *image_type, + }), + &DirtyRect::Partial(dirty_rect), + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_update_blob_image( + txn: &mut Transaction, + image_key: BlobImageKey, + descriptor: &WrImageDescriptor, + bytes: &mut WrVecU8, + visible_rect: DeviceIntRect, + dirty_rect: LayoutIntRect, +) { + txn.update_blob_image( + image_key, + descriptor.into(), + Arc::new(bytes.flush_into_vec()), + visible_rect, + &DirtyRect::Partial(dirty_rect), + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_delete_image(txn: &mut Transaction, key: WrImageKey) { + txn.delete_image(key); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_delete_blob_image(txn: &mut Transaction, key: BlobImageKey) { + txn.delete_blob_image(key); +} + +#[no_mangle] +pub extern "C" fn wr_api_send_transaction(dh: &mut DocumentHandle, transaction: &mut Transaction, is_async: bool) { + if transaction.is_empty() { + return; + } + let new_txn = make_transaction(is_async); + let txn = mem::replace(transaction, new_txn); + dh.api.send_transaction(dh.document_id, txn); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_transaction_clear_display_list( + txn: &mut Transaction, + epoch: WrEpoch, + pipeline_id: WrPipelineId, +) { + let mut frame_builder = WebRenderFrameBuilder::new(pipeline_id); + frame_builder.dl_builder.begin(); + + txn.set_display_list(epoch, frame_builder.dl_builder.end()); +} + +#[no_mangle] +pub extern "C" fn wr_api_send_external_event(dh: &mut DocumentHandle, evt: usize) { + assert!(unsafe { !is_in_render_thread() }); + + dh.api.send_external_event(ExternalEvent::from_raw(evt)); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_add_raw_font( + txn: &mut Transaction, + key: WrFontKey, + bytes: &mut WrVecU8, + index: u32, +) { + txn.add_raw_font(key, bytes.flush_into_vec(), index); +} + +fn generate_capture_path(path: *const c_char) -> Option { + use std::fs::{create_dir_all, File}; + use std::io::Write; + + let cstr = unsafe { CStr::from_ptr(path) }; + let local_dir = PathBuf::from(&*cstr.to_string_lossy()); + + // On Android we need to write into a particular folder on external + // storage so that (a) it can be written without requiring permissions + // and (b) it can be pulled off via `adb pull`. This env var is set + // in GeckoLoader.java. + // When running in Firefox CI, the MOZ_UPLOAD_DIR variable is set to a path + // that taskcluster will export artifacts from, so let's put it there. + let mut path = if let Ok(storage_path) = env::var("PUBLIC_STORAGE") { + PathBuf::from(storage_path).join(local_dir) + } else if let Ok(storage_path) = env::var("MOZ_UPLOAD_DIR") { + PathBuf::from(storage_path).join(local_dir) + } else if let Some(storage_path) = dirs::home_dir() { + storage_path.join(local_dir) + } else { + local_dir + }; + + // Increment the extension until we find a fresh path + while path.is_dir() { + let count: u32 = path + .extension() + .and_then(|x| x.to_str()) + .and_then(|x| x.parse().ok()) + .unwrap_or(0); + path.set_extension((count + 1).to_string()); + } + + // Use warn! so that it gets emitted to logcat on android as well + let border = "--------------------------\n"; + warn!("{} Capturing WR state to: {:?}\n{}", &border, &path, &border); + + let _ = create_dir_all(&path); + match File::create(path.join("wr.txt")) { + Ok(mut file) => { + // The Gecko HG revision is available at compile time + if let Some(moz_revision) = option_env!("GECKO_HEAD_REV") { + writeln!(file, "mozilla-central {}", moz_revision).unwrap(); + } + Some(path) + }, + Err(e) => { + warn!("Unable to create path '{:?}' for capture: {:?}", path, e); + None + }, + } +} + +#[no_mangle] +pub extern "C" fn wr_api_capture(dh: &mut DocumentHandle, path: *const c_char, bits_raw: u32) { + if let Some(path) = generate_capture_path(path) { + let bits = CaptureBits::from_bits(bits_raw as _).unwrap(); + dh.api.save_capture(path, bits); + } +} + +#[no_mangle] +pub extern "C" fn wr_api_start_capture_sequence(dh: &mut DocumentHandle, path: *const c_char, bits_raw: u32) { + if let Some(path) = generate_capture_path(path) { + let bits = CaptureBits::from_bits(bits_raw as _).unwrap(); + dh.api.start_capture_sequence(path, bits); + } +} + +#[no_mangle] +pub extern "C" fn wr_api_stop_capture_sequence(dh: &mut DocumentHandle) { + let border = "--------------------------\n"; + warn!("{} Stop capturing WR state\n{}", &border, &border); + dh.api.stop_capture_sequence(); +} + +#[cfg(target_os = "windows")] +fn read_font_descriptor(bytes: &mut WrVecU8, index: u32) -> NativeFontHandle { + let wchars = bytes.convert_into_vec::(); + NativeFontHandle { + path: PathBuf::from(OsString::from_wide(&wchars)), + index, + } +} + +#[cfg(target_os = "macos")] +fn read_font_descriptor(bytes: &mut WrVecU8, index: u32) -> NativeFontHandle { + // On macOS, the descriptor string is a concatenation of the PostScript name + // and the font file path (to disambiguate cases where there are multiple + // faces with the same psname present). The index is the length of the psname + // portion of the descriptor (= starting offset of the path). + // Here, we split the descriptor into its two components for further use. + let chars = bytes.flush_into_vec(); + NativeFontHandle { + name: String::from_utf8(chars[..index as usize].to_vec()).unwrap_or("".to_string()), + path: String::from_utf8(chars[index as usize..].to_vec()).unwrap_or("".to_string()), + } +} + +#[cfg(not(any(target_os = "macos", target_os = "windows")))] +fn read_font_descriptor(bytes: &mut WrVecU8, index: u32) -> NativeFontHandle { + let chars = bytes.flush_into_vec(); + NativeFontHandle { + path: PathBuf::from(OsString::from_vec(chars)), + index, + } +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_add_font_descriptor( + txn: &mut Transaction, + key: WrFontKey, + bytes: &mut WrVecU8, + index: u32, +) { + let native_font_handle = read_font_descriptor(bytes, index); + txn.add_native_font(key, native_font_handle); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_delete_font(txn: &mut Transaction, key: WrFontKey) { + txn.delete_font(key); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_add_font_instance( + txn: &mut Transaction, + key: WrFontInstanceKey, + font_key: WrFontKey, + glyph_size: f32, + options: *const FontInstanceOptions, + platform_options: *const FontInstancePlatformOptions, + variations: &mut WrVecU8, +) { + txn.add_font_instance( + key, + font_key, + glyph_size, + unsafe { options.as_ref().cloned() }, + unsafe { platform_options.as_ref().cloned() }, + variations.convert_into_vec::(), + ); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_delete_font_instance(txn: &mut Transaction, key: WrFontInstanceKey) { + txn.delete_font_instance(key); +} + +#[no_mangle] +pub extern "C" fn wr_resource_updates_clear(txn: &mut Transaction) { + txn.resource_updates.clear(); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_get_namespace(dh: &mut DocumentHandle) -> WrIdNamespace { + dh.api.get_namespace_id() +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_wake_scene_builder(dh: &mut DocumentHandle) { + dh.api.wake_scene_builder(); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_flush_scene_builder(dh: &mut DocumentHandle) { + dh.api.flush_scene_builder(); +} + +// RenderThread WIP notes: +// In order to separate the compositor thread (or ipc receiver) and the render +// thread, some of the logic below needs to be rewritten. In particular +// the WrWindowState and Notifier implementations aren't designed to work with +// a separate render thread. +// As part of that I am moving the bindings closer to WebRender's API boundary, +// and moving more of the logic in C++ land. +// This work is tracked by bug 1328602. +// +// See RenderThread.h for some notes about how the pieces fit together. + +pub struct WebRenderFrameBuilder { + pub root_pipeline_id: WrPipelineId, + pub dl_builder: DisplayListBuilder, +} + +impl WebRenderFrameBuilder { + pub fn new(root_pipeline_id: WrPipelineId) -> WebRenderFrameBuilder { + WebRenderFrameBuilder { + root_pipeline_id, + dl_builder: DisplayListBuilder::new(root_pipeline_id), + } + } +} + +pub struct WrState { + pipeline_id: WrPipelineId, + frame_builder: WebRenderFrameBuilder, +} + +#[no_mangle] +pub extern "C" fn wr_state_new(pipeline_id: WrPipelineId) -> *mut WrState { + assert!(unsafe { !is_in_render_thread() }); + + let state = Box::new(WrState { + pipeline_id, + frame_builder: WebRenderFrameBuilder::new(pipeline_id), + }); + + Box::into_raw(state) +} + +#[no_mangle] +pub extern "C" fn wr_state_delete(state: *mut WrState) { + assert!(unsafe { !is_in_render_thread() }); + + unsafe { + mem::drop(Box::from_raw(state)); + } +} + +#[no_mangle] +pub extern "C" fn wr_dp_save(state: &mut WrState) { + state.frame_builder.dl_builder.save(); +} + +#[no_mangle] +pub extern "C" fn wr_dp_restore(state: &mut WrState) { + state.frame_builder.dl_builder.restore(); +} + +#[no_mangle] +pub extern "C" fn wr_dp_clear_save(state: &mut WrState) { + state.frame_builder.dl_builder.clear_save(); +} + +#[repr(u8)] +#[derive(PartialEq, Eq, Debug)] +pub enum WrReferenceFrameKind { + Transform, + Perspective, +} + +#[repr(u8)] +#[derive(PartialEq, Eq, Debug)] +pub enum WrRotation { + Degree0, + Degree90, + Degree180, + Degree270, +} + +/// IMPORTANT: If you add fields to this struct, you need to also add initializers +/// for those fields in WebRenderAPI.h. +#[repr(C)] +pub struct WrStackingContextParams { + pub clip: WrStackingContextClip, + pub animation: *const WrAnimationProperty, + pub opacity: *const f32, + pub computed_transform: *const WrComputedTransformData, + pub transform_style: TransformStyle, + pub reference_frame_kind: WrReferenceFrameKind, + pub is_2d_scale_translation: bool, + pub should_snap: bool, + pub paired_with_perspective: bool, + pub scrolling_relative_to: *const u64, + pub prim_flags: PrimitiveFlags, + pub mix_blend_mode: MixBlendMode, + pub flags: StackingContextFlags, +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_stacking_context( + state: &mut WrState, + bounds: LayoutRect, + spatial_id: WrSpatialId, + params: &WrStackingContextParams, + transform: *const WrTransformInfo, + filters: *const FilterOp, + filter_count: usize, + filter_datas: *const WrFilterData, + filter_datas_count: usize, + glyph_raster_space: RasterSpace, +) -> WrSpatialId { + debug_assert!(unsafe { !is_in_render_thread() }); + + let c_filters = unsafe { make_slice(filters, filter_count) }; + let mut filters: Vec = c_filters.iter().copied().collect(); + + let c_filter_datas = unsafe { make_slice(filter_datas, filter_datas_count) }; + let r_filter_datas: Vec = c_filter_datas + .iter() + .map(|c_filter_data| FilterData { + func_r_type: c_filter_data.funcR_type, + r_values: unsafe { make_slice(c_filter_data.R_values, c_filter_data.R_values_count).to_vec() }, + func_g_type: c_filter_data.funcG_type, + g_values: unsafe { make_slice(c_filter_data.G_values, c_filter_data.G_values_count).to_vec() }, + func_b_type: c_filter_data.funcB_type, + b_values: unsafe { make_slice(c_filter_data.B_values, c_filter_data.B_values_count).to_vec() }, + func_a_type: c_filter_data.funcA_type, + a_values: unsafe { make_slice(c_filter_data.A_values, c_filter_data.A_values_count).to_vec() }, + }) + .collect(); + + let transform_ref = unsafe { transform.as_ref() }; + let mut transform_binding = transform_ref.map(|info| (PropertyBinding::Value(info.transform), info.key)); + + let computed_ref = unsafe { params.computed_transform.as_ref() }; + let opacity_ref = unsafe { params.opacity.as_ref() }; + let mut has_opacity_animation = false; + let anim = unsafe { params.animation.as_ref() }; + if let Some(anim) = anim { + debug_assert!(anim.id > 0); + match anim.effect_type { + WrAnimationType::Opacity => { + filters.push(FilterOp::Opacity( + PropertyBinding::Binding( + PropertyBindingKey::new(anim.id), + // We have to set the static opacity value as + // the value for the case where the animation is + // in not in-effect (e.g. in the delay phase + // with no corresponding fill mode). + opacity_ref.cloned().unwrap_or(1.0), + ), + 1.0, + )); + has_opacity_animation = true; + }, + WrAnimationType::Transform => { + transform_binding = Some(( + PropertyBinding::Binding( + PropertyBindingKey::new(anim.id), + // Same as above opacity case. + transform_ref + .map(|info| info.transform) + .unwrap_or_else(LayoutTransform::identity), + ), + anim.key, + )); + }, + _ => unreachable!("{:?} should not create a stacking context", anim.effect_type), + } + } + + if let Some(opacity) = opacity_ref { + if !has_opacity_animation && *opacity < 1.0 { + filters.push(FilterOp::Opacity(PropertyBinding::Value(*opacity), *opacity)); + } + } + + let mut wr_spatial_id = spatial_id.to_webrender(state.pipeline_id); + let wr_clip_id = params.clip.to_webrender(state.pipeline_id); + + let mut origin = bounds.min; + + // Note: 0 has special meaning in WR land, standing for ROOT_REFERENCE_FRAME. + // However, it is never returned by `push_reference_frame`, and we need to return + // an option here across FFI, so we take that 0 value for the None semantics. + // This is resolved into proper `Maybe` inside `WebRenderAPI::PushStackingContext`. + let mut result = WrSpatialId { id: 0 }; + if let Some(transform_binding) = transform_binding { + let scrolling_relative_to = match unsafe { params.scrolling_relative_to.as_ref() } { + Some(scroll_id) => { + debug_assert_eq!(params.reference_frame_kind, WrReferenceFrameKind::Perspective); + Some(ExternalScrollId(*scroll_id, state.pipeline_id)) + }, + None => None, + }; + + let reference_frame_kind = match params.reference_frame_kind { + WrReferenceFrameKind::Transform => ReferenceFrameKind::Transform { + is_2d_scale_translation: params.is_2d_scale_translation, + should_snap: params.should_snap, + paired_with_perspective: params.paired_with_perspective, + }, + WrReferenceFrameKind::Perspective => ReferenceFrameKind::Perspective { scrolling_relative_to }, + }; + wr_spatial_id = state.frame_builder.dl_builder.push_reference_frame( + origin, + wr_spatial_id, + params.transform_style, + transform_binding.0, + reference_frame_kind, + transform_binding.1, + ); + + origin = LayoutPoint::zero(); + result.id = wr_spatial_id.0; + assert_ne!(wr_spatial_id.0, 0); + } else if let Some(data) = computed_ref { + let rotation = match data.rotation { + WrRotation::Degree0 => Rotation::Degree0, + WrRotation::Degree90 => Rotation::Degree90, + WrRotation::Degree180 => Rotation::Degree180, + WrRotation::Degree270 => Rotation::Degree270, + }; + wr_spatial_id = state.frame_builder.dl_builder.push_computed_frame( + origin, + wr_spatial_id, + Some(data.scale_from), + data.vertical_flip, + rotation, + data.key, + ); + + origin = LayoutPoint::zero(); + result.id = wr_spatial_id.0; + assert_ne!(wr_spatial_id.0, 0); + } + + state.frame_builder.dl_builder.push_stacking_context( + origin, + wr_spatial_id, + params.prim_flags, + wr_clip_id, + params.transform_style, + params.mix_blend_mode, + &filters, + &r_filter_datas, + &[], + glyph_raster_space, + params.flags, + ); + + result +} + +#[no_mangle] +pub extern "C" fn wr_dp_pop_stacking_context(state: &mut WrState, is_reference_frame: bool) { + debug_assert!(unsafe { !is_in_render_thread() }); + state.frame_builder.dl_builder.pop_stacking_context(); + if is_reference_frame { + state.frame_builder.dl_builder.pop_reference_frame(); + } +} + +#[no_mangle] +pub extern "C" fn wr_dp_define_clipchain( + state: &mut WrState, + parent_clipchain_id: *const u64, + clips: *const WrClipId, + clips_count: usize, +) -> u64 { + debug_assert!(unsafe { is_in_main_thread() }); + let parent = unsafe { parent_clipchain_id.as_ref() }.map(|id| ClipChainId(*id, state.pipeline_id)); + + let pipeline_id = state.pipeline_id; + let clips = unsafe { make_slice(clips, clips_count) } + .iter() + .map(|clip_id| clip_id.to_webrender(pipeline_id)); + + let clipchain_id = state.frame_builder.dl_builder.define_clip_chain(parent, clips); + assert!(clipchain_id.1 == state.pipeline_id); + clipchain_id.0 +} + +#[no_mangle] +pub extern "C" fn wr_dp_define_image_mask_clip_with_parent_clip_chain( + state: &mut WrState, + space: WrSpatialId, + mask: ImageMask, + points: *const LayoutPoint, + point_count: usize, + fill_rule: FillRule, +) -> WrClipId { + debug_assert!(unsafe { is_in_main_thread() }); + + let c_points = unsafe { make_slice(points, point_count) }; + let points: Vec = c_points.iter().copied().collect(); + + let clip_id = state.frame_builder.dl_builder.define_clip_image_mask( + space.to_webrender(state.pipeline_id), + mask, + &points, + fill_rule, + ); + WrClipId::from_webrender(clip_id) +} + +#[no_mangle] +pub extern "C" fn wr_dp_define_rounded_rect_clip( + state: &mut WrState, + space: WrSpatialId, + complex: ComplexClipRegion, +) -> WrClipId { + debug_assert!(unsafe { is_in_main_thread() }); + + let clip_id = state + .frame_builder + .dl_builder + .define_clip_rounded_rect(space.to_webrender(state.pipeline_id), complex); + WrClipId::from_webrender(clip_id) +} + +#[no_mangle] +pub extern "C" fn wr_dp_define_rect_clip(state: &mut WrState, space: WrSpatialId, clip_rect: LayoutRect) -> WrClipId { + debug_assert!(unsafe { is_in_main_thread() }); + + let clip_id = state + .frame_builder + .dl_builder + .define_clip_rect(space.to_webrender(state.pipeline_id), clip_rect); + WrClipId::from_webrender(clip_id) +} + +#[no_mangle] +pub extern "C" fn wr_dp_define_sticky_frame( + state: &mut WrState, + parent_spatial_id: WrSpatialId, + content_rect: LayoutRect, + top_margin: *const f32, + right_margin: *const f32, + bottom_margin: *const f32, + left_margin: *const f32, + vertical_bounds: StickyOffsetBounds, + horizontal_bounds: StickyOffsetBounds, + applied_offset: LayoutVector2D, + key: SpatialTreeItemKey, +) -> WrSpatialId { + assert!(unsafe { is_in_main_thread() }); + let spatial_id = state.frame_builder.dl_builder.define_sticky_frame( + parent_spatial_id.to_webrender(state.pipeline_id), + content_rect, + SideOffsets2D::new( + unsafe { top_margin.as_ref() }.cloned(), + unsafe { right_margin.as_ref() }.cloned(), + unsafe { bottom_margin.as_ref() }.cloned(), + unsafe { left_margin.as_ref() }.cloned(), + ), + vertical_bounds, + horizontal_bounds, + applied_offset, + key, + ); + + WrSpatialId { id: spatial_id.0 } +} + +#[no_mangle] +pub extern "C" fn wr_dp_define_scroll_layer( + state: &mut WrState, + external_scroll_id: u64, + parent: &WrSpatialId, + content_rect: LayoutRect, + clip_rect: LayoutRect, + scroll_offset: LayoutVector2D, + scroll_offset_generation: APZScrollGeneration, + has_scroll_linked_effect: HasScrollLinkedEffect, + key: SpatialTreeItemKey, +) -> WrSpatialId { + assert!(unsafe { is_in_main_thread() }); + + let space_and_clip = state.frame_builder.dl_builder.define_scroll_frame( + parent.to_webrender(state.pipeline_id), + ExternalScrollId(external_scroll_id, state.pipeline_id), + content_rect, + clip_rect, + scroll_offset, + scroll_offset_generation, + has_scroll_linked_effect, + key, + ); + + WrSpatialId::from_webrender(space_and_clip) +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_iframe( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + _is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + pipeline_id: WrPipelineId, + ignore_missing_pipeline: bool, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + state.frame_builder.dl_builder.push_iframe( + rect, + clip, + &parent.to_webrender(state.pipeline_id), + pipeline_id, + ignore_missing_pipeline, + ); +} + +// A helper fn to construct a PrimitiveFlags +fn prim_flags(is_backface_visible: bool, prefer_compositor_surface: bool) -> PrimitiveFlags { + let mut flags = PrimitiveFlags::empty(); + + if is_backface_visible { + flags |= PrimitiveFlags::IS_BACKFACE_VISIBLE; + } + + if prefer_compositor_surface { + flags |= PrimitiveFlags::PREFER_COMPOSITOR_SURFACE; + } + + flags +} + +fn prim_flags2( + is_backface_visible: bool, + prefer_compositor_surface: bool, + supports_external_compositing: bool, +) -> PrimitiveFlags { + let mut flags = PrimitiveFlags::empty(); + + if supports_external_compositing { + flags |= PrimitiveFlags::SUPPORTS_EXTERNAL_COMPOSITOR_SURFACE; + } + + flags | prim_flags(is_backface_visible, prefer_compositor_surface) +} + +fn common_item_properties_for_rect( + state: &mut WrState, + clip_rect: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, +) -> CommonItemProperties { + let space_and_clip = parent.to_webrender(state.pipeline_id); + + CommonItemProperties { + // NB: the damp-e10s talos-test will frequently crash on startup if we + // early-return here for empty rects. I couldn't figure out why, but + // it's pretty harmless to feed these through, so, uh, we do? + clip_rect, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + } +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_rect( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + force_antialiasing: bool, + is_checkerboard: bool, + parent: &WrSpaceAndClipChain, + color: ColorF, +) { + debug_assert!(unsafe { !is_in_render_thread() }); + + let mut prim_info = common_item_properties_for_rect(state, clip, is_backface_visible, parent); + if force_antialiasing { + prim_info.flags |= PrimitiveFlags::ANTIALISED; + } + if is_checkerboard { + prim_info.flags |= PrimitiveFlags::CHECKERBOARD_BACKGROUND; + } + + state.frame_builder.dl_builder.push_rect(&prim_info, rect, color); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_rect_with_animation( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + color: ColorF, + animation: *const WrAnimationProperty, +) { + debug_assert!(unsafe { !is_in_render_thread() }); + + let prim_info = common_item_properties_for_rect(state, clip, is_backface_visible, parent); + + let anim = unsafe { animation.as_ref() }; + if let Some(anim) = anim { + debug_assert!(anim.id > 0); + match anim.effect_type { + WrAnimationType::BackgroundColor => state.frame_builder.dl_builder.push_rect_with_animation( + &prim_info, + rect, + PropertyBinding::Binding(PropertyBindingKey::new(anim.id), color), + ), + _ => unreachable!("Didn't expect {:?} animation", anim.effect_type), + } + } +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_backdrop_filter( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + filters: *const FilterOp, + filter_count: usize, + filter_datas: *const WrFilterData, + filter_datas_count: usize, +) { + debug_assert!(unsafe { !is_in_render_thread() }); + + let c_filters = unsafe { make_slice(filters, filter_count) }; + let filters: Vec = c_filters.iter().copied().collect(); + + let c_filter_datas = unsafe { make_slice(filter_datas, filter_datas_count) }; + let filter_datas: Vec = c_filter_datas + .iter() + .map(|c_filter_data| FilterData { + func_r_type: c_filter_data.funcR_type, + r_values: unsafe { make_slice(c_filter_data.R_values, c_filter_data.R_values_count).to_vec() }, + func_g_type: c_filter_data.funcG_type, + g_values: unsafe { make_slice(c_filter_data.G_values, c_filter_data.G_values_count).to_vec() }, + func_b_type: c_filter_data.funcB_type, + b_values: unsafe { make_slice(c_filter_data.B_values, c_filter_data.B_values_count).to_vec() }, + func_a_type: c_filter_data.funcA_type, + a_values: unsafe { make_slice(c_filter_data.A_values, c_filter_data.A_values_count).to_vec() }, + }) + .collect(); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let clip_rect = clip.intersection(&rect); + if clip_rect.is_none() { + return; + } + + let prim_info = CommonItemProperties { + clip_rect: clip_rect.unwrap(), + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_backdrop_filter(&prim_info, &filters, &filter_datas, &[]); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_clear_rect( + state: &mut WrState, + rect: LayoutRect, + clip_rect: LayoutRect, + parent: &WrSpaceAndClipChain, +) { + debug_assert!(unsafe { !is_in_render_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(true, /* prefer_compositor_surface */ false), + }; + + state.frame_builder.dl_builder.push_clear_rect(&prim_info, rect); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_hit_test( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + scroll_id: u64, + hit_info: u16, +) { + debug_assert!(unsafe { !is_in_render_thread() }); + + let clip_rect = clip.intersection(&rect); + if clip_rect.is_none() { + return; + } + let tag = (scroll_id, hit_info); + + let spatial_id = parent.space.to_webrender(state.pipeline_id); + + let clip_chain_id = if parent.clip_chain == ROOT_CLIP_CHAIN { + ClipChainId::INVALID + } else { + ClipChainId(parent.clip_chain, state.pipeline_id) + }; + + state.frame_builder.dl_builder.push_hit_test( + clip_rect.unwrap(), + clip_chain_id, + spatial_id, + prim_flags(is_backface_visible, false), + tag, + ); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_image( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + force_antialiasing: bool, + parent: &WrSpaceAndClipChain, + image_rendering: ImageRendering, + key: WrImageKey, + premultiplied_alpha: bool, + color: ColorF, + prefer_compositor_surface: bool, + supports_external_compositing: bool, +) { + debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let mut flags = prim_flags2( + is_backface_visible, + prefer_compositor_surface, + supports_external_compositing, + ); + + if force_antialiasing { + flags |= PrimitiveFlags::ANTIALISED; + } + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags, + }; + + let alpha_type = if premultiplied_alpha { + AlphaType::PremultipliedAlpha + } else { + AlphaType::Alpha + }; + + state + .frame_builder + .dl_builder + .push_image(&prim_info, bounds, image_rendering, alpha_type, key, color); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_repeating_image( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + stretch_size: LayoutSize, + tile_spacing: LayoutSize, + image_rendering: ImageRendering, + key: WrImageKey, + premultiplied_alpha: bool, + color: ColorF, +) { + debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + let alpha_type = if premultiplied_alpha { + AlphaType::PremultipliedAlpha + } else { + AlphaType::Alpha + }; + + state.frame_builder.dl_builder.push_repeating_image( + &prim_info, + bounds, + stretch_size, + tile_spacing, + image_rendering, + alpha_type, + key, + color, + ); +} + +/// Push a 3 planar yuv image. +#[no_mangle] +pub extern "C" fn wr_dp_push_yuv_planar_image( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + image_key_0: WrImageKey, + image_key_1: WrImageKey, + image_key_2: WrImageKey, + color_depth: WrColorDepth, + color_space: WrYuvColorSpace, + color_range: WrColorRange, + image_rendering: ImageRendering, + prefer_compositor_surface: bool, + supports_external_compositing: bool, +) { + debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags2( + is_backface_visible, + prefer_compositor_surface, + supports_external_compositing, + ), + }; + + state.frame_builder.dl_builder.push_yuv_image( + &prim_info, + bounds, + YuvData::PlanarYCbCr(image_key_0, image_key_1, image_key_2), + color_depth, + color_space, + color_range, + image_rendering, + ); +} + +/// Push a 2 planar NV12 image. +#[no_mangle] +pub extern "C" fn wr_dp_push_yuv_NV12_image( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + image_key_0: WrImageKey, + image_key_1: WrImageKey, + color_depth: WrColorDepth, + color_space: WrYuvColorSpace, + color_range: WrColorRange, + image_rendering: ImageRendering, + prefer_compositor_surface: bool, + supports_external_compositing: bool, +) { + debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags2( + is_backface_visible, + prefer_compositor_surface, + supports_external_compositing, + ), + }; + + state.frame_builder.dl_builder.push_yuv_image( + &prim_info, + bounds, + YuvData::NV12(image_key_0, image_key_1), + color_depth, + color_space, + color_range, + image_rendering, + ); +} + +/// Push a 2 planar P010 image. +#[no_mangle] +pub extern "C" fn wr_dp_push_yuv_P010_image( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + image_key_0: WrImageKey, + image_key_1: WrImageKey, + color_depth: WrColorDepth, + color_space: WrYuvColorSpace, + color_range: WrColorRange, + image_rendering: ImageRendering, + prefer_compositor_surface: bool, + supports_external_compositing: bool, +) { + debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags2( + is_backface_visible, + prefer_compositor_surface, + supports_external_compositing, + ), + }; + + state.frame_builder.dl_builder.push_yuv_image( + &prim_info, + bounds, + YuvData::P010(image_key_0, image_key_1), + color_depth, + color_space, + color_range, + image_rendering, + ); +} + +/// Push a yuv interleaved image. +#[no_mangle] +pub extern "C" fn wr_dp_push_yuv_interleaved_image( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + image_key_0: WrImageKey, + color_depth: WrColorDepth, + color_space: WrYuvColorSpace, + color_range: WrColorRange, + image_rendering: ImageRendering, + prefer_compositor_surface: bool, + supports_external_compositing: bool, +) { + debug_assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags2( + is_backface_visible, + prefer_compositor_surface, + supports_external_compositing, + ), + }; + + state.frame_builder.dl_builder.push_yuv_image( + &prim_info, + bounds, + YuvData::InterleavedYCbCr(image_key_0), + color_depth, + color_space, + color_range, + image_rendering, + ); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_text( + state: &mut WrState, + bounds: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + color: ColorF, + font_key: WrFontInstanceKey, + glyphs: *const GlyphInstance, + glyph_count: u32, + glyph_options: *const GlyphOptions, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let glyph_slice = unsafe { make_slice(glyphs, glyph_count as usize) }; + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + spatial_id: space_and_clip.spatial_id, + clip_chain_id: space_and_clip.clip_chain_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_text(&prim_info, bounds, &glyph_slice, font_key, color, unsafe { + glyph_options.as_ref().cloned() + }); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_shadow( + state: &mut WrState, + _bounds: LayoutRect, + _clip: LayoutRect, + _is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + shadow: Shadow, + should_inflate: bool, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + state + .frame_builder + .dl_builder + .push_shadow(&parent.to_webrender(state.pipeline_id), shadow, should_inflate); +} + +#[no_mangle] +pub extern "C" fn wr_dp_pop_all_shadows(state: &mut WrState) { + debug_assert!(unsafe { is_in_main_thread() }); + + state.frame_builder.dl_builder.pop_all_shadows(); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_line( + state: &mut WrState, + clip: &LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + bounds: &LayoutRect, + wavy_line_thickness: f32, + orientation: LineOrientation, + color: &ColorF, + style: LineStyle, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: *clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_line(&prim_info, bounds, wavy_line_thickness, orientation, color, style); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_border( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + do_aa: AntialiasBorder, + widths: LayoutSideOffsets, + top: BorderSide, + right: BorderSide, + bottom: BorderSide, + left: BorderSide, + radius: BorderRadius, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let border_details = BorderDetails::Normal(NormalBorder { + left, + right, + top, + bottom, + radius, + do_aa: do_aa == AntialiasBorder::Yes, + }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_border(&prim_info, rect, widths, border_details); +} + +#[repr(C)] +pub struct WrBorderImage { + widths: LayoutSideOffsets, + image: WrImageKey, + image_rendering: ImageRendering, + width: i32, + height: i32, + fill: bool, + slice: DeviceIntSideOffsets, + repeat_horizontal: RepeatMode, + repeat_vertical: RepeatMode, +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_border_image( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + params: &WrBorderImage, +) { + debug_assert!(unsafe { is_in_main_thread() }); + let border_details = BorderDetails::NinePatch(NinePatchBorder { + source: NinePatchBorderSource::Image(params.image, params.image_rendering), + width: params.width, + height: params.height, + slice: params.slice, + fill: params.fill, + repeat_horizontal: params.repeat_horizontal, + repeat_vertical: params.repeat_vertical, + }); + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_border(&prim_info, rect, params.widths, border_details); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_border_gradient( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + widths: LayoutSideOffsets, + width: i32, + height: i32, + fill: bool, + slice: DeviceIntSideOffsets, + start_point: LayoutPoint, + end_point: LayoutPoint, + stops: *const GradientStop, + stops_count: usize, + extend_mode: ExtendMode, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let stops_slice = unsafe { make_slice(stops, stops_count) }; + let stops_vector = stops_slice.to_owned(); + + let gradient = state + .frame_builder + .dl_builder + .create_gradient(start_point, end_point, stops_vector, extend_mode); + + let border_details = BorderDetails::NinePatch(NinePatchBorder { + source: NinePatchBorderSource::Gradient(gradient), + width, + height, + slice, + fill, + repeat_horizontal: RepeatMode::Stretch, + repeat_vertical: RepeatMode::Stretch, + }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_border(&prim_info, rect, widths, border_details); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_border_radial_gradient( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + widths: LayoutSideOffsets, + fill: bool, + center: LayoutPoint, + radius: LayoutSize, + stops: *const GradientStop, + stops_count: usize, + extend_mode: ExtendMode, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let stops_slice = unsafe { make_slice(stops, stops_count) }; + let stops_vector = stops_slice.to_owned(); + + let slice = SideOffsets2D::new( + widths.top as i32, + widths.right as i32, + widths.bottom as i32, + widths.left as i32, + ); + + let gradient = state + .frame_builder + .dl_builder + .create_radial_gradient(center, radius, stops_vector, extend_mode); + + let border_details = BorderDetails::NinePatch(NinePatchBorder { + source: NinePatchBorderSource::RadialGradient(gradient), + width: rect.width() as i32, + height: rect.height() as i32, + slice, + fill, + repeat_horizontal: RepeatMode::Stretch, + repeat_vertical: RepeatMode::Stretch, + }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_border(&prim_info, rect, widths, border_details); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_border_conic_gradient( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + widths: LayoutSideOffsets, + fill: bool, + center: LayoutPoint, + angle: f32, + stops: *const GradientStop, + stops_count: usize, + extend_mode: ExtendMode, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let stops_slice = unsafe { make_slice(stops, stops_count) }; + let stops_vector = stops_slice.to_owned(); + + let slice = SideOffsets2D::new( + widths.top as i32, + widths.right as i32, + widths.bottom as i32, + widths.left as i32, + ); + + let gradient = state + .frame_builder + .dl_builder + .create_conic_gradient(center, angle, stops_vector, extend_mode); + + let border_details = BorderDetails::NinePatch(NinePatchBorder { + source: NinePatchBorderSource::ConicGradient(gradient), + width: rect.width() as i32, + height: rect.height() as i32, + slice, + fill, + repeat_horizontal: RepeatMode::Stretch, + repeat_vertical: RepeatMode::Stretch, + }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_border(&prim_info, rect, widths, border_details); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_linear_gradient( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + start_point: LayoutPoint, + end_point: LayoutPoint, + stops: *const GradientStop, + stops_count: usize, + extend_mode: ExtendMode, + tile_size: LayoutSize, + tile_spacing: LayoutSize, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let stops_slice = unsafe { make_slice(stops, stops_count) }; + let stops_vector = stops_slice.to_owned(); + + let gradient = state + .frame_builder + .dl_builder + .create_gradient(start_point, end_point, stops_vector, extend_mode); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_gradient(&prim_info, rect, gradient, tile_size, tile_spacing); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_radial_gradient( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + center: LayoutPoint, + radius: LayoutSize, + stops: *const GradientStop, + stops_count: usize, + extend_mode: ExtendMode, + tile_size: LayoutSize, + tile_spacing: LayoutSize, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let stops_slice = unsafe { make_slice(stops, stops_count) }; + let stops_vector = stops_slice.to_owned(); + + let gradient = state + .frame_builder + .dl_builder + .create_radial_gradient(center, radius, stops_vector, extend_mode); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_radial_gradient(&prim_info, rect, gradient, tile_size, tile_spacing); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_conic_gradient( + state: &mut WrState, + rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + center: LayoutPoint, + angle: f32, + stops: *const GradientStop, + stops_count: usize, + extend_mode: ExtendMode, + tile_size: LayoutSize, + tile_spacing: LayoutSize, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let stops_slice = unsafe { make_slice(stops, stops_count) }; + let stops_vector = stops_slice.to_owned(); + + let gradient = state + .frame_builder + .dl_builder + .create_conic_gradient(center, angle, stops_vector, extend_mode); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state + .frame_builder + .dl_builder + .push_conic_gradient(&prim_info, rect, gradient, tile_size, tile_spacing); +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_box_shadow( + state: &mut WrState, + _rect: LayoutRect, + clip: LayoutRect, + is_backface_visible: bool, + parent: &WrSpaceAndClipChain, + box_bounds: LayoutRect, + offset: LayoutVector2D, + color: ColorF, + blur_radius: f32, + spread_radius: f32, + border_radius: BorderRadius, + clip_mode: BoxShadowClipMode, +) { + debug_assert!(unsafe { is_in_main_thread() }); + + let space_and_clip = parent.to_webrender(state.pipeline_id); + + let prim_info = CommonItemProperties { + clip_rect: clip, + clip_chain_id: space_and_clip.clip_chain_id, + spatial_id: space_and_clip.spatial_id, + flags: prim_flags(is_backface_visible, /* prefer_compositor_surface */ false), + }; + + state.frame_builder.dl_builder.push_box_shadow( + &prim_info, + box_bounds, + offset, + color, + blur_radius, + spread_radius, + border_radius, + clip_mode, + ); +} + +#[no_mangle] +pub extern "C" fn wr_dp_start_item_group(state: &mut WrState) { + state.frame_builder.dl_builder.start_item_group(); +} + +#[no_mangle] +pub extern "C" fn wr_dp_cancel_item_group(state: &mut WrState, discard: bool) { + state.frame_builder.dl_builder.cancel_item_group(discard); +} + +#[no_mangle] +pub extern "C" fn wr_dp_finish_item_group(state: &mut WrState, key: ItemKey) -> bool { + state.frame_builder.dl_builder.finish_item_group(key) +} + +#[no_mangle] +pub extern "C" fn wr_dp_push_reuse_items(state: &mut WrState, key: ItemKey) { + state.frame_builder.dl_builder.push_reuse_items(key); +} + +#[no_mangle] +pub extern "C" fn wr_dp_set_cache_size(state: &mut WrState, cache_size: usize) { + state.frame_builder.dl_builder.set_cache_size(cache_size); +} + +#[no_mangle] +pub extern "C" fn wr_dump_display_list( + state: &mut WrState, + indent: usize, + start: *const usize, + end: *const usize, +) -> usize { + let start = unsafe { start.as_ref().cloned() }; + let end = unsafe { end.as_ref().cloned() }; + let range = Range { start, end }; + let mut sink = Cursor::new(Vec::new()); + let index = state + .frame_builder + .dl_builder + .emit_display_list(indent, range, &mut sink); + + // For Android, dump to logcat instead of stderr. This is the same as + // what printf_stderr does on the C++ side. + + #[cfg(target_os = "android")] + unsafe { + let gecko = CString::new("Gecko").unwrap(); + let sink = CString::new(sink.into_inner()).unwrap(); + __android_log_write(4 /* info */, gecko.as_ptr(), sink.as_ptr()); + } + + #[cfg(not(target_os = "android"))] + eprint!("{}", String::from_utf8(sink.into_inner()).unwrap()); + + index +} + +#[no_mangle] +pub extern "C" fn wr_dump_serialized_display_list(state: &mut WrState) { + state.frame_builder.dl_builder.dump_serialized_display_list(); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_begin_builder(state: &mut WrState) { + state.frame_builder.dl_builder.begin(); +} + +#[no_mangle] +pub unsafe extern "C" fn wr_api_end_builder( + state: &mut WrState, + dl_descriptor: &mut BuiltDisplayListDescriptor, + dl_items_data: &mut WrVecU8, + dl_cache_data: &mut WrVecU8, + dl_spatial_tree: &mut WrVecU8, +) { + let (_, dl) = state.frame_builder.dl_builder.end(); + let (payload, descriptor) = dl.into_data(); + *dl_items_data = WrVecU8::from_vec(payload.items_data); + *dl_cache_data = WrVecU8::from_vec(payload.cache_data); + *dl_spatial_tree = WrVecU8::from_vec(payload.spatial_tree); + *dl_descriptor = descriptor; +} + +#[repr(C)] +pub struct HitResult { + pipeline_id: WrPipelineId, + scroll_id: u64, + animation_id: u64, + hit_info: u16, +} + +#[no_mangle] +pub extern "C" fn wr_api_hit_test(dh: &mut DocumentHandle, point: WorldPoint, out_results: &mut ThinVec) { + let result = dh.ensure_hit_tester().hit_test(point); + for item in &result.items { + out_results.push(HitResult { + pipeline_id: item.pipeline, + scroll_id: item.tag.0, + animation_id: item.animation_id, + hit_info: item.tag.1, + }); + } +} + +pub type VecU8 = Vec; +pub type ArcVecU8 = Arc; + +#[no_mangle] +pub extern "C" fn wr_add_ref_arc(arc: &ArcVecU8) -> *const VecU8 { + Arc::into_raw(arc.clone()) +} + +#[no_mangle] +pub unsafe extern "C" fn wr_dec_ref_arc(arc: *const VecU8) { + Arc::from_raw(arc); +} + +// TODO: nical +// Update for the new blob image interface changes. +// +extern "C" { + // TODO: figure out the API for tiled blob images. + pub fn wr_moz2d_render_cb( + blob: ByteSlice, + format: ImageFormat, + render_rect: &LayoutIntRect, + visible_rect: &DeviceIntRect, + tile_size: u16, + tile_offset: &TileOffset, + dirty_rect: Option<&LayoutIntRect>, + output: MutByteSlice, + ) -> bool; +} + +#[no_mangle] +pub extern "C" fn wr_root_scroll_node_id() -> WrSpatialId { + // The PipelineId doesn't matter here, since we just want the numeric part of the id + // produced for any given root reference frame. + WrSpatialId { + id: SpatialId::root_scroll_node(PipelineId(0, 0)).0, + } +} + +#[no_mangle] +pub extern "C" fn wr_root_clip_id() -> WrClipId { + // The PipelineId doesn't matter here, since we just want the numeric part of the id + // produced for any given root reference frame. + WrClipId::from_webrender(ClipId::root(PipelineId(0, 0))) +} + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct WrClipId { + id: usize, +} + +impl WrClipId { + fn to_webrender(&self, pipeline_id: WrPipelineId) -> ClipId { + ClipId(self.id, pipeline_id) + } + + fn from_webrender(clip_id: ClipId) -> Self { + WrClipId { id: clip_id.0 } + } +} + +#[repr(C)] +#[derive(Clone, Copy)] +pub struct WrSpatialId { + id: usize, +} + +impl WrSpatialId { + fn to_webrender(&self, pipeline_id: WrPipelineId) -> SpatialId { + SpatialId::new(self.id, pipeline_id) + } + + fn from_webrender(id: SpatialId) -> Self { + WrSpatialId { id: id.0 } + } +} + +#[no_mangle] +pub unsafe extern "C" fn wr_device_delete(device: *mut Device) { + mem::drop(Box::from_raw(device)); +} + +// Call MakeCurrent before this. +#[no_mangle] +pub extern "C" fn wr_shaders_new( + gl_context: *mut c_void, + program_cache: Option<&mut WrProgramCache>, + precache_shaders: bool, +) -> *mut WrShaders { + let mut device = wr_device_new(gl_context, program_cache); + + let precache_flags = if precache_shaders || env_var_to_bool("MOZ_WR_PRECACHE_SHADERS") { + ShaderPrecacheFlags::FULL_COMPILE + } else { + ShaderPrecacheFlags::ASYNC_COMPILE + }; + + let opts = WebRenderOptions { + precache_flags, + ..Default::default() + }; + + let gl_type = device.gl().get_type(); + device.begin_frame(); + + let shaders = Rc::new(RefCell::new(match Shaders::new(&mut device, gl_type, &opts) { + Ok(shaders) => shaders, + Err(e) => { + warn!(" Failed to create a Shaders: {:?}", e); + let msg = CString::new(format!("wr_shaders_new: {:?}", e)).unwrap(); + unsafe { + gfx_critical_note(msg.as_ptr()); + } + return ptr::null_mut(); + }, + })); + + let shaders = WrShaders(shaders); + + device.end_frame(); + Box::into_raw(Box::new(shaders)) +} + +#[no_mangle] +pub unsafe extern "C" fn wr_shaders_delete(shaders: *mut WrShaders, gl_context: *mut c_void) { + let mut device = wr_device_new(gl_context, None); + let shaders = Box::from_raw(shaders); + if let Ok(shaders) = Rc::try_unwrap(shaders.0) { + shaders.into_inner().deinit(&mut device); + } + // let shaders go out of scope and get dropped +} + +#[no_mangle] +pub unsafe extern "C" fn wr_program_cache_report_memory( + cache: *const WrProgramCache, + size_of_op: VoidPtrToSizeFn, +) -> usize { + (*cache).program_cache.report_memory(size_of_op) +} diff --git a/gfx/webrender_bindings/src/lib.rs b/gfx/webrender_bindings/src/lib.rs new file mode 100644 index 0000000000..9e94302e0f --- /dev/null +++ b/gfx/webrender_bindings/src/lib.rs @@ -0,0 +1,43 @@ +/* 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/. */ + +#![deny(warnings)] + +extern crate app_units; +extern crate bincode; +extern crate euclid; +extern crate fxhash; +extern crate gecko_profiler; +extern crate gleam; +extern crate nsstring; +extern crate num_cpus; +extern crate rayon; +extern crate swgl; +extern crate thin_vec; +extern crate tracy_rs; +extern crate uuid; +extern crate webrender; +extern crate wr_malloc_size_of; + +#[macro_use] +extern crate log; + +#[cfg(target_os = "windows")] +extern crate dwrote; +#[cfg(target_os = "windows")] +extern crate winapi; + +#[cfg(target_os = "macos")] +extern crate core_foundation; +#[cfg(target_os = "macos")] +extern crate core_graphics; +#[cfg(target_os = "macos")] +extern crate foreign_types; + +mod program_cache; + +#[allow(non_snake_case)] +pub mod bindings; +pub mod moz2d_renderer; +mod swgl_bindings; diff --git a/gfx/webrender_bindings/src/moz2d_renderer.rs b/gfx/webrender_bindings/src/moz2d_renderer.rs new file mode 100644 index 0000000000..4c7a32c912 --- /dev/null +++ b/gfx/webrender_bindings/src/moz2d_renderer.rs @@ -0,0 +1,871 @@ +/* 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/. */ +#![deny(missing_docs)] + +//! Provides the webrender-side implementation of gecko blob images. +//! +//! Pretty much this is just a shim that calls back into Moz2DImageRenderer, but +//! it also handles merging "partial" blob images (see `merge_blob_images`) and +//! registering fonts found in the blob (see `prepare_request`). + +use bindings::{ + gecko_profiler_end_marker, gecko_profiler_start_marker, wr_moz2d_render_cb, ArcVecU8, ByteSlice, MutByteSlice, +}; +use gecko_profiler::gecko_profiler_label; +use rayon::prelude::*; +use rayon::ThreadPool; +use webrender::api::units::{BlobDirtyRect, BlobToDeviceTranslation, DeviceIntRect}; +use webrender::api::*; + +use euclid::point2; +use std; +use std::collections::btree_map::BTreeMap; +use std::collections::hash_map; +use std::collections::hash_map::HashMap; +use std::collections::Bound::Included; +use std::i32; +use std::mem; +use std::os::raw::c_void; +use std::ptr; +use std::sync::Arc; + +#[cfg(target_os = "windows")] +use dwrote; + +#[cfg(target_os = "macos")] +use core_foundation::string::CFString; +#[cfg(target_os = "macos")] +use core_graphics::font::CGFont; +#[cfg(target_os = "macos")] +use foreign_types::ForeignType; + +#[cfg(not(any(target_os = "macos", target_os = "windows")))] +use std::ffi::CString; +#[cfg(not(any(target_os = "macos", target_os = "windows")))] +use std::os::unix::ffi::OsStrExt; + +/// Local print-debugging utility +macro_rules! dlog { + ($($e:expr),*) => { {$(let _ = $e;)*} } + //($($t:tt)*) => { println!($($t)*) } +} + +/// Debug prints a blob's item bounds, indicating whether the bounds are dirty or not. +fn dump_bounds(blob: &[u8], dirty_rect: DeviceIntRect) { + let mut index = BlobReader::new(blob); + while index.reader.has_more() { + let e = index.read_entry(); + dlog!( + " {:?} {}", + e.bounds, + if dirty_rect.contains_box(&e.bounds) { "*" } else { "" } + ); + } +} + +/// Debug prints a blob's metadata. +fn dump_index(blob: &[u8]) { + let mut index = BlobReader::new(blob); + // we might get an empty result here because sub groups are not tightly bound + // and we'll sometimes have display items that end up with empty bounds in + // the blob image. + while index.reader.has_more() { + let e = index.read_entry(); + dlog!("result bounds: {} {} {:?}", e.end, e.extra_end, e.bounds); + } +} + +/// Handles the interpretation and rasterization of gecko-based (moz2d) WR blob images. +pub struct Moz2dBlobImageHandler { + workers: Arc, + workers_low_priority: Arc, + blob_commands: HashMap, + enable_multithreading: bool, +} + +/// Transmute some bytes into a value. +/// +/// FIXME: kill this with fire and/or do a super robust security audit +unsafe fn convert_from_bytes(slice: &[u8]) -> T { + assert!(mem::size_of::() <= slice.len()); + ptr::read_unaligned(slice.as_ptr() as *const T) +} + +/// Transmute a value into some bytes. +fn convert_to_bytes(x: &T) -> &[u8] { + unsafe { + let ip: *const T = x; + let bp: *const u8 = ip as *const _; + ::std::slice::from_raw_parts(bp, mem::size_of::()) + } +} + +/// A simple helper for deserializing a bunch of transmuted POD data from bytes. +struct BufReader<'a> { + /// The buffer to read from. + buf: &'a [u8], + /// Where we currently are reading from. + pos: usize, +} + +impl<'a> BufReader<'a> { + /// Creates a reader over the given input. + fn new(buf: &'a [u8]) -> BufReader<'a> { + BufReader { buf, pos: 0 } + } + + /// Transmute-deserializes a value of type T from the stream. + /// + /// !!! SUPER DANGEROUS !!! + /// + /// To limit the scope of this unsafety, please don't call this directly. + /// Make a helper method for each whitelisted type. + unsafe fn read(&mut self) -> T { + let ret = convert_from_bytes(&self.buf[self.pos..]); + self.pos += mem::size_of::(); + ret + } + + /// Deserializes a BlobFont. + fn read_blob_font(&mut self) -> BlobFont { + unsafe { self.read::() } + } + + /// Deserializes a usize. + fn read_usize(&mut self) -> usize { + unsafe { self.read::() } + } + + /// Deserializes a rectangle. + fn read_box(&mut self) -> DeviceIntRect { + unsafe { self.read::() } + } + + /// Returns whether the buffer has more data to deserialize. + fn has_more(&self) -> bool { + self.pos < self.buf.len() + } +} + +/// Reads the metadata of a blob image. +/// +/// Blob stream format: +/// { data[..], index[..], offset in the stream of the index array } +/// +/// An 'item' has 'data' and 'extra_data' +/// - In our case the 'data' is the stream produced by DrawTargetRecording +/// and the 'extra_data' includes things like webrender font keys +/// +/// The index is an array of entries of the following form: +/// { end, extra_end, bounds } +/// +/// - end is the offset of the end of an item's data +/// an item's data goes from the begining of the stream or +/// the begining of the last item til end +/// - extra_end is the offset of the end of an item's extra data +/// an item's extra data goes from 'end' until 'extra_end' +/// - bounds is a set of 4 ints { min.x, min.y, max.x, max.y } +/// +/// The offsets in the index should be monotonically increasing. +/// +/// Design rationale: +/// - the index is smaller so we append it to the end of the data array +/// during construction. This makes it more likely that we'll fit inside +/// the data Vec +/// - we use indices/offsets instead of sizes to avoid having to deal with any +/// arithmetic that might overflow. +struct BlobReader<'a> { + /// The buffer of the blob. + reader: BufReader<'a>, + /// Where the buffer head is. + begin: usize, +} + +#[derive(PartialEq, Debug, Eq, Clone, Copy)] +struct IntPoint { + x: i32, + y: i32, +} + +/// The metadata for each display item in a blob image (doesn't match the serialized layout). +/// +/// See BlobReader above for detailed docs of the blob image format. +struct Entry { + /// The bounds of the display item. + bounds: DeviceIntRect, + /// Where the item's recorded drawing commands start. + begin: usize, + /// Where the item's recorded drawing commands end, and its extra data starts. + end: usize, + /// Where the item's extra data ends, and the next item's `begin`. + extra_end: usize, +} + +impl<'a> BlobReader<'a> { + /// Creates a new BlobReader for the given buffer. + fn new(buf: &'a [u8]) -> BlobReader<'a> { + // The offset of the index is at the end of the buffer. + let index_offset_pos = buf.len() - mem::size_of::(); + assert!(index_offset_pos < buf.len()); + let index_offset = unsafe { convert_from_bytes::(&buf[index_offset_pos..]) }; + + BlobReader { + reader: BufReader::new(&buf[index_offset..index_offset_pos]), + begin: 0, + } + } + + /// Reads the next display item's metadata. + fn read_entry(&mut self) -> Entry { + let end = self.reader.read_usize(); + let extra_end = self.reader.read_usize(); + let bounds = self.reader.read_box(); + let ret = Entry { + begin: self.begin, + end, + extra_end, + bounds, + }; + self.begin = extra_end; + ret + } +} + +/// Writes new blob images. +/// +/// In our case this is the result of merging an old one and a new one +struct BlobWriter { + /// The buffer that the data and extra data for the items is accumulated. + data: Vec, + /// The buffer that the metadata for the items is accumulated. + index: Vec, +} + +impl BlobWriter { + /// Creates an empty BlobWriter. + fn new() -> BlobWriter { + BlobWriter { + data: Vec::new(), + index: Vec::new(), + } + } + + /// Writes a display item to the blob. + fn new_entry(&mut self, extra_size: usize, bounds: DeviceIntRect, data: &[u8]) { + self.data.extend_from_slice(data); + // Write 'end' to the index: the offset where the regular data ends and the extra data starts. + self.index + .extend_from_slice(convert_to_bytes(&(self.data.len() - extra_size))); + // Write 'extra_end' to the index: the offset where the extra data ends. + self.index.extend_from_slice(convert_to_bytes(&self.data.len())); + // XXX: we can aggregate these writes + // Write the bounds to the index. + self.index.extend_from_slice(convert_to_bytes(&bounds.min.x)); + self.index.extend_from_slice(convert_to_bytes(&bounds.min.y)); + self.index.extend_from_slice(convert_to_bytes(&bounds.max.x)); + self.index.extend_from_slice(convert_to_bytes(&bounds.max.y)); + } + + /// Completes the blob image, producing a single buffer containing it. + fn finish(mut self) -> Vec { + // Append the index to the end of the buffer + // and then append the offset to the beginning of the index. + let index_begin = self.data.len(); + self.data.extend_from_slice(&self.index); + self.data.extend_from_slice(convert_to_bytes(&index_begin)); + self.data + } +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +struct CacheKey { + x1: i32, + y1: i32, + x2: i32, + y2: i32, + cache_order: u32, +} + +impl CacheKey { + pub fn new(bounds: DeviceIntRect, cache_order: u32) -> Self { + CacheKey { + x1: bounds.min.x, + y1: bounds.min.y, + x2: bounds.max.x, + y2: bounds.max.y, + cache_order, + } + } +} + +/// Provides an API for looking up the display items in a blob image by bounds, yielding items +/// with equal bounds in their original relative ordering. +/// +/// This is used to implement `merge_blobs_images`. +/// +/// We use a BTree as a kind of multi-map, by appending an integer "cache_order" to the key. +/// This lets us use multiple items with matching bounds in the map and allows +/// us to fetch and remove them while retaining the ordering of the original list. +struct CachedReader<'a> { + /// Wrapped reader. + reader: BlobReader<'a>, + /// Cached entries that have been read but not yet requested by our consumer. + cache: BTreeMap, + /// The current number of internally read display items, used to preserve list order. + cache_index_counter: u32, +} + +impl<'a> CachedReader<'a> { + /// Creates a new CachedReader. + pub fn new(buf: &'a [u8]) -> CachedReader { + CachedReader { + reader: BlobReader::new(buf), + cache: BTreeMap::new(), + cache_index_counter: 0, + } + } + + /// Tries to find the given bounds in the cache of internally read items, removing it if found. + fn take_entry_with_bounds_from_cache(&mut self, bounds: &DeviceIntRect) -> Option { + if self.cache.is_empty() { + return None; + } + + let key_to_delete = match self + .cache + .range(( + Included(CacheKey::new(*bounds, 0u32)), + Included(CacheKey::new(*bounds, std::u32::MAX)), + )) + .next() + { + Some((&key, _)) => key, + None => return None, + }; + + Some( + self.cache + .remove(&key_to_delete) + .expect("We just got this key from range, it needs to be present"), + ) + } + + /// Yields the next item in the blob image with the given bounds. + /// + /// If the given bounds aren't found in the blob, this panics. `merge_blob_images` should + /// avoid this by construction if the blob images are well-formed. + pub fn next_entry_with_bounds(&mut self, bounds: &DeviceIntRect, ignore_rect: &DeviceIntRect) -> Entry { + if let Some(entry) = self.take_entry_with_bounds_from_cache(bounds) { + return entry; + } + + loop { + // This will panic if we run through the whole list without finding our bounds. + let old = self.reader.read_entry(); + if old.bounds == *bounds { + return old; + } else if !ignore_rect.contains_box(&old.bounds) { + self.cache + .insert(CacheKey::new(old.bounds, self.cache_index_counter), old); + self.cache_index_counter += 1; + } + } + } +} + +/// Merges a new partial blob image into an existing complete one. +/// +/// A blob image represents a recording of the drawing commands needed to render +/// (part of) a display list. A partial blob image is a diff between the old display +/// list and a new one. It contains an entry for every display item in the new list, but +/// the actual drawing commands are missing for any item that isn't strictly contained +/// in the dirty rect. This is possible because not being contained in the dirty +/// rect implies that the item is unchanged between the old and new list, so we can +/// just grab the drawing commands from the old list. +/// +/// The dirty rect strictly contains the bounds of every item that has been inserted +/// into or deleted from the old list to create the new list. (For simplicity +/// you may think of any other update as deleting and reinserting the item). +/// +/// Partial blobs are based on gecko's "retained display list" system, and +/// in particular rely on one key property: if two items have overlapping bounds +/// and *aren't* contained in the dirty rect, then their relative order in both +/// the old and new list will not change. This lets us uniquely identify a display +/// item using only its bounds and relative order in the list. +/// +/// That is, the first non-dirty item in the new list with bounds (10, 15, 100, 100) +/// is *also* the first non-dirty item in the old list with those bounds. +/// +/// Note that *every* item contained inside the dirty rect will be fully recorded in +/// the new list, even if it is actually unchanged from the old list. +/// +/// All of this together gives us a fairly simple merging algorithm: all we need +/// to do is walk through the new (partial) list, determine which of the two lists +/// has the recording for that item, and copy the recording into the result. +/// +/// If an item is contained in the dirty rect, then the new list contains the +/// correct recording for that item, so we always copy it from there. Otherwise, we find +/// the first not-yet-copied item with those bounds in the old list and copy that. +/// Any items found in the old list but not the new one can be safely assumed to +/// have been deleted. +fn merge_blob_images( + old_buf: &[u8], + new_buf: &[u8], + dirty_rect: DeviceIntRect, + old_visible_rect: DeviceIntRect, + new_visible_rect: DeviceIntRect, +) -> Vec { + let mut result = BlobWriter::new(); + dlog!("dirty rect: {:?}", dirty_rect); + dlog!("old:"); + dump_bounds(old_buf, dirty_rect); + dlog!("new:"); + dump_bounds(new_buf, dirty_rect); + dlog!("old visibile rect: {:?}", old_visible_rect); + dlog!("new visibile rect: {:?}", new_visible_rect); + + let mut old_reader = CachedReader::new(old_buf); + let mut new_reader = BlobReader::new(new_buf); + let preserved_rect = old_visible_rect.intersection_unchecked(&new_visible_rect); + + // Loop over both new and old entries merging them. + // Both new and old must have the same number of entries that + // overlap but are not contained by the dirty rect, and they + // must be in the same order. + while new_reader.reader.has_more() { + let new = new_reader.read_entry(); + dlog!("bounds: {} {} {:?}", new.end, new.extra_end, new.bounds); + let preserved_bounds = new.bounds.intersection_unchecked(&preserved_rect); + if dirty_rect.contains_box(&preserved_bounds) { + result.new_entry(new.extra_end - new.end, new.bounds, &new_buf[new.begin..new.extra_end]); + } else { + let old = old_reader.next_entry_with_bounds(&new.bounds, &dirty_rect); + result.new_entry(old.extra_end - old.end, new.bounds, &old_buf[old.begin..old.extra_end]) + } + } + + // XXX: future work: ensure that items that have been deleted but aren't in the blob's visible + // rect don't affect the dirty rect -- this allows us to scroll content out of view while only + // updating the areas where items have been scrolled *into* view. This is very important for + // the performance of blobs that are larger than the viewport. When this is done this + // assertion will need to be modified to factor in the visible rect, or removed. + + // Ensure all remaining items will be discarded + while old_reader.reader.reader.has_more() { + let old = old_reader.reader.read_entry(); + dlog!("new bounds: {} {} {:?}", old.end, old.extra_end, old.bounds); + //assert!(dirty_rect.contains_box(&old.bounds)); + } + + //assert!(old_reader.cache.is_empty()); + + let result = result.finish(); + dump_index(&result); + result +} + +/// A font used by a blob image. +#[repr(C)] +#[derive(Copy, Clone)] +struct BlobFont { + /// The font key. + font_instance_key: FontInstanceKey, + /// A pointer to the scaled font. + scaled_font_ptr: u64, +} + +/// A blob image and extra data provided by webrender on how to rasterize it. +#[derive(Clone)] +struct BlobCommand { + /// The blob. + data: Arc, + /// What part of the blob should be rasterized (visible_rect's top-left corresponds to + /// (0,0) in the blob's rasterization) + visible_rect: DeviceIntRect, + /// The size of the tiles to use in rasterization. + tile_size: TileSize, +} + +struct Job { + request: BlobImageRequest, + descriptor: BlobImageDescriptor, + commands: Arc, + dirty_rect: BlobDirtyRect, + visible_rect: DeviceIntRect, + tile_size: TileSize, +} + +/// Rasterizes gecko blob images. +struct Moz2dBlobRasterizer { + /// Pool of rasterizers. + workers: Arc, + /// Pool of low priority rasterizers. + workers_low_priority: Arc, + /// Blobs to rasterize. + blob_commands: HashMap, + /// + enable_multithreading: bool, +} + +struct GeckoProfilerMarker { + name: &'static str, +} + +impl GeckoProfilerMarker { + pub fn new(name: &'static str) -> GeckoProfilerMarker { + gecko_profiler_start_marker(name); + GeckoProfilerMarker { name } + } +} + +impl Drop for GeckoProfilerMarker { + fn drop(&mut self) { + gecko_profiler_end_marker(self.name); + } +} + +impl AsyncBlobImageRasterizer for Moz2dBlobRasterizer { + fn rasterize( + &mut self, + requests: &[BlobImageParams], + low_priority: bool, + ) -> Vec<(BlobImageRequest, BlobImageResult)> { + // All we do here is spin up our workers to callback into gecko to replay the drawing commands. + gecko_profiler_label!(Graphics, Rasterization); + let _marker = GeckoProfilerMarker::new("BlobRasterization"); + + let requests: Vec = requests + .iter() + .map(|params| { + let command = &self.blob_commands[¶ms.request.key]; + let blob = Arc::clone(&command.data); + assert!(!params.descriptor.rect.is_empty()); + + Job { + request: params.request, + descriptor: params.descriptor, + commands: blob, + visible_rect: command.visible_rect, + dirty_rect: params.dirty_rect, + tile_size: command.tile_size, + } + }) + .collect(); + + // If we don't have a lot of blobs it is probably not worth the initial cost + // of installing work on rayon's thread pool so we do it serially on this thread. + let should_parallelize = if !self.enable_multithreading { + false + } else if low_priority { + requests.len() > 2 + } else { + // For high priority requests we don't "risk" the potential priority inversion of + // dispatching to a thread pool full of low priority jobs unless it is really + // appealing. + requests.len() > 4 + }; + + if should_parallelize { + // Parallel version synchronously installs a job on the thread pool which will + // try to do the work in parallel. + // This thread is blocked until the thread pool is done doing the work. + let lambda = || requests.into_par_iter().map(rasterize_blob).collect(); + if low_priority { + //TODO --bpe runtime flag to A/B test these two + self.workers_low_priority.install(lambda) + //self.workers.install(lambda) + } else { + self.workers.install(lambda) + } + } else { + requests.into_iter().map(rasterize_blob).collect() + } + } +} + +// a cross platform wrapper that creates an autorelease pool +// on macOS +fn autoreleasepool T>(f: F) -> T { + #[cfg(target_os = "macos")] + { + objc::rc::autoreleasepool(f) + } + #[cfg(not(target_os = "macos"))] + { + f() + } +} + +fn rasterize_blob(job: Job) -> (BlobImageRequest, BlobImageResult) { + gecko_profiler_label!(Graphics, Rasterization); + let descriptor = job.descriptor; + let buf_size = (descriptor.rect.area() * descriptor.format.bytes_per_pixel()) as usize; + + let mut output = vec![0u8; buf_size]; + + let dirty_rect = match job.dirty_rect { + DirtyRect::Partial(rect) => Some(rect), + DirtyRect::All => None, + }; + assert!(!descriptor.rect.is_empty()); + + let result = autoreleasepool(|| { + unsafe { + if wr_moz2d_render_cb( + ByteSlice::new(&job.commands[..]), + descriptor.format, + &descriptor.rect, + &job.visible_rect, + job.tile_size, + &job.request.tile, + dirty_rect.as_ref(), + MutByteSlice::new(output.as_mut_slice()), + ) { + // We want the dirty rect local to the tile rather than the whole image. + // TODO(nical): move that up and avoid recomupting the tile bounds in the callback + let dirty_rect = job.dirty_rect.to_subrect_of(&descriptor.rect); + let tx: BlobToDeviceTranslation = (-descriptor.rect.min.to_vector()).into(); + let rasterized_rect = tx.transform_box(&dirty_rect); + + Ok(RasterizedBlobImage { + rasterized_rect, + data: Arc::new(output), + }) + } else { + panic!("Moz2D replay problem"); + } + } + }); + + (job.request, result) +} + +impl BlobImageHandler for Moz2dBlobImageHandler { + fn create_similar(&self) -> Box { + Box::new(Self::new( + Arc::clone(&self.workers), + Arc::clone(&self.workers_low_priority), + )) + } + + fn add(&mut self, key: BlobImageKey, data: Arc, visible_rect: &DeviceIntRect, tile_size: TileSize) { + { + let index = BlobReader::new(&data); + assert!(index.reader.has_more()); + } + self.blob_commands.insert( + key, + BlobCommand { + data: Arc::clone(&data), + visible_rect: *visible_rect, + tile_size, + }, + ); + } + + fn update( + &mut self, + key: BlobImageKey, + data: Arc, + visible_rect: &DeviceIntRect, + dirty_rect: &BlobDirtyRect, + ) { + match self.blob_commands.entry(key) { + hash_map::Entry::Occupied(mut e) => { + let command = e.get_mut(); + let dirty_rect = if let DirtyRect::Partial(rect) = *dirty_rect { + rect.cast_unit() + } else { + DeviceIntRect { + min: point2(i32::MIN, i32::MIN), + max: point2(i32::MAX, i32::MAX), + } + }; + command.data = Arc::new(merge_blob_images( + &command.data, + &data, + dirty_rect, + command.visible_rect, + *visible_rect, + )); + command.visible_rect = *visible_rect; + }, + _ => { + panic!("missing image key"); + }, + } + } + + fn delete(&mut self, key: BlobImageKey) { + self.blob_commands.remove(&key); + } + + fn create_blob_rasterizer(&mut self) -> Box { + Box::new(Moz2dBlobRasterizer { + workers: Arc::clone(&self.workers), + workers_low_priority: Arc::clone(&self.workers_low_priority), + blob_commands: self.blob_commands.clone(), + enable_multithreading: self.enable_multithreading, + }) + } + + fn delete_font(&mut self, font: FontKey) { + unsafe { + DeleteFontData(font); + } + } + + fn delete_font_instance(&mut self, key: FontInstanceKey) { + unsafe { + DeleteBlobFont(key); + } + } + + fn clear_namespace(&mut self, namespace: IdNamespace) { + unsafe { + ClearBlobImageResources(namespace); + } + } + + fn prepare_resources(&mut self, resources: &dyn BlobImageResources, requests: &[BlobImageParams]) { + for params in requests { + let commands = &self.blob_commands[¶ms.request.key]; + let blob = Arc::clone(&commands.data); + self.prepare_request(&blob, resources); + } + } + + fn enable_multithreading(&mut self, enable: bool) { + self.enable_multithreading = enable; + } +} + +use bindings::{WrFontInstanceKey, WrFontKey, WrIdNamespace}; + +#[allow(improper_ctypes)] // this is needed so that rustc doesn't complain about passing the &Arc to an extern function +extern "C" { + fn HasFontData(key: WrFontKey) -> bool; + fn AddFontData(key: WrFontKey, data: *const u8, size: usize, index: u32, vec: &ArcVecU8); + fn AddNativeFontHandle(key: WrFontKey, handle: *mut c_void, index: u32); + fn DeleteFontData(key: WrFontKey); + fn AddBlobFont( + instance_key: WrFontInstanceKey, + font_key: WrFontKey, + size: f32, + options: Option<&FontInstanceOptions>, + platform_options: Option<&FontInstancePlatformOptions>, + variations: *const FontVariation, + num_variations: usize, + ); + fn DeleteBlobFont(key: WrFontInstanceKey); + fn ClearBlobImageResources(namespace: WrIdNamespace); + +} + +impl Moz2dBlobImageHandler { + /// Create a new BlobImageHandler with the given thread pool. + pub fn new(workers: Arc, workers_low_priority: Arc) -> Self { + Moz2dBlobImageHandler { + blob_commands: HashMap::new(), + workers, + workers_low_priority, + enable_multithreading: true, + } + } + + /// Does early preprocessing of a blob's resources. + /// + /// Currently just sets up fonts found in the blob. + fn prepare_request(&self, blob: &[u8], resources: &dyn BlobImageResources) { + #[cfg(target_os = "windows")] + fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) { + let file = dwrote::FontFile::new_from_path(&handle.path).unwrap(); + let face = file + .create_face(handle.index, dwrote::DWRITE_FONT_SIMULATIONS_NONE) + .unwrap(); + unsafe { AddNativeFontHandle(key, face.as_ptr() as *mut c_void, 0) }; + } + + #[cfg(target_os = "macos")] + fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) { + let font = match CGFont::from_name(&CFString::new(&handle.name)) { + Ok(font) => font, + Err(_) => { + // If for some reason we failed to load a font descriptor, then our + // only options are to either abort or substitute a fallback font. + // It is preferable to use a fallback font instead so that rendering + // can at least still proceed in some fashion without erroring. + // Lucida Grande is the fallback font in Gecko, so use that here. + CGFont::from_name(&CFString::from_static_string("Lucida Grande")) + .expect("Failed reading font descriptor and could not load fallback font") + }, + }; + unsafe { AddNativeFontHandle(key, font.as_ptr() as *mut c_void, 0) }; + } + + #[cfg(not(any(target_os = "macos", target_os = "windows")))] + fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) { + let cstr = CString::new(handle.path.as_os_str().as_bytes()).unwrap(); + unsafe { AddNativeFontHandle(key, cstr.as_ptr() as *mut c_void, handle.index) }; + } + + fn process_fonts( + mut extra_data: BufReader, + resources: &dyn BlobImageResources, + unscaled_fonts: &mut Vec, + scaled_fonts: &mut Vec, + ) { + let font_count = extra_data.read_usize(); + for _ in 0..font_count { + let font = extra_data.read_blob_font(); + if scaled_fonts.contains(&font.font_instance_key) { + continue; + } + scaled_fonts.push(font.font_instance_key); + if let Some(instance) = resources.get_font_instance_data(font.font_instance_key) { + if !unscaled_fonts.contains(&instance.font_key) { + unscaled_fonts.push(instance.font_key); + if !unsafe { HasFontData(instance.font_key) } { + let template = resources.get_font_data(instance.font_key).unwrap(); + match template { + FontTemplate::Raw(ref data, ref index) => unsafe { + AddFontData(instance.font_key, data.as_ptr(), data.len(), *index, data); + }, + FontTemplate::Native(ref handle) => { + process_native_font_handle(instance.font_key, handle); + }, + } + } + } + unsafe { + AddBlobFont( + font.font_instance_key, + instance.font_key, + instance.size, + instance.options.as_ref(), + instance.platform_options.as_ref(), + instance.variations.as_ptr(), + instance.variations.len(), + ); + } + } + } + } + + { + let mut index = BlobReader::new(blob); + let mut unscaled_fonts = Vec::new(); + let mut scaled_fonts = Vec::new(); + while index.reader.pos < index.reader.buf.len() { + let e = index.read_entry(); + process_fonts( + BufReader::new(&blob[e.end..e.extra_end]), + resources, + &mut unscaled_fonts, + &mut scaled_fonts, + ); + } + } + } +} diff --git a/gfx/webrender_bindings/src/program_cache.rs b/gfx/webrender_bindings/src/program_cache.rs new file mode 100644 index 0000000000..5db61fc8b5 --- /dev/null +++ b/gfx/webrender_bindings/src/program_cache.rs @@ -0,0 +1,355 @@ +/* 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/. */ + +use std::cell::RefCell; +use std::ffi::OsString; +use std::fs::{create_dir_all, read_dir, read_to_string, File}; +use std::io::{Error, ErrorKind}; +use std::io::{Read, Write}; +use std::path::{Path, PathBuf}; +use std::rc::Rc; +use std::sync::Arc; + +use bincode; +use fxhash; +use nsstring::nsAString; +use rayon::ThreadPool; +use webrender::{ProgramBinary, ProgramCache, ProgramCacheObserver, ProgramSourceDigest}; + +const MAX_LOAD_TIME_MS: u64 = 400; + +fn deserialize_program_binary(path: &Path) -> Result, Error> { + let mut buf = vec![]; + let mut file = File::open(path)?; + file.read_to_end(&mut buf)?; + + if buf.len() <= 8 + 4 { + return Err(Error::new(ErrorKind::InvalidData, "File size is too small")); + } + let magic = &buf[0..4]; + let hash = &buf[4..8 + 4]; + let data = &buf[8 + 4..]; + + // Check if magic + version are correct. + let mv: u32 = bincode::deserialize(&magic).unwrap(); + if mv != MAGIC_AND_VERSION { + return Err(Error::new( + ErrorKind::InvalidData, + "File data is invalid (magic+version)", + )); + } + + // Check if hash is correct + let hash: u64 = bincode::deserialize(&hash).unwrap(); + let hash_data = fxhash::hash64(&data); + if hash != hash_data { + return Err(Error::new(ErrorKind::InvalidData, "File data is invalid (hash)")); + } + + // Deserialize ProgramBinary + let binary = match bincode::deserialize(&data) { + Ok(binary) => binary, + Err(_) => { + return Err(Error::new( + ErrorKind::InvalidData, + "Failed to deserialize ProgramBinary", + )) + }, + }; + + Ok(Arc::new(binary)) +} + +#[cfg(target_os = "windows")] +fn get_cache_path_from_prof_path(prof_path: &nsAString) -> Option { + if prof_path.is_empty() { + // Empty means that we do not use disk cache. + return None; + } + + use std::os::windows::prelude::*; + + let prof_path = OsString::from_wide(prof_path.as_ref()); + let mut cache_path = PathBuf::from(&prof_path); + cache_path.push("shader-cache"); + + Some(cache_path) +} + +#[cfg(not(target_os = "windows"))] +fn get_cache_path_from_prof_path(prof_path: &nsAString) -> Option { + if prof_path.is_empty() { + // Empty means that we do not use disk cache. + return None; + } + + let utf8 = String::from_utf16(prof_path.as_ref()).unwrap(); + let prof_path = OsString::from(utf8); + let mut cache_path = PathBuf::from(&prof_path); + cache_path.push("shader-cache"); + + Some(cache_path) +} + +struct WrProgramBinaryDiskCache { + cache_path: PathBuf, + workers: Arc, + cached_shader_filenames: Vec, +} + +// Magic number + version. Increment the version when the binary format changes. +const MAGIC: u32 = 0xB154AD30; // BI-SHADE + version. +const VERSION: u32 = 2; +const MAGIC_AND_VERSION: u32 = MAGIC + VERSION; + +const WHITELIST_FILENAME: &str = "startup_shaders"; +const WHITELIST_SEPARATOR: &str = "\n"; + +/// Helper to convert a closure returning a `Result` to one that returns void. +/// This allows the enclosed code to use the question-mark operator in a +/// context where the calling function doesn't expect a `Result`. +#[allow(unused_must_use)] +fn result_to_void Result<(), ()>>(f: F) { + f(); +} + +impl WrProgramBinaryDiskCache { + #[allow(dead_code)] + fn new(cache_path: PathBuf, workers: &Arc) -> Self { + WrProgramBinaryDiskCache { + cache_path, + workers: Arc::clone(workers), + cached_shader_filenames: Vec::new(), + } + } + + /// Saves the specified binaries to the on-disk shader cache. + fn save_shaders_to_disk(&mut self, entries: Vec>) { + info!("Saving binaries to on-disk shader cache"); + + // Write the entries to disk on a worker thread. + for entry in entries { + let file_name = entry.source_digest().to_string(); + let file_path = self.cache_path.join(&file_name); + + self.workers.spawn(move || { + result_to_void(move || { + info!("Writing shader: {}", file_name); + + use std::time::Instant; + let start = Instant::now(); + + let data: Vec = + bincode::serialize(&*entry).map_err(|e| error!("shader-cache: Failed to serialize: {}", e))?; + + let mut file = + File::create(&file_path).map_err(|e| error!("shader-cache: Failed to create file: {}", e))?; + + // Write magic + version. + let mv = MAGIC_AND_VERSION; + let mv = bincode::serialize(&mv).unwrap(); + assert!(mv.len() == 4); + file.write_all(&mv) + .map_err(|e| error!("shader-cache: Failed to write magic + version: {}", e))?; + + // Write hash + let hash = fxhash::hash64(&data); + let hash = bincode::serialize(&hash).unwrap(); + assert!(hash.len() == 8); + file.write_all(&hash) + .map_err(|e| error!("shader-cache: Failed to write hash: {}", e))?; + + // Write serialized data + file.write_all(&data) + .map_err(|e| error!("shader-cache: Failed to write program binary: {}", e))?; + + info!("Wrote shader {} in {:?}", file_name, start.elapsed()); + Ok(()) + }) + }); + } + } + + /// Writes the whitelist containing the set of startup shaders to disk. + fn set_startup_shaders(&mut self, entries: Vec>) { + let whitelist = entries + .iter() + .map(|e| e.source_digest().to_string()) + .collect::>() + .join(WHITELIST_SEPARATOR); + + let mut whitelist_path = self.cache_path.clone(); + whitelist_path.push(WHITELIST_FILENAME); + self.workers.spawn(move || { + result_to_void(move || { + info!("Writing startup shader whitelist"); + File::create(&whitelist_path) + .and_then(|mut file| file.write_all(whitelist.as_bytes())) + .map_err(|e| error!("shader-cache: Failed to write startup whitelist: {}", e))?; + Ok(()) + }) + }); + } + + pub fn try_load_shader_from_disk(&mut self, filename: &str, program_cache: &Rc) { + if let Some(index) = self.cached_shader_filenames.iter().position(|e| e == filename) { + let mut path = self.cache_path.clone(); + path.push(filename); + + self.cached_shader_filenames.swap_remove(index); + + info!("Loading shader: {}", filename); + + match deserialize_program_binary(&path) { + Ok(program) => { + program_cache.load_program_binary(program); + }, + Err(err) => { + error!("shader-cache: Failed to deserialize program binary: {}", err); + }, + }; + } else { + info!("shader-cache: Program binary not found in disk cache"); + } + } + + pub fn try_load_startup_shaders_from_disk(&mut self, program_cache: &Rc) { + use std::time::Instant; + let start = Instant::now(); + + // Load and parse the whitelist if it exists + let mut whitelist_path = self.cache_path.clone(); + whitelist_path.push(WHITELIST_FILENAME); + let whitelist = match read_to_string(&whitelist_path) { + Ok(whitelist) => whitelist + .split(WHITELIST_SEPARATOR) + .map(|s| s.to_string()) + .collect::>(), + Err(err) => { + info!("shader-cache: Could not read startup whitelist: {}", err); + Vec::new() + }, + }; + info!("Loaded startup shader whitelist in {:?}", start.elapsed()); + + self.cached_shader_filenames = read_dir(&self.cache_path) + .map_err(|err| { + error!( + "shader-cache: Error reading directory whilst loading startup shaders: {}", + err + ) + }) + .into_iter() + .flatten() + .filter_map(Result::ok) + .map(|entry| entry.file_name()) + .filter(|filename| filename != WHITELIST_FILENAME) + .collect::>(); + + // Load whitelisted program binaries if they exist + for entry in &whitelist { + self.try_load_shader_from_disk(&entry, program_cache); + + let elapsed = start.elapsed(); + info!("Loaded shader in {:?}", elapsed); + let elapsed_ms = (elapsed.as_secs() * 1_000) + elapsed.subsec_millis() as u64; + + if elapsed_ms > MAX_LOAD_TIME_MS { + // Loading the startup shaders is taking too long, so bail out now. + // Additionally clear the list of remaining shaders cached on disk, + // so that we do not attempt to load any on demand during rendering. + error!("shader-cache: Timed out before finishing loads"); + self.cached_shader_filenames.clear(); + break; + } + } + } +} + +pub struct WrProgramCacheObserver { + disk_cache: Rc>, +} + +impl WrProgramCacheObserver { + #[allow(dead_code)] + fn new(disk_cache: Rc>) -> Self { + WrProgramCacheObserver { disk_cache } + } +} + +impl ProgramCacheObserver for WrProgramCacheObserver { + fn save_shaders_to_disk(&self, entries: Vec>) { + self.disk_cache.borrow_mut().save_shaders_to_disk(entries); + } + + fn set_startup_shaders(&self, entries: Vec>) { + self.disk_cache.borrow_mut().set_startup_shaders(entries); + } + + fn try_load_shader_from_disk(&self, digest: &ProgramSourceDigest, program_cache: &Rc) { + let filename = digest.to_string(); + self.disk_cache + .borrow_mut() + .try_load_shader_from_disk(&filename, program_cache); + } + + fn notify_program_binary_failed(&self, _program_binary: &Arc) { + error!("shader-cache: Failed program_binary"); + } +} + +pub struct WrProgramCache { + pub program_cache: Rc, + disk_cache: Option>>, +} + +impl WrProgramCache { + pub fn new(prof_path: &nsAString, workers: &Arc) -> Self { + let cache_path = get_cache_path_from_prof_path(prof_path); + let use_disk_cache = cache_path.as_ref().map_or(false, |p| create_dir_all(p).is_ok()); + let (disk_cache, program_cache_observer) = if use_disk_cache { + let cache = Rc::new(RefCell::new(WrProgramBinaryDiskCache::new( + cache_path.unwrap(), + workers, + ))); + let obs = Box::new(WrProgramCacheObserver::new(Rc::clone(&cache))) as Box; + (Some(cache), Some(obs)) + } else { + (None, None) + }; + let program_cache = ProgramCache::new(program_cache_observer); + + WrProgramCache { + program_cache, + disk_cache, + } + } + + pub fn rc_get(&self) -> &Rc { + &self.program_cache + } + + pub fn try_load_startup_shaders_from_disk(&self) { + if let Some(ref disk_cache) = self.disk_cache { + disk_cache + .borrow_mut() + .try_load_startup_shaders_from_disk(&self.program_cache); + } else { + error!("shader-cache: Shader disk cache is not supported"); + } + } +} + +pub fn remove_disk_cache(prof_path: &nsAString) -> Result<(), Error> { + use std::time::Instant; + + if let Some(cache_path) = get_cache_path_from_prof_path(prof_path) { + if cache_path.exists() { + let start = Instant::now(); + remove_dir_all::remove_dir_all(&cache_path)?; + info!("removed all disk cache shaders in {:?}", start.elapsed()); + } + } + Ok(()) +} diff --git a/gfx/webrender_bindings/src/swgl_bindings.rs b/gfx/webrender_bindings/src/swgl_bindings.rs new file mode 100644 index 0000000000..b1e7684a69 --- /dev/null +++ b/gfx/webrender_bindings/src/swgl_bindings.rs @@ -0,0 +1,101 @@ +/* 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/. */ + +use gleam::gl::Gl; + +use std::os::raw::c_void; + +#[no_mangle] +pub extern "C" fn wr_swgl_create_context() -> *mut c_void { + swgl::Context::create().into() +} + +#[no_mangle] +pub extern "C" fn wr_swgl_reference_context(ctx: *mut c_void) { + swgl::Context::from(ctx).reference(); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_destroy_context(ctx: *mut c_void) { + swgl::Context::from(ctx).destroy(); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_make_current(ctx: *mut c_void) { + swgl::Context::from(ctx).make_current(); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_init_default_framebuffer( + ctx: *mut c_void, + x: i32, + y: i32, + width: i32, + height: i32, + stride: i32, + buf: *mut c_void, +) { + swgl::Context::from(ctx).init_default_framebuffer(x, y, width, height, stride, buf); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_resolve_framebuffer(ctx: *mut c_void, fbo: u32) { + swgl::Context::from(ctx).resolve_framebuffer(fbo); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_gen_texture(ctx: *mut c_void) -> u32 { + swgl::Context::from(ctx).gen_textures(1)[0] +} + +#[no_mangle] +pub extern "C" fn wr_swgl_delete_texture(ctx: *mut c_void, tex: u32) { + swgl::Context::from(ctx).delete_textures(&[tex]); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_set_texture_parameter(ctx: *mut c_void, tex: u32, pname: u32, param: i32) { + swgl::Context::from(ctx).set_texture_parameter(tex, pname, param); +} + +#[no_mangle] +pub extern "C" fn wr_swgl_set_texture_buffer( + ctx: *mut c_void, + tex: u32, + internal_format: u32, + width: i32, + height: i32, + stride: i32, + buf: *mut c_void, + min_width: i32, + min_height: i32, +) { + swgl::Context::from(ctx).set_texture_buffer( + tex, + internal_format, + width, + height, + stride, + buf, + min_width, + min_height, + ); +} + +#[no_mangle] +#[allow(clippy::many_single_char_names)] +pub extern "C" fn wr_swgl_clear_color_rect( + ctx: *mut c_void, + fbo: u32, + x: i32, + y: i32, + width: i32, + height: i32, + r: f32, + g: f32, + b: f32, + a: f32, +) { + swgl::Context::from(ctx).clear_color_rect(fbo, x, y, width, height, r, g, b, a); +} diff --git a/gfx/webrender_bindings/webrender_ffi.h b/gfx/webrender_bindings/webrender_ffi.h new file mode 100644 index 0000000000..e9c8be1ef4 --- /dev/null +++ b/gfx/webrender_bindings/webrender_ffi.h @@ -0,0 +1,123 @@ +/* -*- 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/. */ + +#ifndef WR_h +#define WR_h + +#include "mozilla/gfx/Types.h" +#include "nsTArray.h" + +extern "C" { + +// ---- +// Functions invoked from Rust code +// ---- + +bool is_in_compositor_thread(); +bool is_in_main_thread(); +bool is_in_render_thread(); +bool is_glcontext_gles(void* glcontext_ptr); +bool is_glcontext_angle(void* glcontext_ptr); +bool gfx_use_wrench(); +const char* gfx_wr_resource_path_override(); +bool gfx_wr_use_optimized_shaders(); +void gfx_critical_note(const char* msg); +void gfx_critical_error(const char* msg); +void gecko_printf_stderr_output(const char* msg); +void* get_proc_address_from_glcontext(void* glcontext_ptr, + const char* procname); + +bool gecko_profiler_thread_is_being_profiled(); + +// IMPORTANT: Keep this synchronized with enumerate_interners in +// gfx/wr/webrender_api +#define WEBRENDER_FOR_EACH_INTERNER(macro) \ + macro(clip); \ + macro(prim); \ + macro(normal_border); \ + macro(image_border); \ + macro(image); \ + macro(yuv_image); \ + macro(line_decoration); \ + macro(linear_grad); \ + macro(radial_grad); \ + macro(conic_grad); \ + macro(picture); \ + macro(text_run); \ + macro(filterdata); \ + macro(backdrop_capture); \ + macro(backdrop_render); \ + macro(polyon); + +// Prelude of types necessary before including webrender_ffi_generated.h +namespace mozilla { +namespace wr { + +// Because this struct is macro-generated on the Rust side, cbindgen can't see +// it. Work around that by re-declaring it here. +#define DECLARE_MEMBER(id) uintptr_t id; +struct InternerSubReport { + WEBRENDER_FOR_EACH_INTERNER(DECLARE_MEMBER) +}; + +#undef DECLARE_MEMBER + +struct Transaction; +struct WrWindowId; +struct DocumentId; +struct WrPipelineInfo; + +struct WrPipelineIdAndEpoch; +using WrPipelineIdEpochs = nsTArray; + +} // namespace wr +} // namespace mozilla + +void apz_register_updater(mozilla::wr::WrWindowId aWindowId); +void apz_pre_scene_swap(mozilla::wr::WrWindowId aWindowId); +void apz_post_scene_swap(mozilla::wr::WrWindowId aWindowId, + const mozilla::wr::WrPipelineInfo* aInfo); +void apz_run_updater(mozilla::wr::WrWindowId aWindowId); +void apz_deregister_updater(mozilla::wr::WrWindowId aWindowId); + +void apz_register_sampler(mozilla::wr::WrWindowId aWindowId); +void apz_sample_transforms(mozilla::wr::WrWindowId aWindowId, + const uint64_t* aGeneratedFrameId, + mozilla::wr::Transaction* aTransaction); +void apz_deregister_sampler(mozilla::wr::WrWindowId aWindowId); + +void omta_register_sampler(mozilla::wr::WrWindowId aWindowId); +void omta_sample(mozilla::wr::WrWindowId aWindowId, + mozilla::wr::Transaction* aTransaction); +void omta_deregister_sampler(mozilla::wr::WrWindowId aWindowId); +} // extern "C" + +// Work-around Solaris define which conflcits with WR color constant, see +// bug 1773491. +#pragma push_macro("TRANSPARENT") +#undef TRANSPARENT + +#include "webrender_ffi_generated.h" + +#pragma pop_macro("TRANSPARENT") + +template struct mozilla::wr::Point2D; +template struct mozilla::wr::Point2D; +template struct mozilla::wr::Point2D; +template struct mozilla::wr::Box2D; +template struct mozilla::wr::Box2D; + +namespace mozilla { +namespace wr { + +// Cast a blob image key into a regular image for use in +// a display item. +inline ImageKey AsImageKey(BlobImageKey aKey) { return aKey._0; } + +} // namespace wr +} // namespace mozilla + +#endif // WR_h -- cgit v1.2.3