diff options
Diffstat (limited to 'gfx/layers/NativeLayerCA.h')
| -rw-r--r-- | gfx/layers/NativeLayerCA.h | 481 |
1 files changed, 481 insertions, 0 deletions
diff --git a/gfx/layers/NativeLayerCA.h b/gfx/layers/NativeLayerCA.h new file mode 100644 index 0000000000..ce4ce6fd93 --- /dev/null +++ b/gfx/layers/NativeLayerCA.h @@ -0,0 +1,481 @@ +/* -*- 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/. */ + +#ifndef mozilla_layers_NativeLayerCA_h +#define mozilla_layers_NativeLayerCA_h + +#include <IOSurface/IOSurface.h> + +#include <deque> +#include <unordered_map> +#include <ostream> + +#include "mozilla/Mutex.h" +#include "mozilla/TimeStamp.h" + +#include "mozilla/gfx/MacIOSurface.h" +#include "mozilla/layers/NativeLayer.h" +#include "CFTypeRefPtr.h" +#include "nsRegion.h" +#include "nsISupportsImpl.h" + +#ifdef __OBJC__ +@class CALayer; +#else +typedef void CALayer; +#endif + +namespace mozilla { + +namespace gl { +class GLContextCGL; +class MozFramebuffer; +} // namespace gl +namespace wr { +class RenderMacIOSurfaceTextureHost; +} // namespace wr + +namespace layers { + +class NativeLayerRootSnapshotterCA; +class SurfacePoolHandleCA; + +enum class VideoLowPowerType { + // These must be kept synchronized with the telemetry histogram enums. + NotVideo, // Never emitted as telemetry. No video is visible. + LowPower, // As best we can tell, we are in the "detached", + // low-power compositing mode. We don't use "Success" + // because of name collision with telemetry generation. + FailMultipleVideo, // There is more than one video visible. + FailWindowed, // The window is not fullscreen. + FailOverlaid, // Something is on top of the video (likely captions). + FailBacking, // The layer behind the video is not full-coverage black. + FailMacOSVersion, // macOS version does not meet requirements. + FailPref, // Pref is not set. + FailSurface, // Surface is not eligible. + FailEnqueue, // Enqueueing the video didn't work. +}; + +// NativeLayerRootCA is the CoreAnimation implementation of the NativeLayerRoot +// interface. A NativeLayerRootCA is created by the widget around an existing +// CALayer with a call to CreateForCALayer - this CALayer is the root of the +// "onscreen" representation of this layer tree. +// All methods can be called from any thread, there is internal locking. +// All effects from mutating methods are buffered locally and don't modify the +// underlying CoreAnimation layers until CommitToScreen() is called. This +// ensures that the modifications happen on the right thread. +// +// More specifically: During normal operation, screen updates are driven from a +// compositing thread. On this thread, the layers are created / destroyed, their +// contents are painted, and the result is committed to the screen. However, +// there are some scenarios that need to involve the main thread, most notably +// window resizing: During a window resize, we still need the drawing part to +// happen on the compositing thread, but the modifications to the underlying +// CALayers need to happen on the main thread, once compositing is done. +// +// NativeLayerRootCA + NativeLayerCA create and maintain *two* CALayer tree +// representations: An "onscreen" representation and an "offscreen" +// representation. These representations are updated via calls to +// CommitToScreen() and CommitOffscreen(), respectively. The reason for having +// two representations is the following: Our implementation of the snapshotter +// API uses CARenderer, which lets us render the composited result of our layer +// tree into a GPU buffer. But CARenderer requires "ownership" of the rendered +// CALayers in the sense that it associates the CALayers with a local +// "CAContext". A CALayer can only be associated with one CAContext at any time. +// If we wanted te render our *onscreen* CALayers with CARenderer, we would need +// to remove them from the window, reparent them to the CARenderer, render them, +// and then put them back into the window. This would lead to a visible flashing +// effect. To solve this problem, we build two CALayer representations, so that +// one representation can stay inside the window and the other can stay attached +// to the CARenderer. +class NativeLayerRootCA : public NativeLayerRoot { + public: + static already_AddRefed<NativeLayerRootCA> CreateForCALayer(CALayer* aLayer); + + virtual NativeLayerRootCA* AsNativeLayerRootCA() override { return this; } + + // Can be called on any thread at any point. Returns whether comitting was + // successful. Will return false if called off the main thread while + // off-main-thread commits are suspended. + bool CommitToScreen() override; + + void CommitOffscreen(); + void OnNativeLayerRootSnapshotterDestroyed( + NativeLayerRootSnapshotterCA* aNativeLayerRootSnapshotter); + + // Enters a mode during which CommitToScreen(), when called on a non-main + // thread, will not apply any updates to the CALayer tree. + void SuspendOffMainThreadCommits(); + + // Exits the mode entered by SuspendOffMainThreadCommits(). + // Returns true if the last CommitToScreen() was canceled due to suspension, + // indicating that another call to CommitToScreen() is needed. + bool UnsuspendOffMainThreadCommits(); + + bool AreOffMainThreadCommitsSuspended(); + + void DumpLayerTreeToFile(const char* aPath); + + enum class WhichRepresentation : uint8_t { ONSCREEN, OFFSCREEN }; + + // Overridden methods + already_AddRefed<NativeLayer> CreateLayer(const gfx::IntSize& aSize, bool aIsOpaque, + SurfacePoolHandle* aSurfacePoolHandle) override; + void AppendLayer(NativeLayer* aLayer) override; + void RemoveLayer(NativeLayer* aLayer) override; + void SetLayers(const nsTArray<RefPtr<NativeLayer>>& aLayers) override; + UniquePtr<NativeLayerRootSnapshotter> CreateSnapshotter() override; + + void SetBackingScale(float aBackingScale); + float BackingScale(); + + already_AddRefed<NativeLayer> CreateLayerForExternalTexture(bool aIsOpaque) override; + already_AddRefed<NativeLayer> CreateLayerForColor(gfx::DeviceColor aColor) override; + + void SetWindowIsFullscreen(bool aFullscreen); + + VideoLowPowerType CheckVideoLowPower(); + + protected: + explicit NativeLayerRootCA(CALayer* aLayer); + ~NativeLayerRootCA() override; + + struct Representation { + explicit Representation(CALayer* aRootCALayer); + ~Representation(); + void Commit(WhichRepresentation aRepresentation, + const nsTArray<RefPtr<NativeLayerCA>>& aSublayers, bool aWindowIsFullscreen); + CALayer* mRootCALayer = nullptr; // strong + bool mMutatedLayerStructure = false; + }; + + template <typename F> + void ForAllRepresentations(F aFn); + + Mutex mMutex MOZ_UNANNOTATED; // protects all other fields + Representation mOnscreenRepresentation; + Representation mOffscreenRepresentation; + NativeLayerRootSnapshotterCA* mWeakSnapshotter = nullptr; + nsTArray<RefPtr<NativeLayerCA>> mSublayers; // in z-order + float mBackingScale = 1.0f; + bool mMutated = false; + + // While mOffMainThreadCommitsSuspended is true, no commits + // should happen on a non-main thread, because they might race with + // main-thread driven updates such as window shape changes, and cause + // glitches. + bool mOffMainThreadCommitsSuspended = false; + + // Set to true if CommitToScreen() was aborted because of commit suspension. + // Set to false when CommitToScreen() completes successfully. When true, + // indicates that CommitToScreen() needs to be called at the next available + // opportunity. + bool mCommitPending = false; + + // Updated by the layer's view's window to match the fullscreen state + // of that window. + bool mWindowIsFullscreen = false; + + // How many times have we committed since the last time we emitted + // telemetry? + unsigned int mTelemetryCommitCount = 0; +}; + +class RenderSourceNLRS; + +class NativeLayerRootSnapshotterCA final : public NativeLayerRootSnapshotter { + public: + static UniquePtr<NativeLayerRootSnapshotterCA> Create(NativeLayerRootCA* aLayerRoot, + CALayer* aRootCALayer); + virtual ~NativeLayerRootSnapshotterCA(); + + bool ReadbackPixels(const gfx::IntSize& aReadbackSize, gfx::SurfaceFormat aReadbackFormat, + const Range<uint8_t>& aReadbackBuffer) override; + already_AddRefed<profiler_screenshots::RenderSource> GetWindowContents( + const gfx::IntSize& aWindowSize) override; + already_AddRefed<profiler_screenshots::DownscaleTarget> CreateDownscaleTarget( + const gfx::IntSize& aSize) override; + already_AddRefed<profiler_screenshots::AsyncReadbackBuffer> CreateAsyncReadbackBuffer( + const gfx::IntSize& aSize) override; + + protected: + NativeLayerRootSnapshotterCA(NativeLayerRootCA* aLayerRoot, RefPtr<gl::GLContext>&& aGL, + CALayer* aRootCALayer); + void UpdateSnapshot(const gfx::IntSize& aSize); + + RefPtr<NativeLayerRootCA> mLayerRoot; + RefPtr<gl::GLContext> mGL; + + // Can be null. Created and updated in UpdateSnapshot. + RefPtr<RenderSourceNLRS> mSnapshot; + CARenderer* mRenderer = nullptr; // strong +}; + +// NativeLayerCA wraps a CALayer and lets you draw to it. It ensures that only +// fully-drawn frames make their way to the screen, by maintaining a swap chain +// of IOSurfaces. +// All calls to mutating methods are buffered, and don't take effect on the +// underlying CoreAnimation layers until ApplyChanges() is called. +// The two most important methods are NextSurface and NotifySurfaceReady: +// NextSurface takes an available surface from the swap chain or creates a new +// surface if necessary. This surface can then be drawn to. Once drawing is +// finished, NotifySurfaceReady marks the surface as ready. This surface is +// committed to the layer during the next call to ApplyChanges(). +// The swap chain keeps track of invalid areas within the surfaces. +class NativeLayerCA : public NativeLayer { + public: + virtual NativeLayerCA* AsNativeLayerCA() override { return this; } + + // Overridden methods + gfx::IntSize GetSize() override; + void SetPosition(const gfx::IntPoint& aPosition) override; + gfx::IntPoint GetPosition() override; + void SetTransform(const gfx::Matrix4x4& aTransform) override; + gfx::Matrix4x4 GetTransform() override; + gfx::IntRect GetRect() override; + void SetSamplingFilter(gfx::SamplingFilter aSamplingFilter) override; + RefPtr<gfx::DrawTarget> NextSurfaceAsDrawTarget(const gfx::IntRect& aDisplayRect, + const gfx::IntRegion& aUpdateRegion, + gfx::BackendType aBackendType) override; + Maybe<GLuint> NextSurfaceAsFramebuffer(const gfx::IntRect& aDisplayRect, + const gfx::IntRegion& aUpdateRegion, + bool aNeedsDepth) override; + void NotifySurfaceReady() override; + void DiscardBackbuffers() override; + bool IsOpaque() override; + void SetClipRect(const Maybe<gfx::IntRect>& aClipRect) override; + Maybe<gfx::IntRect> ClipRect() override; + gfx::IntRect CurrentSurfaceDisplayRect() override; + void SetSurfaceIsFlipped(bool aIsFlipped) override; + bool SurfaceIsFlipped() override; + + void DumpLayer(std::ostream& aOutputStream); + + void AttachExternalImage(wr::RenderTextureHost* aExternalImage) override; + + void SetRootWindowIsFullscreen(bool aFullscreen); + + protected: + friend class NativeLayerRootCA; + + NativeLayerCA(const gfx::IntSize& aSize, bool aIsOpaque, SurfacePoolHandleCA* aSurfacePoolHandle); + explicit NativeLayerCA(bool aIsOpaque); + explicit NativeLayerCA(gfx::DeviceColor aColor); + ~NativeLayerCA() override; + + // Gets the next surface for drawing from our swap chain and stores it in + // mInProgressSurface. Returns whether this was successful. + // mInProgressSurface is guaranteed to be not in use by the window server. + // After a call to NextSurface, NextSurface must not be called again until + // after NotifySurfaceReady has been called. Can be called on any thread. When + // used from multiple threads, callers need to make sure that they still only + // call NextSurface and NotifySurfaceReady alternatingly and not in any other + // order. + bool NextSurface(const MutexAutoLock& aProofOfLock); + + // To be called by NativeLayerRootCA: + typedef NativeLayerRootCA::WhichRepresentation WhichRepresentation; + CALayer* UnderlyingCALayer(WhichRepresentation aRepresentation); + + enum class UpdateType { + None, // Order is important. Each enum must fully encompass the + OnlyVideo, // work implied by the previous enums. + All, + }; + + UpdateType HasUpdate(WhichRepresentation aRepresentation); + bool WillUpdateAffectLayers(WhichRepresentation aRepresentation); + bool ApplyChanges(WhichRepresentation aRepresentation, UpdateType aUpdate); + + void SetBackingScale(float aBackingScale); + + // Invalidates the specified region in all surfaces that are tracked by this + // layer. + void InvalidateRegionThroughoutSwapchain(const MutexAutoLock& aProofOfLock, + const gfx::IntRegion& aRegion); + + // Invalidate aUpdateRegion and make sure that mInProgressSurface retains any + // valid content from the previous surface outside of aUpdateRegion, so that + // only aUpdateRegion needs to be drawn. If content needs to be copied, + // aCopyFn is called to do the copying. + // aCopyFn: Fn(CFTypeRefPtr<IOSurfaceRef> aValidSourceIOSurface, + // const gfx::IntRegion& aCopyRegion) -> void + template <typename F> + void HandlePartialUpdate(const MutexAutoLock& aProofOfLock, const gfx::IntRect& aDisplayRect, + const gfx::IntRegion& aUpdateRegion, F&& aCopyFn); + + struct SurfaceWithInvalidRegion { + CFTypeRefPtr<IOSurfaceRef> mSurface; + gfx::IntRegion mInvalidRegion; + }; + + struct SurfaceWithInvalidRegionAndCheckCount { + SurfaceWithInvalidRegion mEntry; + uint32_t mCheckCount; // The number of calls to IOSurfaceIsInUse + }; + + Maybe<SurfaceWithInvalidRegion> GetUnusedSurfaceAndCleanUp(const MutexAutoLock& aProofOfLock); + + bool IsVideo(); + bool IsVideoAndLocked(const MutexAutoLock& aProofOfLock); + bool ShouldSpecializeVideo(const MutexAutoLock& aProofOfLock); + bool HasExtent() const { return mHasExtent; } + void SetHasExtent(bool aHasExtent) { mHasExtent = aHasExtent; } + + // This function returns a CGRect if a clip should be applied to the layer. + // If set, the CGRect has the scaled position of the clip relative to the + // surface origin and the scaled size of the clip rect. + static Maybe<CGRect> CalculateClipGeometry( + const gfx::IntSize& aSize, const gfx::IntPoint& aPosition, const gfx::Matrix4x4& aTransform, + const gfx::IntRect& aDisplayRect, const Maybe<gfx::IntRect>& aClipRect, float aBackingScale); + + // Wraps one CALayer representation of this NativeLayer. + struct Representation { + Representation(); + ~Representation(); + + CALayer* UnderlyingCALayer() { return mWrappingCALayer; } + + bool EnqueueSurface(IOSurfaceRef aSurfaceRef); + + // Applies buffered changes to the native CALayers. The contract with the + // caller is as follows: If any of these values have changed since the last + // call to ApplyChanges, mMutated[Field] needs to have been set to true + // before the call. If aUpdate is not All, then a partial update will be + // applied. In such a case, ApplyChanges may not make any changes that + // require a CATransacation, because no transaction will be created. In a + // a partial update, the return value will indicate if all the needed + // changes were able to be applied under these restrictions. A false return + // value indicates an All update is necessary. + bool ApplyChanges(UpdateType aUpdate, const gfx::IntSize& aSize, bool aIsOpaque, + const gfx::IntPoint& aPosition, const gfx::Matrix4x4& aTransform, + const gfx::IntRect& aDisplayRect, const Maybe<gfx::IntRect>& aClipRect, + float aBackingScale, bool aSurfaceIsFlipped, + gfx::SamplingFilter aSamplingFilter, bool aSpecializeVideo, + CFTypeRefPtr<IOSurfaceRef> aFrontSurface, CFTypeRefPtr<CGColorRef> aColor, + bool aIsDRM, bool aIsVideo); + + // Return whether any aspects of this layer representation have been mutated + // since the last call to ApplyChanges, i.e. whether ApplyChanges needs to + // be called. + // This is used to optimize away a CATransaction commit if no layers have + // changed. + UpdateType HasUpdate(bool aIsVideo); + + // Lazily initialized by first call to ApplyChanges. mWrappingLayer is the + // layer that applies the intersection of mDisplayRect and mClipRect (if + // set), and mContentCALayer is the layer that hosts the IOSurface. We do + // not share clip layers between consecutive NativeLayerCA objects with the + // same clip rect. + CALayer* mWrappingCALayer = nullptr; // strong + CALayer* mContentCALayer = nullptr; // strong + CALayer* mOpaquenessTintLayer = nullptr; // strong + +#ifdef NIGHTLY_BUILD + bool mLogNextVideoSurface = false; +#endif + + bool mMutatedPosition : 1; + bool mMutatedTransform : 1; + bool mMutatedDisplayRect : 1; + bool mMutatedClipRect : 1; + bool mMutatedBackingScale : 1; + bool mMutatedSize : 1; + bool mMutatedSurfaceIsFlipped : 1; + bool mMutatedFrontSurface : 1; + bool mMutatedSamplingFilter : 1; + bool mMutatedSpecializeVideo : 1; + bool mMutatedIsDRM : 1; + }; + + Representation& GetRepresentation(WhichRepresentation aRepresentation); + template <typename F> + void ForAllRepresentations(F aFn); + + // Controls access to all fields of this class. + Mutex mMutex MOZ_UNANNOTATED; + + // Each IOSurface is initially created inside NextSurface. + // The surface stays alive until the recycling mechanism in NextSurface + // determines it is no longer needed (because the swap chain has grown too + // long) or until DiscardBackbuffers() is called or the layer is destroyed. + // During the surface's lifetime, it will continuously move through the fields + // mInProgressSurface, mFrontSurface, and back to front through the mSurfaces + // queue: + // + // mSurfaces.front() + // ------[NextSurface()]-----> mInProgressSurface + // --[NotifySurfaceReady()]--> mFrontSurface + // --[NotifySurfaceReady()]--> mSurfaces.back() --> .... --> + // mSurfaces.front() + // + // We mark an IOSurface as "in use" as long as it is either in + // mInProgressSurface. When it is in mFrontSurface or in the mSurfaces queue, + // it is not marked as "in use" by us - but it can be "in use" by the window + // server. Consequently, IOSurfaceIsInUse on a surface from mSurfaces reflects + // whether the window server is still reading from the surface, and we can use + // this indicator to decide when to recycle the surface. + // + // Users of NativeLayerCA normally proceed in this order: + // 1. Begin a frame by calling NextSurface to get the surface. + // 2. Draw to the surface. + // 3. Mark the surface as done by calling NotifySurfaceReady. + // 4. Call NativeLayerRoot::CommitToScreen(), which calls ApplyChanges() + // during a CATransaction. + + // The surface we returned from the most recent call to NextSurface, before + // the matching call to NotifySurfaceReady. + // Will only be Some() between calls to NextSurface and NotifySurfaceReady. + Maybe<SurfaceWithInvalidRegion> mInProgressSurface; + Maybe<gfx::IntRegion> mInProgressUpdateRegion; + Maybe<gfx::IntRect> mInProgressDisplayRect; + + // The surface that the most recent call to NotifySurfaceReady was for. + // Will be Some() after the first call to NotifySurfaceReady, for the rest of + // the layer's life time. + Maybe<SurfaceWithInvalidRegion> mFrontSurface; + + // The queue of surfaces which make up the rest of our "swap chain". + // mSurfaces.front() is the next surface we'll attempt to use. + // mSurfaces.back() is the one that was used most recently. + std::vector<SurfaceWithInvalidRegionAndCheckCount> mSurfaces; + + // Non-null between calls to NextSurfaceAsDrawTarget and NotifySurfaceReady. + RefPtr<MacIOSurface> mInProgressLockedIOSurface; + + RefPtr<SurfacePoolHandleCA> mSurfacePoolHandle; + RefPtr<wr::RenderMacIOSurfaceTextureHost> mTextureHost; + + Representation mOnscreenRepresentation; + Representation mOffscreenRepresentation; + + gfx::IntPoint mPosition; + gfx::Matrix4x4 mTransform; + gfx::IntRect mDisplayRect; + gfx::IntSize mSize; + Maybe<gfx::IntRect> mClipRect; + gfx::SamplingFilter mSamplingFilter = gfx::SamplingFilter::POINT; + float mBackingScale = 1.0f; + bool mSurfaceIsFlipped = false; + CFTypeRefPtr<CGColorRef> mColor; + const bool mIsOpaque = false; + bool mRootWindowIsFullscreen = false; + bool mSpecializeVideo = false; + bool mHasExtent = false; + bool mIsDRM = false; + +#ifdef NIGHTLY_BUILD + // Track the consistency of our caller's API usage. Layers that are drawn + // should only ever be called with NotifySurfaceReady. Layers that are + // external should only ever be called with AttachExternalImage. + bool mHasEverAttachExternalImage = false; + bool mHasEverNotifySurfaceReady = false; +#endif +}; + +} // namespace layers +} // namespace mozilla + +#endif // mozilla_layers_NativeLayerCA_h |