diff options
Diffstat (limited to 'gfx/layers/composite')
43 files changed, 14444 insertions, 0 deletions
diff --git a/gfx/layers/composite/AsyncCompositionManager.cpp b/gfx/layers/composite/AsyncCompositionManager.cpp new file mode 100644 index 0000000000..3c155d0df0 --- /dev/null +++ b/gfx/layers/composite/AsyncCompositionManager.cpp @@ -0,0 +1,1314 @@ +/* -*- 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/layers/AsyncCompositionManager.h" +#include <stdint.h> // for uint32_t +#include "LayerManagerComposite.h" // for LayerManagerComposite, etc +#include "Layers.h" // for Layer, ContainerLayer, etc +#include "gfxPoint.h" // for gfxPoint, gfxSize +#include "mozilla/ServoBindings.h" // for Servo_AnimationValue_GetOpacity, etc +#include "mozilla/ScopeExit.h" // for MakeScopeExit +#include "mozilla/StaticPrefs_apz.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/WidgetUtils.h" // for ComputeTransformForRotation +#include "mozilla/gfx/BaseRect.h" // for BaseRect +#include "mozilla/gfx/Point.h" // for RoundedToInt, PointTyped +#include "mozilla/gfx/Rect.h" // for RoundedToInt, RectTyped +#include "mozilla/gfx/ScaleFactor.h" // for ScaleFactor +#include "mozilla/layers/AnimationHelper.h" +#include "mozilla/layers/APZSampler.h" // for APZSampler +#include "mozilla/layers/APZUtils.h" // for CompleteAsyncTransform +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorAnimationStorage.h" // for CompositorAnimationStorage +#include "mozilla/layers/CompositorBridgeParent.h" // for CompositorBridgeParent, etc +#include "mozilla/layers/CompositorThread.h" +#include "mozilla/layers/LayerAnimationUtils.h" // for TimingFunctionToComputedTimingFunction +#include "mozilla/layers/LayerMetricsWrapper.h" // for LayerMetricsWrapper +#include "mozilla/layers/SampleTime.h" +#include "nsCoord.h" // for NSAppUnitsToFloatPixels, etc +#include "nsDebug.h" // for NS_ASSERTION, etc +#include "nsDeviceContext.h" // for nsDeviceContext +#include "nsDisplayList.h" // for nsDisplayTransform, etc +#include "nsMathUtils.h" // for NS_round +#include "nsPoint.h" // for nsPoint +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nsRegion.h" // for nsIntRegion +#include "nsTArray.h" // for nsTArray, nsTArray_Impl, etc +#include "nsTArrayForwardDeclare.h" // for nsTArray +#include "UnitTransforms.h" // for TransformTo +#if defined(MOZ_WIDGET_ANDROID) +# include <android/log.h> +# include "mozilla/layers/UiCompositorControllerParent.h" +# include "mozilla/widget/AndroidCompositorWidget.h" +#endif +#include "GeckoProfiler.h" +#include "FrameUniformityData.h" +#include "TreeTraversal.h" // for ForEachNode, BreadthFirstSearch +#include "VsyncSource.h" + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +static bool IsSameDimension(hal::ScreenOrientation o1, + hal::ScreenOrientation o2) { + bool isO1portrait = (o1 == hal::eScreenOrientation_PortraitPrimary || + o1 == hal::eScreenOrientation_PortraitSecondary); + bool isO2portrait = (o2 == hal::eScreenOrientation_PortraitPrimary || + o2 == hal::eScreenOrientation_PortraitSecondary); + return !(isO1portrait ^ isO2portrait); +} + +static bool ContentMightReflowOnOrientationChange(const IntRect& rect) { + return rect.Width() != rect.Height(); +} + +AsyncCompositionManager::AsyncCompositionManager( + CompositorBridgeParent* aParent, HostLayerManager* aManager) + : mLayerManager(aManager), + mIsFirstPaint(true), + mLayersUpdated(false), + mReadyForCompose(true), + mCompositorBridge(aParent) { + MOZ_ASSERT(mCompositorBridge); +} + +AsyncCompositionManager::~AsyncCompositionManager() = default; + +void AsyncCompositionManager::ResolveRefLayers( + CompositorBridgeParent* aCompositor, bool* aHasRemoteContent, + bool* aResolvePlugins) { + if (aHasRemoteContent) { + *aHasRemoteContent = false; + } + +#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK) + // If valid *aResolvePlugins indicates if we need to update plugin geometry + // when we walk the tree. + bool resolvePlugins = (aCompositor && aResolvePlugins && *aResolvePlugins); +#endif + + if (!mLayerManager->GetRoot()) { + // Updated the return value since this result controls completing + // composition. + if (aResolvePlugins) { + *aResolvePlugins = false; + } + return; + } + + mReadyForCompose = true; + bool hasRemoteContent = false; + bool didResolvePlugins = false; + + ForEachNode<ForwardIterator>(mLayerManager->GetRoot(), [&](Layer* layer) { + RefLayer* refLayer = layer->AsRefLayer(); + if (!refLayer) { + return; + } + + hasRemoteContent = true; + const CompositorBridgeParent::LayerTreeState* state = + CompositorBridgeParent::GetIndirectShadowTree( + refLayer->GetReferentId()); + if (!state) { + return; + } + + Layer* referent = state->mRoot; + if (!referent) { + return; + } + + if (!refLayer->GetLocalVisibleRegion().IsEmpty()) { + hal::ScreenOrientation chromeOrientation = mTargetConfig.orientation(); + hal::ScreenOrientation contentOrientation = + state->mTargetConfig.orientation(); + if (!IsSameDimension(chromeOrientation, contentOrientation) && + ContentMightReflowOnOrientationChange( + mTargetConfig.naturalBounds())) { + mReadyForCompose = false; + } + } + + refLayer->ConnectReferentLayer(referent); + +#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK) + if (resolvePlugins) { + didResolvePlugins |= + aCompositor->UpdatePluginWindowState(refLayer->GetReferentId()); + } +#endif + }); + + if (aHasRemoteContent) { + *aHasRemoteContent = hasRemoteContent; + } + if (aResolvePlugins) { + *aResolvePlugins = didResolvePlugins; + } +} + +void AsyncCompositionManager::DetachRefLayers() { + if (!mLayerManager->GetRoot()) { + return; + } + + mReadyForCompose = false; + + ForEachNodePostOrder<ForwardIterator>( + mLayerManager->GetRoot(), [&](Layer* layer) { + RefLayer* refLayer = layer->AsRefLayer(); + if (!refLayer) { + return; + } + + const CompositorBridgeParent::LayerTreeState* state = + CompositorBridgeParent::GetIndirectShadowTree( + refLayer->GetReferentId()); + if (!state) { + return; + } + + Layer* referent = state->mRoot; + if (referent) { + refLayer->DetachReferentLayer(referent); + } + }); +} + +void AsyncCompositionManager::ComputeRotation() { + if (!mTargetConfig.naturalBounds().IsEmpty()) { + mWorldTransform = ComputeTransformForRotation(mTargetConfig.naturalBounds(), + mTargetConfig.rotation()); + } +} + +static void GetBaseTransform(Layer* aLayer, Matrix4x4* aTransform) { + // Start with the animated transform if there is one + *aTransform = (aLayer->AsHostLayer()->GetShadowTransformSetByAnimation() + ? aLayer->GetLocalTransform() + : aLayer->GetTransform()); +} + +static void TransformClipRect( + Layer* aLayer, const ParentLayerToParentLayerMatrix4x4& aTransform) { + MOZ_ASSERT(aTransform.Is2D()); + const Maybe<ParentLayerIntRect>& clipRect = + aLayer->AsHostLayer()->GetShadowClipRect(); + if (clipRect) { + ParentLayerIntRect transformed = TransformBy(aTransform, *clipRect); + aLayer->AsHostLayer()->SetShadowClipRect(Some(transformed)); + } +} + +// Similar to TransformFixedClip(), but only transforms the fixed part of the +// clip. +static void TransformFixedClip( + Layer* aLayer, const ParentLayerToParentLayerMatrix4x4& aTransform, + AsyncCompositionManager::ClipParts& aClipParts) { + MOZ_ASSERT(aTransform.Is2D()); + if (aClipParts.mFixedClip) { + *aClipParts.mFixedClip = TransformBy(aTransform, *aClipParts.mFixedClip); + aLayer->AsHostLayer()->SetShadowClipRect(aClipParts.Intersect()); + } +} + +/** + * Set the given transform as the shadow transform on the layer, assuming + * that the given transform already has the pre- and post-scales applied. + * That is, this function cancels out the pre- and post-scales from aTransform + * before setting it as the shadow transform on the layer, so that when + * the layer's effective transform is computed, the pre- and post-scales will + * only be applied once. + */ +static void SetShadowTransform(Layer* aLayer, + LayerToParentLayerMatrix4x4 aTransform) { + if (ContainerLayer* c = aLayer->AsContainerLayer()) { + aTransform.PreScale(1.0f / c->GetPreXScale(), 1.0f / c->GetPreYScale(), 1); + } + aTransform.PostScale(1.0f / aLayer->GetPostXScale(), + 1.0f / aLayer->GetPostYScale(), 1); + aLayer->AsHostLayer()->SetShadowBaseTransform(aTransform.ToUnknownMatrix()); +} + +static void TranslateShadowLayer( + Layer* aLayer, const ParentLayerPoint& aTranslation, bool aAdjustClipRect, + AsyncCompositionManager::ClipPartsCache* aClipPartsCache) { + // This layer might also be a scrollable layer and have an async transform. + // To make sure we don't clobber that, we start with the shadow transform. + // (i.e. GetLocalTransform() instead of GetTransform()). + // Note that the shadow transform is reset on every frame of composition so + // we don't have to worry about the adjustments compounding over successive + // frames. + LayerToParentLayerMatrix4x4 layerTransform = aLayer->GetLocalTransformTyped(); + + // Apply the translation to the layer transform. + layerTransform.PostTranslate(aTranslation); + + SetShadowTransform(aLayer, layerTransform); + aLayer->AsHostLayer()->SetShadowTransformSetByAnimation(false); + + if (aAdjustClipRect) { + auto transform = + ParentLayerToParentLayerMatrix4x4::Translation(aTranslation); + // If we're passed a clip parts cache, only transform the fixed part of + // the clip. + if (aClipPartsCache) { + auto iter = aClipPartsCache->find(aLayer); + MOZ_ASSERT(iter != aClipPartsCache->end()); + TransformFixedClip(aLayer, transform, iter->second); + } else { + TransformClipRect(aLayer, transform); + } + + // If a fixed- or sticky-position layer has a mask layer, that mask should + // move along with the layer, so apply the translation to the mask layer + // too. + if (Layer* maskLayer = aLayer->GetMaskLayer()) { + TranslateShadowLayer(maskLayer, aTranslation, false, aClipPartsCache); + } + } +} + +static void AccumulateLayerTransforms(Layer* aLayer, Layer* aAncestor, + Matrix4x4& aMatrix) { + // Accumulate the transforms between this layer and the subtree root layer. + for (Layer* l = aLayer; l && l != aAncestor; l = l->GetParent()) { + Matrix4x4 transform; + GetBaseTransform(l, &transform); + aMatrix *= transform; + } +} + +/** + * Finds the metrics on |aLayer| with scroll id |aScrollId|, and returns a + * LayerMetricsWrapper representing the (layer, metrics) pair, or the null + * LayerMetricsWrapper if no matching metrics could be found. + */ +static LayerMetricsWrapper FindMetricsWithScrollId( + Layer* aLayer, ScrollableLayerGuid::ViewID aScrollId) { + for (uint64_t i = 0; i < aLayer->GetScrollMetadataCount(); ++i) { + if (aLayer->GetFrameMetrics(i).GetScrollId() == aScrollId) { + return LayerMetricsWrapper(aLayer, i); + } + } + return LayerMetricsWrapper(); +} + +/** + * Checks whether the (layer, metrics) pair (aTransformedLayer, + * aTransformedMetrics) is on the path from |aFixedLayer| to the metrics with + * scroll id |aFixedWithRespectTo|, inclusive. + */ +static bool AsyncTransformShouldBeUnapplied( + Layer* aFixedLayer, ScrollableLayerGuid::ViewID aFixedWithRespectTo, + Layer* aTransformedLayer, ScrollableLayerGuid::ViewID aTransformedMetrics) { + LayerMetricsWrapper transformed = + FindMetricsWithScrollId(aTransformedLayer, aTransformedMetrics); + if (!transformed.IsValid()) { + return false; + } + // It's important to start at the bottom, because the fixed layer itself + // could have the transformed metrics, and they can be at the bottom. + LayerMetricsWrapper current(aFixedLayer, + LayerMetricsWrapper::StartAt::BOTTOM); + bool encounteredTransformedLayer = false; + // The transformed layer is on the path from |aFixedLayer| to the fixed-to + // layer if as we walk up the (layer, metrics) tree starting from + // |aFixedLayer|, we *first* encounter the transformed layer, and *then* (or + // at the same time) the fixed-to layer. + while (current) { + if (!encounteredTransformedLayer && current == transformed) { + encounteredTransformedLayer = true; + } + if (current.Metrics().GetScrollId() == aFixedWithRespectTo) { + return encounteredTransformedLayer; + } + current = current.GetParent(); + // It's possible that we reach a layers id boundary before we reach an + // ancestor with the scroll id |aFixedWithRespectTo| (this could happen + // e.g. if the scroll frame with that scroll id uses containerless + // scrolling). In such a case, stop the walk, as a new layers id could + // have a different layer with scroll id |aFixedWithRespectTo| which we + // don't intend to match. + if (current && current.AsRefLayer() != nullptr) { + break; + } + } + return false; +} + +// If |aLayer| is fixed or sticky, returns the scroll id of the scroll frame +// that it's fixed or sticky to. Otherwise, returns Nothing(). +static Maybe<ScrollableLayerGuid::ViewID> IsFixedOrSticky(Layer* aLayer) { + bool isRootOfFixedSubtree = aLayer->GetIsFixedPosition() && + !aLayer->GetParent()->GetIsFixedPosition(); + if (isRootOfFixedSubtree) { + return Some(aLayer->GetFixedPositionScrollContainerId()); + } + if (aLayer->GetIsStickyPosition()) { + return Some(aLayer->GetStickyScrollContainerId()); + } + return Nothing(); +} + +void AsyncCompositionManager::AlignFixedAndStickyLayers( + Layer* aTransformedSubtreeRoot, Layer* aStartTraversalAt, + SideBits aStuckSides, ScrollableLayerGuid::ViewID aTransformScrollId, + const LayerToParentLayerMatrix4x4& aPreviousTransformForRoot, + const LayerToParentLayerMatrix4x4& aCurrentTransformForRoot, + const ScreenMargin& aFixedLayerMargins, ClipPartsCache& aClipPartsCache, + const ScreenMargin& aGeckoFixedLayerMargins) { + Layer* layer = aStartTraversalAt; + bool needsAsyncTransformUnapplied = false; + if (Maybe<ScrollableLayerGuid::ViewID> fixedTo = IsFixedOrSticky(layer)) { + needsAsyncTransformUnapplied = AsyncTransformShouldBeUnapplied( + layer, *fixedTo, aTransformedSubtreeRoot, aTransformScrollId); + } + + // We want to process all the fixed and sticky descendants of + // aTransformedSubtreeRoot. Once we do encounter such a descendant, we don't + // need to recurse any deeper because the adjustment to the fixed or sticky + // layer will apply to its subtree. + if (!needsAsyncTransformUnapplied) { + for (Layer* child = layer->GetFirstChild(); child; + child = child->GetNextSibling()) { + AlignFixedAndStickyLayers(aTransformedSubtreeRoot, child, aStuckSides, + aTransformScrollId, aPreviousTransformForRoot, + aCurrentTransformForRoot, aFixedLayerMargins, + aClipPartsCache, aGeckoFixedLayerMargins); + } + return; + } + + AdjustFixedOrStickyLayer(aTransformedSubtreeRoot, layer, aStuckSides, + aTransformScrollId, aPreviousTransformForRoot, + aCurrentTransformForRoot, aFixedLayerMargins, + aClipPartsCache, aGeckoFixedLayerMargins); +} + +// Determine the amount of overlap between the 1D vector |aTranslation| +// and the interval [aMin, aMax]. +static gfxFloat IntervalOverlap(gfxFloat aTranslation, gfxFloat aMin, + gfxFloat aMax) { + if (aTranslation > 0) { + return std::max(0.0, std::min(aMax, aTranslation) - std::max(aMin, 0.0)); + } + + return std::min(0.0, std::max(aMin, aTranslation) - std::min(aMax, 0.0)); +} + +void AsyncCompositionManager::AdjustFixedOrStickyLayer( + Layer* aTransformedSubtreeRoot, Layer* aFixedOrSticky, SideBits aStuckSides, + ScrollableLayerGuid::ViewID aTransformScrollId, + const LayerToParentLayerMatrix4x4& aPreviousTransformForRoot, + const LayerToParentLayerMatrix4x4& aCurrentTransformForRoot, + const ScreenMargin& aFixedLayerMargins, ClipPartsCache& aClipPartsCache, + const ScreenMargin& aGeckoFixedLayerMargins) { + Layer* layer = aFixedOrSticky; + + // Insert a translation so that the position of the anchor point is the same + // before and after the change to the transform of aTransformedSubtreeRoot. + + // Accumulate the transforms between this layer and the subtree root layer. + Matrix4x4 ancestorTransform; + if (layer != aTransformedSubtreeRoot) { + AccumulateLayerTransforms(layer->GetParent(), aTransformedSubtreeRoot, + ancestorTransform); + } + ancestorTransform.NudgeToIntegersFixedEpsilon(); + + // A transform creates a containing block for fixed-position descendants, + // so there shouldn't be a transform in between the fixed layer and + // the subtree root layer. + if (layer->GetIsFixedPosition()) { + MOZ_ASSERT(ancestorTransform.IsIdentity()); + } + + // Calculate the cumulative transforms between the subtree root with the + // old transform and the current transform. + // For coordinate purposes, we'll treat the subtree root layer as the + // "parent" layer, even though it could be a farther ancestor. + auto oldCumulativeTransform = ViewAs<LayerToParentLayerMatrix4x4>( + ancestorTransform * aPreviousTransformForRoot.ToUnknownMatrix()); + auto newCumulativeTransform = ViewAs<LayerToParentLayerMatrix4x4>( + ancestorTransform * aCurrentTransformForRoot.ToUnknownMatrix()); + + // We're going to be inverting |newCumulativeTransform|. If it's singular, + // there's nothing we can do. + if (newCumulativeTransform.IsSingular()) { + return; + } + + // Since we create container layers for fixed layers, there shouldn't + // a local CSS or OMTA transform on the fixed layer, either (any local + // transform would go onto a descendant layer inside the container + // layer). +#ifdef DEBUG + Matrix4x4 localTransform; + GetBaseTransform(layer, &localTransform); + localTransform.NudgeToIntegersFixedEpsilon(); + MOZ_ASSERT(localTransform.IsIdentity()); +#endif + + // Now work out the translation necessary to make sure the layer doesn't + // move given the new sub-tree root transform. + + // Get the layer's fixed anchor point, in the layer's local coordinate space + // (before any transform is applied). + LayerPoint anchor = layer->GetFixedPositionAnchor(); + + SideBits sideBits = layer->GetFixedPositionSides(); + if (layer->GetIsStickyPosition()) { + // For sticky items, it may be that only some of the sides are actively + // stuck. Only take into account those sides. + sideBits &= aStuckSides; + } + + // Offset the layer's anchor point to make sure fixed position content + // respects content document fixed position margins. + ScreenPoint offset = apz::ComputeFixedMarginsOffset( + aFixedLayerMargins, sideBits, + // For sticky layers, we don't need to factor aGeckoFixedLayerMargins + // because Gecko doesn't shift the position of sticky elements for dynamic + // toolbar movements. + layer->GetIsStickyPosition() ? ScreenMargin() : aGeckoFixedLayerMargins); + + // Fixed margins only apply to layers fixed to the root, so we can view + // the offset in layer space. + LayerPoint offsetAnchor = + anchor + ViewAs<LayerPixel>( + offset, PixelCastJustification::ScreenIsParentLayerForRoot); + + // Additionally transform the anchor to compensate for the change + // from the old transform to the new transform. We do + // this by using the old transform to take the offset anchor back into + // subtree root space, and then the inverse of the new transform + // to bring it back to layer space. + ParentLayerPoint offsetAnchorInSubtreeRootSpace = + oldCumulativeTransform.TransformPoint(offsetAnchor); + LayerPoint transformedAnchor = + newCumulativeTransform.Inverse().TransformPoint( + offsetAnchorInSubtreeRootSpace); + + // We want to translate the layer by the difference between + // |transformedAnchor| and |anchor|. + LayerPoint translation = transformedAnchor - anchor; + + // A fixed layer will "consume" (be unadjusted by) the entire translation + // calculated above. A sticky layer may consume all, part, or none of it, + // depending on where we are relative to its sticky scroll range. + // The remainder of the translation (the unconsumed portion) needs to + // be propagated to descendant fixed/sticky layers. + LayerPoint unconsumedTranslation; + + if (layer->GetIsStickyPosition()) { + // For sticky positioned layers, the difference between the two rectangles + // defines a pair of translation intervals in each dimension through which + // the layer should not move relative to the scroll container. To + // accomplish this, we limit each dimension of the |translation| to that + // part of it which overlaps those intervals. + const LayerRectAbsolute& stickyOuter = layer->GetStickyScrollRangeOuter(); + const LayerRectAbsolute& stickyInner = layer->GetStickyScrollRangeInner(); + + LayerPoint originalTranslation = translation; + translation.y = + IntervalOverlap(translation.y, stickyOuter.Y(), stickyOuter.YMost()) - + IntervalOverlap(translation.y, stickyInner.Y(), stickyInner.YMost()); + translation.x = + IntervalOverlap(translation.x, stickyOuter.X(), stickyOuter.XMost()) - + IntervalOverlap(translation.x, stickyInner.X(), stickyInner.XMost()); + unconsumedTranslation = translation - originalTranslation; + } + + // Finally, apply the translation to the layer transform. Note that in cases + // where the async transform on |aTransformedSubtreeRoot| affects this layer's + // clip rect, we need to apply the same translation to said clip rect, so + // that the effective transform on the clip rect takes it back to where it was + // originally, had there been no async scroll. + TranslateShadowLayer( + layer, + ViewAs<ParentLayerPixel>(translation, + PixelCastJustification::NoTransformOnLayer), + true, &aClipPartsCache); + + // Propragate the unconsumed portion of the translation to descendant + // fixed/sticky layers. + if (unconsumedTranslation != LayerPoint()) { + // Take the computations we performed to derive |translation| from + // |aCurrentTransformForRoot|, and perform them in reverse, keeping other + // quantities fixed, to come up with a new transform |newTransform| that + // would produce |unconsumedTranslation|. + LayerPoint newTransformedAnchor = unconsumedTranslation + anchor; + ParentLayerPoint newTransformedAnchorInSubtreeRootSpace = + oldCumulativeTransform.TransformPoint(newTransformedAnchor); + LayerToParentLayerMatrix4x4 newTransform = aPreviousTransformForRoot; + newTransform.PostTranslate(newTransformedAnchorInSubtreeRootSpace - + offsetAnchorInSubtreeRootSpace); + + // Propagate this new transform to our descendants as the new value of + // |aCurrentTransformForRoot|. This allows them to consume the unconsumed + // translation. + for (Layer* child = layer->GetFirstChild(); child; + child = child->GetNextSibling()) { + AlignFixedAndStickyLayers(aTransformedSubtreeRoot, child, aStuckSides, + aTransformScrollId, aPreviousTransformForRoot, + newTransform, aFixedLayerMargins, + aClipPartsCache, aGeckoFixedLayerMargins); + } + } +} + +bool AsyncCompositionManager::SampleAnimations(Layer* aLayer, + TimeStamp aCurrentFrameTime) { + CompositorAnimationStorage* storage = + mCompositorBridge->GetAnimationStorage(); + MOZ_ASSERT(storage); + + return storage->SampleAnimations(aLayer, mCompositorBridge, + mPreviousFrameTimeStamp, aCurrentFrameTime); +} + +void AsyncCompositionManager::RecordShadowTransforms(Layer* aLayer) { + MOZ_ASSERT(StaticPrefs::gfx_vsync_collect_scroll_transforms()); + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + + ForEachNodePostOrder<ForwardIterator>(aLayer, [this](Layer* layer) { + for (uint32_t i = 0; i < layer->GetScrollMetadataCount(); i++) { + if (!layer->GetFrameMetrics(i).IsScrollable()) { + continue; + } + gfx::Matrix4x4 shadowTransform = + layer->AsHostLayer()->GetShadowBaseTransform(); + if (!shadowTransform.Is2D()) { + continue; + } + + Matrix transform = shadowTransform.As2D(); + if (transform.IsTranslation() && !shadowTransform.IsIdentity()) { + Point translation = transform.GetTranslation(); + mLayerTransformRecorder.RecordTransform(layer, translation); + return; + } + } + }); +} + +static AsyncTransformComponentMatrix AdjustForClip( + const AsyncTransformComponentMatrix& asyncTransform, Layer* aLayer) { + AsyncTransformComponentMatrix result = asyncTransform; + + // Container layers start at the origin, but they are clipped to where they + // actually have content on the screen. The tree transform is meant to apply + // to the clipped area. If the tree transform includes a scale component, + // then applying it to container as-is will produce incorrect results. To + // avoid this, translate the layer so that the clip rect starts at the origin, + // apply the tree transform, and translate back. + if (const Maybe<ParentLayerIntRect>& shadowClipRect = + aLayer->AsHostLayer()->GetShadowClipRect()) { + if (shadowClipRect->TopLeft() != + ParentLayerIntPoint()) { // avoid a gratuitous change of basis + result.ChangeBasis(shadowClipRect->X(), shadowClipRect->Y(), 0); + } + } + return result; +} + +static void ExpandRootClipRect(Layer* aLayer, + const ScreenMargin& aFixedLayerMargins) { + // For Fennec we want to expand the root scrollable layer clip rect based on + // the fixed position margins. In particular, we want this while the dynamic + // toolbar is in the process of sliding offscreen and the area of the + // LayerView visible to the user is larger than the viewport size that Gecko + // knows about (and therefore larger than the clip rect). We could also just + // clear the clip rect on aLayer entirely but this seems more precise. + Maybe<ParentLayerIntRect> rootClipRect = + aLayer->AsHostLayer()->GetShadowClipRect(); + if (rootClipRect && aFixedLayerMargins != ScreenMargin()) { +#ifndef MOZ_WIDGET_ANDROID + // We should never enter here on anything other than Fennec, since + // aFixedLayerMargins should be empty everywhere else. + MOZ_ASSERT(false); +#endif + ParentLayerRect rect(rootClipRect.value()); + rect.Deflate(ViewAs<ParentLayerPixel>( + aFixedLayerMargins, + PixelCastJustification::ScreenIsParentLayerForRoot)); + aLayer->AsHostLayer()->SetShadowClipRect(Some(RoundedOut(rect))); + } +} + +#ifdef MOZ_WIDGET_ANDROID +static void MoveScrollbarForLayerMargin( + Layer* aRoot, ScrollableLayerGuid::ViewID aRootScrollId, + const ScreenMargin& aFixedLayerMargins) { + // See bug 1223928 comment 9 - once we can detect the RCD with just the + // isRootContent flag on the metrics, we can probably move this code into + // ApplyAsyncTransformToScrollbar rather than having it as a separate + // adjustment on the layer tree. + Layer* scrollbar = + BreadthFirstSearch<ReverseIterator>(aRoot, [aRootScrollId](Layer* aNode) { + return (aNode->GetScrollbarData().IsThumb() && + aNode->GetScrollbarData().mDirection.isSome() && + *aNode->GetScrollbarData().mDirection == + ScrollDirection::eHorizontal && + aNode->GetScrollbarData().mTargetViewId == aRootScrollId); + }); + if (scrollbar) { + // Shift the horizontal scrollbar down into the new space exposed by the + // dynamic toolbar hiding. Technically we should also scale the vertical + // scrollbar a bit to expand into the new space but it's not as noticeable + // and it would add a lot more complexity, so we're going with the "it's not + // worth it" justification. + TranslateShadowLayer(scrollbar, + ParentLayerPoint(0, -aFixedLayerMargins.bottom), true, + nullptr); + if (scrollbar->GetParent()) { + // The layer that has the HORIZONTAL direction sits inside another + // ContainerLayer. This ContainerLayer also has a clip rect that causes + // the scrollbar to get clipped. We need to expand that clip rect to + // prevent that from happening. This is kind of ugly in that we're + // assuming a particular layer tree structure but short of adding more + // flags to the layer there doesn't appear to be a good way to do this. + ExpandRootClipRect(scrollbar->GetParent(), aFixedLayerMargins); + } + } +} +#endif + +bool AsyncCompositionManager::ApplyAsyncContentTransformToTree( + Layer* aLayer, bool* aOutFoundRoot) { + bool appliedTransform = false; + std::stack<Maybe<ParentLayerIntRect>> stackDeferredClips; + std::stack<LayersId> layersIds; + layersIds.push(mCompositorBridge->RootLayerTreeId()); + + // Maps layers to their ClipParts. The parts are not stored individually + // on the layer, but during AlignFixedAndStickyLayers we need access to + // the individual parts for descendant layers. + ClipPartsCache clipPartsCache; + + Layer* zoomContainer = nullptr; + Maybe<LayerMetricsWrapper> zoomedMetrics; + + ForEachNode<ForwardIterator>( + aLayer, + [&](Layer* layer) { + if (layer->AsRefLayer()) { + layersIds.push(layer->AsRefLayer()->GetReferentId()); + } + + stackDeferredClips.push(Maybe<ParentLayerIntRect>()); + + // If we encounter the async zoom container, find the corresponding + // APZC and stash it into |zoomedMetrics|. + // (We stash it in the form of a LayerMetricsWrapper because + // APZSampler requires going through that rather than using the APZC + // directly.) + // We do this on the way down the tree (i.e. here in the pre-action) + // so that by the time we encounter the layers with the RCD-RSF's + // scroll metadata (which will be descendants of the async zoom + // container), we can check for it and know we should only apply the + // scroll portion of the async transform to those layers (as the zoom + // portion will go on the async zoom container). + if (Maybe<ScrollableLayerGuid::ViewID> zoomedScrollId = + layer->IsAsyncZoomContainer()) { + zoomContainer = layer; + ForEachNode<ForwardIterator>( + LayerMetricsWrapper(layer), + [zoomedScrollId, &zoomedMetrics](LayerMetricsWrapper aWrapper) { + // Do not descend into layer subtrees with a different layers + // id. + if (aWrapper.AsRefLayer()) { + return TraversalFlag::Skip; + } + + if (aWrapper.Metrics().GetScrollId() == *zoomedScrollId) { + zoomedMetrics = Some(aWrapper); + MOZ_ASSERT(zoomedMetrics->GetApzc()); + return TraversalFlag::Abort; + } + + return TraversalFlag::Continue; + }); + } + }, + [&](Layer* layer) { + Maybe<ParentLayerIntRect> clipDeferredFromChildren = + stackDeferredClips.top(); + stackDeferredClips.pop(); + MOZ_ASSERT(!layersIds.empty()); + LayersId currentLayersId = layersIds.top(); + LayerToParentLayerMatrix4x4 oldTransform = + layer->GetTransformTyped() * AsyncTransformMatrix(); + + AsyncTransformComponentMatrix combinedAsyncTransform; + bool hasAsyncTransform = false; + // Only set on the root layer for Android. + ScreenMargin fixedLayerMargins; + + // Each layer has multiple clips: + // - Its local clip, which is fixed to the layer contents, i.e. it + // moves with those async transforms which the layer contents move + // with. + // - Its scrolled clip, which moves with all async transforms. + // - For each ScrollMetadata on the layer, a scroll clip. This + // includes the composition bounds and any other clips induced by + // layout. This moves with async transforms from ScrollMetadatas + // above it. + // In this function, these clips are combined into two shadow clip + // parts: + // - The fixed clip, which consists of the local clip only, initially + // transformed by all async transforms. + // - The scrolled clip, which consists of the other clips, transformed + // by the appropriate transforms. + // These two parts are kept separate for now, because for fixed layers, + // we need to adjust the fixed clip (to cancel out some async + // transforms). The parts are kept in a cache which is cleared at the + // beginning of every composite. The final shadow clip for the layer is + // the intersection of the (possibly adjusted) fixed clip and the + // scrolled clip. + ClipParts& clipParts = clipPartsCache[layer]; + clipParts.mFixedClip = layer->GetClipRect(); + clipParts.mScrolledClip = layer->GetScrolledClipRect(); + + // If we are a perspective transform ContainerLayer, apply the clip + // deferred from our child (if there is any) before we iterate over our + // frame metrics, because this clip is subject to all async transforms + // of this layer. Since this clip came from the a scroll clip on the + // child, it becomes part of our scrolled clip. + clipParts.mScrolledClip = IntersectMaybeRects(clipDeferredFromChildren, + clipParts.mScrolledClip); + + // The transform of a mask layer is relative to the masked layer's + // parent layer. So whenever we apply an async transform to a layer, we + // need to apply that same transform to the layer's own mask layer. A + // layer can also have "ancestor" mask layers for any rounded clips from + // its ancestor scroll frames. A scroll frame mask layer only needs to + // be async transformed for async scrolls of this scroll frame's + // ancestor scroll frames, not for async scrolls of this scroll frame + // itself. In the loop below, we iterate over scroll frames from inside + // to outside. At each iteration, this array contains the layer's + // ancestor mask layers of all scroll frames inside the current one. + nsTArray<Layer*> ancestorMaskLayers; + + // The layer's scrolled clip can have an ancestor mask layer as well, + // which is moved by all async scrolls on this layer. + if (const Maybe<LayerClip>& scrolledClip = layer->GetScrolledClip()) { + if (scrolledClip->GetMaskLayerIndex()) { + ancestorMaskLayers.AppendElement(layer->GetAncestorMaskLayerAt( + *scrolledClip->GetMaskLayerIndex())); + } + } + + if (RefPtr<APZSampler> sampler = mCompositorBridge->GetAPZSampler()) { + for (uint32_t i = 0; i < layer->GetScrollMetadataCount(); i++) { + LayerMetricsWrapper wrapper(layer, i); + if (!wrapper.GetApzc()) { + continue; + } + + const FrameMetrics& metrics = wrapper.Metrics(); + MOZ_ASSERT(metrics.IsScrollable()); + + hasAsyncTransform = true; + + AsyncTransformComponents asyncTransformComponents = + (zoomedMetrics && + sampler->GetGuid(*zoomedMetrics) == sampler->GetGuid(wrapper)) + ? AsyncTransformComponents{AsyncTransformComponent::eLayout} + : LayoutAndVisual; + AsyncTransform asyncTransformWithoutOverscroll = + sampler->GetCurrentAsyncTransform(wrapper, + asyncTransformComponents); + Maybe<CompositionPayload> payload = + sampler->NotifyScrollSampling(wrapper); + // The scroll latency should be measured between composition and the + // first scrolling event. Otherwise we observe metrics with <16ms + // latency even when frame.delay is enabled. + if (payload.isSome()) { + mLayerManager->RegisterPayload(*payload); + } + + AsyncTransformComponentMatrix overscrollTransform = + sampler->GetOverscrollTransform(wrapper); + AsyncTransformComponentMatrix asyncTransform = + AsyncTransformComponentMatrix(asyncTransformWithoutOverscroll) * + overscrollTransform; + + if (!layer->IsScrollableWithoutContent()) { + sampler->MarkAsyncTransformAppliedToContent(wrapper); + } + + const ScrollMetadata& scrollMetadata = wrapper.Metadata(); + +#if defined(MOZ_WIDGET_ANDROID) + // If we find a metrics which is the root content doc, use that. If + // not, use the root layer. Since this function recurses on children + // first we should only end up using the root layer if the entire + // tree was devoid of a root content metrics. This is a temporary + // solution; in the long term we should not need the root content + // metrics at all. See bug 1201529 comment 6 for details. + if (!(*aOutFoundRoot)) { + *aOutFoundRoot = + metrics.IsRootContent() || /* RCD */ + (layer->GetParent() == nullptr && /* rootmost metrics */ + i + 1 >= layer->GetScrollMetadataCount()); + if (*aOutFoundRoot) { + mRootScrollableId = metrics.GetScrollId(); + Compositor* compositor = mLayerManager->GetCompositor(); + if (CompositorBridgeParent* bridge = + compositor->GetCompositorBridgeParent()) { + LayersId rootLayerTreeId = bridge->RootLayerTreeId(); + GeckoViewMetrics gvMetrics = + sampler->GetGeckoViewMetrics(wrapper); + if (mIsFirstPaint || GeckoViewMetricsHaveUpdated(gvMetrics)) { + if (RefPtr<UiCompositorControllerParent> uiController = + UiCompositorControllerParent:: + GetFromRootLayerTreeId(rootLayerTreeId)) { + uiController->NotifyUpdateScreenMetrics(gvMetrics); + } + mLastMetrics = gvMetrics; + } + if (mIsFirstPaint) { + if (RefPtr<UiCompositorControllerParent> uiController = + UiCompositorControllerParent:: + GetFromRootLayerTreeId(rootLayerTreeId)) { + uiController->NotifyFirstPaint(); + } + mIsFirstPaint = false; + } + if (mLayersUpdated) { + LayersId rootLayerTreeId = bridge->RootLayerTreeId(); + if (RefPtr<UiCompositorControllerParent> uiController = + UiCompositorControllerParent:: + GetFromRootLayerTreeId(rootLayerTreeId)) { + uiController->NotifyLayersUpdated(); + } + mLayersUpdated = false; + } + } + fixedLayerMargins = GetFixedLayerMargins(); + } + } +#else + *aOutFoundRoot = false; + // Non-Android platforms still care about this flag being cleared + // after the first call to TransformShadowTree(). + mIsFirstPaint = false; +#endif + + // Transform the current local clips by this APZC's async transform. + MOZ_ASSERT(asyncTransform.Is2D()); + if (clipParts.mFixedClip) { + *clipParts.mFixedClip = + TransformBy(asyncTransform, *clipParts.mFixedClip); + } + if (clipParts.mScrolledClip) { + *clipParts.mScrolledClip = + TransformBy(asyncTransform, *clipParts.mScrolledClip); + } + // Note: we don't set the layer's shadow clip rect property yet; + // AlignFixedAndStickyLayers will use the clip parts from the clip + // parts cache. + + combinedAsyncTransform *= asyncTransform; + + // For the purpose of aligning fixed and sticky layers, we disregard + // the overscroll transform as well as any OMTA transform when + // computing the 'aCurrentTransformForRoot' parameter. This ensures + // that the overscroll and OMTA transforms are not unapplied, and + // therefore that the visual effects apply to fixed and sticky + // layers. We do this by using GetTransform() as the base transform + // rather than GetLocalTransform(), which would include those + // factors. + LayerToParentLayerMatrix4x4 transformWithoutOverscrollOrOmta = + layer->GetTransformTyped() * + CompleteAsyncTransform(AdjustForClip(asyncTransform, layer)); + // See bug 1630274 for why we pass eNone here; fixing that bug will + // probably end up changing this to be more correct. + AlignFixedAndStickyLayers(layer, layer, SideBits::eNone, + metrics.GetScrollId(), oldTransform, + transformWithoutOverscrollOrOmta, + fixedLayerMargins, clipPartsCache, + sampler->GetGeckoFixedLayerMargins()); + + // Combine the local clip with the ancestor scrollframe clip. This + // is not included in the async transform above, since the ancestor + // clip should not move with this APZC. + if (scrollMetadata.HasScrollClip()) { + ParentLayerIntRect clip = + scrollMetadata.ScrollClip().GetClipRect(); + if (layer->GetParent() && + layer->GetParent()->GetTransformIsPerspective()) { + // If our parent layer has a perspective transform, we want to + // apply our scroll clip to it instead of to this layer (see bug + // 1168263). A layer with a perspective transform shouldn't have + // multiple children with FrameMetrics, nor a child with + // multiple FrameMetrics. (A child with multiple FrameMetrics + // would mean that there's *another* scrollable element between + // the one with the CSS perspective and the transformed element. + // But you'd have to use preserve-3d on the inner scrollable + // element in order to have the perspective apply to the + // transformed child, and preserve-3d is not supported on + // scrollable elements, so this case can't occur.) + MOZ_ASSERT(!stackDeferredClips.top()); + stackDeferredClips.top().emplace(clip); + } else { + clipParts.mScrolledClip = + IntersectMaybeRects(Some(clip), clipParts.mScrolledClip); + } + } + + // Do the same for the ancestor mask layers: ancestorMaskLayers + // contains the ancestor mask layers for scroll frames *inside* the + // current scroll frame, so these are the ones we need to shift by + // our async transform. + for (Layer* ancestorMaskLayer : ancestorMaskLayers) { + SetShadowTransform( + ancestorMaskLayer, + ancestorMaskLayer->GetLocalTransformTyped() * asyncTransform); + } + + // Append the ancestor mask layer for this scroll frame to + // ancestorMaskLayers. + if (scrollMetadata.HasScrollClip()) { + const LayerClip& scrollClip = scrollMetadata.ScrollClip(); + if (scrollClip.GetMaskLayerIndex()) { + size_t maskLayerIndex = scrollClip.GetMaskLayerIndex().value(); + Layer* ancestorMaskLayer = + layer->GetAncestorMaskLayerAt(maskLayerIndex); + ancestorMaskLayers.AppendElement(ancestorMaskLayer); + } + } + } + + if (Maybe<ScrollableLayerGuid::ViewID> zoomedScrollId = + layer->IsAsyncZoomContainer()) { + if (zoomedMetrics) { + AsyncTransform zoomTransform = sampler->GetCurrentAsyncTransform( + *zoomedMetrics, {AsyncTransformComponent::eVisual}); + hasAsyncTransform = true; + combinedAsyncTransform *= + AsyncTransformComponentMatrix(zoomTransform); + } else { + // TODO: Is this normal? It happens on some pages, such as + // about:config on mobile, for just one frame or so, before the + // scroll metadata for zoomedScrollId appears in the layer tree. + } + } + + auto IsFixedToZoomContainer = [&](Layer* aFixedLayer) { + if (!zoomedMetrics) { + return false; + } + ScrollableLayerGuid::ViewID targetId = + aFixedLayer->GetFixedPositionScrollContainerId(); + MOZ_ASSERT(targetId != ScrollableLayerGuid::NULL_SCROLL_ID); + ScrollableLayerGuid rootContent = sampler->GetGuid(*zoomedMetrics); + return rootContent.mScrollId == targetId && + rootContent.mLayersId == currentLayersId; + }; + + auto SidesStuckToZoomContainer = [&](Layer* aLayer) -> SideBits { + SideBits result = SideBits::eNone; + if (!zoomedMetrics) { + return result; + } + if (!aLayer->GetIsStickyPosition()) { + return result; + } + + ScrollableLayerGuid::ViewID targetId = + aLayer->GetStickyScrollContainerId(); + if (targetId == ScrollableLayerGuid::NULL_SCROLL_ID) { + return result; + } + + ScrollableLayerGuid rootContent = sampler->GetGuid(*zoomedMetrics); + if (rootContent.mScrollId != targetId || + rootContent.mLayersId != currentLayersId) { + return result; + } + + ParentLayerPoint translation = + sampler + ->GetCurrentAsyncTransform( + *zoomedMetrics, {AsyncTransformComponent::eLayout}) + .mTranslation; + + if (apz::IsStuckAtBottom(translation.y, + aLayer->GetStickyScrollRangeInner(), + aLayer->GetStickyScrollRangeOuter())) { + result |= SideBits::eBottom; + } + if (apz::IsStuckAtTop(translation.y, + aLayer->GetStickyScrollRangeInner(), + aLayer->GetStickyScrollRangeOuter())) { + result |= SideBits::eTop; + } + return result; + }; + + // Layers fixed to the RCD-RSF no longer need + // AdjustFixedOrStickyLayer() to scroll them by the eVisual transform, + // as that's now applied to the async zoom container itself. However, + // we still need to adjust them by the fixed layer margins to + // account for dynamic toolbar transitions. This is also handled by + // AdjustFixedOrStickyLayer(), so we now call it with empty transforms + // to get it to perform just the fixed margins adjustment. + SideBits stuckSides = SidesStuckToZoomContainer(layer); + if (zoomedMetrics && ((layer->GetIsFixedPosition() && + !layer->GetParent()->GetIsFixedPosition() && + IsFixedToZoomContainer(layer)) || + stuckSides != SideBits::eNone)) { + LayerToParentLayerMatrix4x4 emptyTransform; + ScreenMargin marginsForFixedLayer = GetFixedLayerMargins(); + AdjustFixedOrStickyLayer(zoomContainer, layer, stuckSides, + sampler->GetGuid(*zoomedMetrics).mScrollId, + emptyTransform, emptyTransform, + marginsForFixedLayer, clipPartsCache, + sampler->GetGeckoFixedLayerMargins()); + } + } + + bool clipChanged = (hasAsyncTransform || clipDeferredFromChildren || + layer->GetScrolledClipRect()); + if (clipChanged) { + // Intersect the two clip parts and apply them to the layer. + // During ApplyAsyncContentTransformTree on an ancestor layer, + // AlignFixedAndStickyLayers may overwrite this with a new clip it + // computes from the clip parts, but if that doesn't happen, this + // is the layer's final clip rect. + layer->AsHostLayer()->SetShadowClipRect(clipParts.Intersect()); + } + + if (hasAsyncTransform) { + // Apply the APZ transform on top of GetLocalTransform() here (rather + // than GetTransform()) in case the OMTA code in SampleAnimations + // already set a shadow transform; in that case we want to apply ours + // on top of that one rather than clobber it. + SetShadowTransform(layer, + layer->GetLocalTransformTyped() * + AdjustForClip(combinedAsyncTransform, layer)); + + // Do the same for the layer's own mask layer, if it has one. + if (Layer* maskLayer = layer->GetMaskLayer()) { + SetShadowTransform(maskLayer, maskLayer->GetLocalTransformTyped() * + combinedAsyncTransform); + } + + appliedTransform = true; + } + + ExpandRootClipRect(layer, fixedLayerMargins); + + if (layer->GetScrollbarData().mScrollbarLayerType == + layers::ScrollbarLayerType::Thumb) { + ApplyAsyncTransformToScrollbar(layer); + } + + if (layer->AsRefLayer()) { + MOZ_ASSERT(layersIds.size() > 1); + layersIds.pop(); + } + }); + + return appliedTransform; +} + +#if defined(MOZ_WIDGET_ANDROID) +bool AsyncCompositionManager::GeckoViewMetricsHaveUpdated( + const GeckoViewMetrics& aMetrics) { + return RoundedToInt(mLastMetrics.mVisualScrollOffset) != + RoundedToInt(aMetrics.mVisualScrollOffset) || + mLastMetrics.mZoom != aMetrics.mZoom; +} +#endif + +static bool LayerIsScrollbarTarget(const LayerMetricsWrapper& aTarget, + Layer* aScrollbar) { + if (!aTarget.GetApzc()) { + return false; + } + const FrameMetrics& metrics = aTarget.Metrics(); + MOZ_ASSERT(metrics.IsScrollable()); + if (metrics.GetScrollId() != aScrollbar->GetScrollbarData().mTargetViewId) { + return false; + } + return !metrics.IsScrollInfoLayer(); +} + +static void ApplyAsyncTransformToScrollbarForContent( + const RefPtr<APZSampler>& aSampler, Layer* aScrollbar, + const LayerMetricsWrapper& aContent, bool aScrollbarIsDescendant) { + AsyncTransformComponentMatrix clipTransform; + + MOZ_ASSERT(aSampler); + LayerToParentLayerMatrix4x4 transform = + aSampler->ComputeTransformForScrollThumb( + aScrollbar->GetLocalTransformTyped(), aContent, + aScrollbar->GetScrollbarData(), aScrollbarIsDescendant, + &clipTransform); + + if (aScrollbarIsDescendant) { + // We also need to make a corresponding change on the clip rect of all the + // layers on the ancestor chain from the scrollbar layer up to but not + // including the layer with the async transform. Otherwise the scrollbar + // shifts but gets clipped and so appears to flicker. + for (Layer* ancestor = aScrollbar; ancestor != aContent.GetLayer(); + ancestor = ancestor->GetParent()) { + TransformClipRect(ancestor, clipTransform); + } + } + + SetShadowTransform(aScrollbar, transform); +} + +static LayerMetricsWrapper FindScrolledLayerForScrollbar(Layer* aScrollbar, + bool* aOutIsAncestor) { + // First check if the scrolled layer is an ancestor of the scrollbar layer. + LayerMetricsWrapper root(aScrollbar->Manager()->GetRoot()); + LayerMetricsWrapper prevAncestor(aScrollbar); + LayerMetricsWrapper scrolledLayer; + + for (LayerMetricsWrapper ancestor(aScrollbar); ancestor; + ancestor = ancestor.GetParent()) { + // Don't walk into remote layer trees; the scrollbar will always be in + // the same layer space. + if (ancestor.AsRefLayer()) { + root = prevAncestor; + break; + } + prevAncestor = ancestor; + + if (LayerIsScrollbarTarget(ancestor, aScrollbar)) { + *aOutIsAncestor = true; + return ancestor; + } + } + + // Search the entire layer space of the scrollbar. + ForEachNode<ForwardIterator>(root, [&root, &scrolledLayer, &aScrollbar]( + LayerMetricsWrapper aLayerMetrics) { + // Do not recurse into RefLayers, since our initial aSubtreeRoot is the + // root (or RefLayer root) of a single layer space to search. + if (root != aLayerMetrics && aLayerMetrics.AsRefLayer()) { + return TraversalFlag::Skip; + } + if (LayerIsScrollbarTarget(aLayerMetrics, aScrollbar)) { + scrolledLayer = aLayerMetrics; + return TraversalFlag::Abort; + } + return TraversalFlag::Continue; + }); + return scrolledLayer; +} + +void AsyncCompositionManager::ApplyAsyncTransformToScrollbar(Layer* aLayer) { + // If this layer corresponds to a scrollbar, then there should be a layer that + // is a previous sibling or a parent that has a matching ViewID on its + // FrameMetrics. That is the content that this scrollbar is for. We pick up + // the transient async transform from that layer and use it to update the + // scrollbar position. Note that it is possible that the content layer is no + // longer there; in this case we don't need to do anything because there can't + // be an async transform on the content. + bool isAncestor = false; + const LayerMetricsWrapper& scrollTarget = + FindScrolledLayerForScrollbar(aLayer, &isAncestor); + if (scrollTarget) { + ApplyAsyncTransformToScrollbarForContent(mCompositorBridge->GetAPZSampler(), + aLayer, scrollTarget, isAncestor); + } +} + +void AsyncCompositionManager::GetFrameUniformity( + FrameUniformityData* aOutData) { + MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread()); + mLayerTransformRecorder.EndTest(aOutData); +} + +bool AsyncCompositionManager::TransformShadowTree( + const SampleTime& aCurrentFrame, TimeDuration aVsyncRate, + CompositorBridgeParentBase::TransformsToSkip aSkip) { + AUTO_PROFILER_LABEL("AsyncCompositionManager::TransformShadowTree", GRAPHICS); + + Layer* root = mLayerManager->GetRoot(); + if (!root) { + return false; + } + + // First, compute and set the shadow transforms from OMT animations. + // NB: we must sample animations *before* sampling pan/zoom + // transforms. + bool wantNextFrame = SampleAnimations(root, aCurrentFrame.Time()); + + // Advance animations to the next expected vsync timestamp, if we can + // get it. + SampleTime nextFrame = aCurrentFrame; + + MOZ_ASSERT(aVsyncRate != TimeDuration::Forever()); + if (aVsyncRate != TimeDuration::Forever()) { + nextFrame = nextFrame + aVsyncRate; + } + + // Reset the previous time stamp if we don't already have any running + // animations to avoid using the time which is far behind for newly + // started animations. + mPreviousFrameTimeStamp = wantNextFrame ? aCurrentFrame.Time() : TimeStamp(); + + if (!(aSkip & CompositorBridgeParentBase::TransformsToSkip::APZ)) { + bool apzAnimating = false; + if (RefPtr<APZSampler> apz = mCompositorBridge->GetAPZSampler()) { + apzAnimating = apz->AdvanceAnimations(nextFrame); + } + wantNextFrame |= apzAnimating; + + // Apply an async content transform to any layer that has + // an async pan zoom controller. + bool foundRoot = false; + if (ApplyAsyncContentTransformToTree(root, &foundRoot)) { +#if defined(MOZ_WIDGET_ANDROID) + MOZ_ASSERT(foundRoot); + if (foundRoot && GetFixedLayerMargins() != ScreenMargin()) { + MoveScrollbarForLayerMargin(root, mRootScrollableId, + GetFixedLayerMargins()); + } +#endif + } + } + + HostLayer* rootComposite = root->AsHostLayer(); + + gfx::Matrix4x4 trans = rootComposite->GetShadowBaseTransform(); + trans *= gfx::Matrix4x4::From2D(mWorldTransform); + rootComposite->SetShadowBaseTransform(trans); + + if (StaticPrefs::gfx_vsync_collect_scroll_transforms()) { + RecordShadowTransforms(root); + } + + return wantNextFrame; +} + +void AsyncCompositionManager::SetFixedLayerMargins(ScreenIntCoord aTop, + ScreenIntCoord aBottom) { + mFixedLayerMargins.top = aTop; + mFixedLayerMargins.bottom = aBottom; +} +ScreenMargin AsyncCompositionManager::GetFixedLayerMargins() const { + ScreenMargin result = mFixedLayerMargins; + if (StaticPrefs::apz_fixed_margin_override_enabled()) { + result.top = StaticPrefs::apz_fixed_margin_override_top(); + result.bottom = StaticPrefs::apz_fixed_margin_override_bottom(); + } + return result; +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/AsyncCompositionManager.h b/gfx/layers/composite/AsyncCompositionManager.h new file mode 100644 index 0000000000..474f653f99 --- /dev/null +++ b/gfx/layers/composite/AsyncCompositionManager.h @@ -0,0 +1,273 @@ +/* -*- 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_ASYNCCOMPOSITIONMANAGER_H +#define GFX_ASYNCCOMPOSITIONMANAGER_H + +#include "Units.h" // for ScreenPoint, etc +#include "FrameMetrics.h" // for FrameMetrics +#include "mozilla/layers/APZUtils.h" // for GeckoViewMetrics +#include "mozilla/layers/CompositorBridgeParent.h" // for TransformsToSkip +#include "mozilla/layers/LayerManagerComposite.h" // for LayerManagerComposite +#include "mozilla/Attributes.h" // for final, etc +#include "mozilla/RefPtr.h" // for RefCounted +#include "mozilla/TimeStamp.h" // for TimeStamp +#include "mozilla/gfx/BasePoint.h" // for BasePoint +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/HalScreenConfiguration.h" // For ScreenOrientation +#include "mozilla/layers/FrameUniformityData.h" // For FrameUniformityData +#include "mozilla/layers/LayersMessages.h" // for TargetConfig +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsISupportsImpl.h" // for LayerManager::AddRef, etc + +namespace mozilla { +namespace layers { + +class Layer; +class LayerManagerComposite; +class AutoResolveRefLayers; +class CompositorBridgeParent; +class SampleTime; + +/** + * Manage async composition effects. This class is only used with OMTC and only + * lives on the compositor thread. It is a layer on top of the layer manager + * (LayerManagerComposite) which deals with elements of composition which are + * usually dealt with by dom or layout when main thread rendering, but which can + * short circuit that stuff to directly affect layers as they are composited, + * for example, off-main thread animation, async video, async pan/zoom. + */ +class AsyncCompositionManager final { + friend class AutoResolveRefLayers; + ~AsyncCompositionManager(); + + public: + NS_INLINE_DECL_REFCOUNTING(AsyncCompositionManager) + + AsyncCompositionManager(CompositorBridgeParent* aParent, + HostLayerManager* aManager); + + /** + * This forces the is-first-paint flag to true. This is intended to + * be called by the widget code when it loses its viewport information + * (or for whatever reason wants to refresh the viewport information). + * The information refresh happens because the compositor will call + * AndroidDynamicToolbarAnimator::FirstPaint() on the next frame of + * composition. + */ + void ForceIsFirstPaint() { mIsFirstPaint = true; } + + // Sample transforms for layer trees. Return true to request + // another animation frame. + bool TransformShadowTree( + const SampleTime& aCurrentFrame, TimeDuration aVsyncRate, + CompositorBridgeParentBase::TransformsToSkip aSkip = + CompositorBridgeParentBase::TransformsToSkip::NoneOfThem); + + // Calculates the correct rotation and applies the transform to + // our layer manager + void ComputeRotation(); + + // Call after updating our layer tree. + void Updated(bool isFirstPaint, const TargetConfig& aTargetConfig) { + mIsFirstPaint |= isFirstPaint; + mLayersUpdated = true; + mTargetConfig = aTargetConfig; + } + + bool RequiresReorientation(hal::ScreenOrientation aOrientation) const { + return mTargetConfig.orientation() != aOrientation; + } + + // True if the underlying layer tree is ready to be composited. + bool ReadyForCompose() { return mReadyForCompose; } + + // Returns true if the next composition will be the first for a + // particular document. + bool IsFirstPaint() { return mIsFirstPaint; } + + // GetFrameUniformity will return the frame uniformity for each layer attached + // to an APZ from the recorded data in RecordShadowTransform + void GetFrameUniformity(FrameUniformityData* aFrameUniformityData); + + // Stores the clip rect of a layer in two parts: a fixed part and a scrolled + // part. When a layer is fixed, the clip needs to be adjusted to account for + // async transforms. Only the fixed part needs to be adjusted, so we need + // to store the two parts separately. + struct ClipParts { + Maybe<ParentLayerIntRect> mFixedClip; + Maybe<ParentLayerIntRect> mScrolledClip; + + Maybe<ParentLayerIntRect> Intersect() const { + return IntersectMaybeRects(mFixedClip, mScrolledClip); + } + }; + + typedef std::map<Layer*, ClipParts> ClipPartsCache; + + private: + // Return true if an AsyncPanZoomController content transform was + // applied for |aLayer|. |*aOutFoundRoot| is set to true on Android only, if + // one of the metrics on one of the layers was determined to be the "root" + // and its state was synced to the Java front-end. |aOutFoundRoot| must be + // non-null. + bool ApplyAsyncContentTransformToTree(Layer* aLayer, bool* aOutFoundRoot); + /** + * Update the shadow transform for aLayer assuming that is a scrollbar, + * so that it stays in sync with the content that is being scrolled by APZ. + */ + void ApplyAsyncTransformToScrollbar(Layer* aLayer); + + /** + * Adds a translation to the transform of any fixed position (whose parent + * layer is not fixed) or sticky position layer descendant of + * |aTransformedSubtreeRoot|. The translation is chosen so that the layer's + * anchor point relative to |aTransformedSubtreeRoot|'s parent layer is the + * same as it was when |aTransformedSubtreeRoot|'s GetLocalTransform() was + * |aPreviousTransformForRoot|. |aCurrentTransformForRoot| is + * |aTransformedSubtreeRoot|'s current GetLocalTransform() modulo any + * overscroll-related transform, which we don't want to adjust for. + * For sticky position layers, the translation is further intersected with + * the layer's sticky scroll ranges. + * This function will also adjust layers so that the given content document + * fixed position margins will be respected during asynchronous panning and + * zooming. + * |aTransformScrollId| is the scroll id of the scroll frame that scrolls + * |aTransformedSubtreeRoot|. + * |aClipPartsCache| maps layers to separate fixed and scrolled + * clips, so we can only adjust the fixed portion. + * This function has a recursive implementation; aStartTraversalAt specifies + * where to start the current recursion of the traversal. For the initial + * call, it should be the same as aTrasnformedSubtreeRoot. + */ + void AlignFixedAndStickyLayers( + Layer* aTransformedSubtreeRoot, Layer* aStartTraversalAt, + SideBits aStuckSides, ScrollableLayerGuid::ViewID aTransformScrollId, + const LayerToParentLayerMatrix4x4& aPreviousTransformForRoot, + const LayerToParentLayerMatrix4x4& aCurrentTransformForRoot, + const ScreenMargin& aCompositorFixedLayerMargins, + ClipPartsCache& aClipPartsCache, + const ScreenMargin& aGeckoFixedLayerMargins); + + /** + * Helper function for AlignFixedAndStickyLayers() to perform a transform + * adjustment for a single fixed or sticky layer, rather than all such + * layers rooted at a subtree. May also be called directly. + */ + void AdjustFixedOrStickyLayer( + Layer* aTransformedSubtreeRoot, Layer* aFixedOrSticky, + SideBits aStuckSides, ScrollableLayerGuid::ViewID aTransformScrollId, + const LayerToParentLayerMatrix4x4& aPreviousTransformForRoot, + const LayerToParentLayerMatrix4x4& aCurrentTransformForRoot, + const ScreenMargin& aCompositorFixedLayerMargins, + ClipPartsCache& aClipPartsCache, + const ScreenMargin& aGeckoFixedLayerMargins); + + /** + * DRAWING PHASE ONLY + * + * For reach RefLayer in our layer tree, look up its referent and connect it + * to the layer tree, if found. + * aHasRemoteContent - indicates if the layer tree contains a remote reflayer. + * May be null. + * aResolvePlugins - incoming value indicates if plugin windows should be + * updated through a call on aCompositor's UpdatePluginWindowState. Applies + * to linux and windows only, may be null. On return value indicates + * if any updates occured. + */ + void ResolveRefLayers(CompositorBridgeParent* aCompositor, + bool* aHasRemoteContent, bool* aResolvePlugins); + + /** + * Detaches all referents resolved by ResolveRefLayers. + * Assumes that mLayerManager->GetRoot() and mTargetConfig have not changed + * since ResolveRefLayers was called. + */ + void DetachRefLayers(); + + // Records the shadow transforms for the tree of layers rooted at the given + // layer + void RecordShadowTransforms(Layer* aLayer); + + bool SampleAnimations(Layer* aLayer, TimeStamp aCurrentFrameTime); + + TargetConfig mTargetConfig; + CSSRect mContentRect; + + RefPtr<HostLayerManager> mLayerManager; + // When this flag is set, the next composition will be the first for a + // particular document (i.e. the document displayed on the screen will + // change). This happens when loading a new page or switching tabs. We notify + // the front-end (e.g. Java on Android) about this so that it take the new + // page size and zoom into account when providing us with the next view + // transform. + bool mIsFirstPaint; + + // This flag is set during a layers update, so that the first composition + // after a layers update has it set. It is cleared after that first + // composition. + bool mLayersUpdated; + + bool mReadyForCompose; + + gfx::Matrix mWorldTransform; + LayerTransformRecorder mLayerTransformRecorder; + + TimeStamp mPreviousFrameTimeStamp; + + MOZ_NON_OWNING_REF CompositorBridgeParent* mCompositorBridge; + + public: + void SetFixedLayerMargins(ScreenIntCoord aTop, ScreenIntCoord aBottom); + ScreenMargin GetFixedLayerMargins() const; + + private: + ScreenMargin mFixedLayerMargins; + +#ifdef MOZ_WIDGET_ANDROID + private: + // This calculates whether GeckoView metrics should be sent to Java. + bool GeckoViewMetricsHaveUpdated(const GeckoViewMetrics& aMetrics); + // This holds the most recent GeckoView metrics sent to Java, and is used + // to send new updates when it changes. + GeckoViewMetrics mLastMetrics; + // The following two fields are only needed on Fennec with C++ APZ, because + // then we need to reposition the gecko scrollbar to deal with the + // dynamic toolbar shifting content around. + ScrollableLayerGuid::ViewID mRootScrollableId; +#endif +}; + +class MOZ_STACK_CLASS AutoResolveRefLayers { + public: + explicit AutoResolveRefLayers(AsyncCompositionManager* aManager, + CompositorBridgeParent* aCompositor = nullptr, + bool* aHasRemoteContent = nullptr, + bool* aResolvePlugins = nullptr) + : mManager(aManager) { + if (mManager) { + mManager->ResolveRefLayers(aCompositor, aHasRemoteContent, + aResolvePlugins); + } + } + + ~AutoResolveRefLayers() { + if (mManager) { + mManager->DetachRefLayers(); + } + } + + private: + AsyncCompositionManager* mManager; + + AutoResolveRefLayers(const AutoResolveRefLayers&) = delete; + AutoResolveRefLayers& operator=(const AutoResolveRefLayers&) = delete; +}; + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/CanvasLayerComposite.cpp b/gfx/layers/composite/CanvasLayerComposite.cpp new file mode 100644 index 0000000000..9b1d4aa78b --- /dev/null +++ b/gfx/layers/composite/CanvasLayerComposite.cpp @@ -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/. */ + +#include "CanvasLayerComposite.h" +#include "composite/CompositableHost.h" // for CompositableHost +#include "gfx2DGlue.h" // for ToFilter +#include "gfxEnv.h" // for gfxEnv, etc +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/Effects.h" // for EffectChain +#include "mozilla/layers/LayerManagerCompositeUtils.h" +#include "mozilla/mozalloc.h" // for operator delete +#include "nsAString.h" +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "nsString.h" // for nsAutoCString + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +CanvasLayerComposite::CanvasLayerComposite(LayerManagerComposite* aManager) + : CanvasLayer(aManager, nullptr), + LayerComposite(aManager), + mCompositableHost(nullptr) { + MOZ_COUNT_CTOR(CanvasLayerComposite); + mImplData = static_cast<LayerComposite*>(this); +} + +CanvasLayerComposite::~CanvasLayerComposite() { + MOZ_COUNT_DTOR(CanvasLayerComposite); + + CleanupResources(); +} + +bool CanvasLayerComposite::SetCompositableHost(CompositableHost* aHost) { + switch (aHost->GetType()) { + case CompositableType::IMAGE: { + if (mCompositableHost && aHost != mCompositableHost) { + mCompositableHost->Detach(this); + } + mCompositableHost = aHost; + return true; + } + default: + return false; + } +} + +Layer* CanvasLayerComposite::GetLayer() { return this; } + +void CanvasLayerComposite::SetLayerManager(HostLayerManager* aManager) { + LayerComposite::SetLayerManager(aManager); + mManager = aManager; + if (mCompositableHost && mCompositor) { + mCompositableHost->SetTextureSourceProvider(mCompositor); + } +} + +void CanvasLayerComposite::RenderLayer(const IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + if (!mCompositableHost || !mCompositableHost->IsAttached()) { + return; + } + + mCompositor->MakeCurrent(); + +#ifdef MOZ_DUMP_PAINTING + if (gfxEnv::DumpCompositorTextures()) { + RefPtr<gfx::DataSourceSurface> surf = mCompositableHost->GetAsSurface(); + if (surf) { + WriteSnapshotToDumpFile(this, surf); + } + } +#endif + + RenderWithAllMasks(this, mCompositor, aClipRect, + [&](EffectChain& effectChain, const IntRect& clipRect) { + mCompositableHost->Composite( + mCompositor, this, effectChain, + GetEffectiveOpacity(), GetEffectiveTransform(), + GetSamplingFilter(), clipRect); + }); + + mCompositableHost->BumpFlashCounter(); +} + +CompositableHost* CanvasLayerComposite::GetCompositableHost() { + if (mCompositableHost && mCompositableHost->IsAttached()) { + return mCompositableHost.get(); + } + + return nullptr; +} + +void CanvasLayerComposite::CleanupResources() { + if (mCompositableHost) { + mCompositableHost->Detach(this); + } + mCompositableHost = nullptr; +} + +gfx::SamplingFilter CanvasLayerComposite::GetSamplingFilter() { + gfx::SamplingFilter filter = mSamplingFilter; +#ifdef ANDROID + // Bug 691354 + // Using the LINEAR filter we get unexplained artifacts. + // Use NEAREST when no scaling is required. + Matrix matrix; + bool is2D = GetEffectiveTransform().Is2D(&matrix); + if (is2D && !ThebesMatrix(matrix).HasNonTranslationOrFlip()) { + filter = SamplingFilter::POINT; + } +#endif + return filter; +} + +void CanvasLayerComposite::GenEffectChain(EffectChain& aEffect) { + aEffect.mLayerRef = this; + aEffect.mPrimaryEffect = mCompositableHost->GenEffect(GetSamplingFilter()); +} + +void CanvasLayerComposite::PrintInfo(std::stringstream& aStream, + const char* aPrefix) { + CanvasLayer::PrintInfo(aStream, aPrefix); + aStream << "\n"; + if (mCompositableHost && mCompositableHost->IsAttached()) { + nsAutoCString pfx(aPrefix); + pfx += " "; + mCompositableHost->PrintInfo(aStream, pfx.get()); + } +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/CanvasLayerComposite.h b/gfx/layers/composite/CanvasLayerComposite.h new file mode 100644 index 0000000000..dbe29fbb6d --- /dev/null +++ b/gfx/layers/composite/CanvasLayerComposite.h @@ -0,0 +1,72 @@ +/* -*- 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_CanvasLayerComposite_H +#define GFX_CanvasLayerComposite_H + +#include "Layers.h" // for CanvasLayer, etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/layers/LayerManagerComposite.h" // for LayerComposite, etc +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nscore.h" // for nsACString + +namespace mozilla { +namespace layers { + +class CompositableHost; +// Canvas layers use ImageHosts (but CanvasClients) because compositing a +// canvas is identical to compositing an image. +class ImageHost; + +class CanvasLayerComposite : public CanvasLayer, public LayerComposite { + public: + explicit CanvasLayerComposite(LayerManagerComposite* aManager); + + protected: + virtual ~CanvasLayerComposite(); + + public: + bool SetCompositableHost(CompositableHost* aHost) override; + + void Disconnect() override { Destroy(); } + + void SetLayerManager(HostLayerManager* aManager) override; + + Layer* GetLayer() override; + void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) override; + + void CleanupResources() override; + + void GenEffectChain(EffectChain& aEffect) override; + + CompositableHost* GetCompositableHost() override; + + HostLayer* AsHostLayer() override { return this; } + + const char* Name() const override { return "CanvasLayerComposite"; } + + protected: + RefPtr<CanvasRenderer> CreateCanvasRendererInternal() override { + MOZ_CRASH("Incompatible surface type"); + return nullptr; + } + + void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; + + private: + gfx::SamplingFilter GetSamplingFilter(); + + private: + RefPtr<CompositableHost> mCompositableHost; +}; + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_CanvasLayerComposite_H */ diff --git a/gfx/layers/composite/ColorLayerComposite.cpp b/gfx/layers/composite/ColorLayerComposite.cpp new file mode 100644 index 0000000000..4b17a216e8 --- /dev/null +++ b/gfx/layers/composite/ColorLayerComposite.cpp @@ -0,0 +1,63 @@ +/* -*- 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 "ColorLayerComposite.h" +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for Color +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorTypes.h" // for DiagnosticFlags::COLOR +#include "mozilla/layers/Effects.h" // for Effect, EffectChain, etc +#include "mozilla/layers/LayerManagerCompositeUtils.h" +#include "mozilla/mozalloc.h" // for operator delete, etc +#include "UnitTransforms.h" // for ViewAs + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +void ColorLayerComposite::RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + const Matrix4x4& transform = GetEffectiveTransform(); + +#ifdef MOZ_GFX_OPTIMIZE_MOBILE + // On desktop we want to draw a single rectangle to avoid possible + // seams if we're resampling. On mobile we'd prefer to use the accurate + // region for better performance. + LayerIntRegion drawRegion = GetLocalVisibleRegion(); +#else + LayerIntRegion drawRegion = ViewAs<LayerPixel>(GetBounds()); +#endif + + for (auto iter = drawRegion.RectIter(); !iter.Done(); iter.Next()) { + const LayerIntRect& rect = iter.Get(); + Rect graphicsRect(rect.X(), rect.Y(), rect.Width(), rect.Height()); + + RenderWithAllMasks(this, mCompositor, aClipRect, + [&](EffectChain& effectChain, const IntRect& clipRect) { + GenEffectChain(effectChain); + + mCompositor->DrawGeometry( + graphicsRect, clipRect, effectChain, + GetEffectiveOpacity(), transform, aGeometry); + }); + } + + Rect rect(GetBounds()); + mCompositor->DrawDiagnostics(DiagnosticFlags::COLOR, rect, aClipRect, + transform); +} + +void ColorLayerComposite::GenEffectChain(EffectChain& aEffect) { + aEffect.mLayerRef = this; + aEffect.mPrimaryEffect = new EffectSolidColor(GetColor()); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ColorLayerComposite.h b/gfx/layers/composite/ColorLayerComposite.h new file mode 100644 index 0000000000..b499112486 --- /dev/null +++ b/gfx/layers/composite/ColorLayerComposite.h @@ -0,0 +1,62 @@ +/* -*- 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_ColorLayerComposite_H +#define GFX_ColorLayerComposite_H + +#include "Layers.h" // for ColorLayer, etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/layers/LayerManagerComposite.h" // for LayerComposite, etc +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc + +namespace mozilla { +namespace layers { + +class CompositableHost; + +class ColorLayerComposite : public ColorLayer, public LayerComposite { + public: + explicit ColorLayerComposite(LayerManagerComposite* aManager) + : ColorLayer(aManager, nullptr), LayerComposite(aManager) { + MOZ_COUNT_CTOR(ColorLayerComposite); + mImplData = static_cast<LayerComposite*>(this); + } + + protected: + virtual ~ColorLayerComposite() { + MOZ_COUNT_DTOR(ColorLayerComposite); + Destroy(); + } + + public: + // LayerComposite Implementation + Layer* GetLayer() override { return this; } + + void SetLayerManager(HostLayerManager* aManager) override { + LayerComposite::SetLayerManager(aManager); + mManager = aManager; + } + + void Destroy() override { mDestroyed = true; } + + void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) override; + + void CleanupResources() override{}; + + void GenEffectChain(EffectChain& aEffect) override; + + CompositableHost* GetCompositableHost() override { return nullptr; } + + HostLayer* AsHostLayer() override { return this; } + + const char* Name() const override { return "ColorLayerComposite"; } +}; + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_ColorLayerComposite_H */ diff --git a/gfx/layers/composite/CompositableHost.cpp b/gfx/layers/composite/CompositableHost.cpp new file mode 100644 index 0000000000..056f26de04 --- /dev/null +++ b/gfx/layers/composite/CompositableHost.cpp @@ -0,0 +1,167 @@ +/* -*- 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 "CompositableHost.h" +#include <map> // for _Rb_tree_iterator, map, etc +#include <utility> // for pair +#include "ContentHost.h" // for ContentHostDoubleBuffered, etc +#include "Effects.h" // for EffectMask, Effect, etc +#include "gfxUtils.h" +#include "ImageHost.h" // for ImageHostBuffered, etc +#include "Layers.h" +#include "TiledContentHost.h" // for TiledContentHost +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor +#include "mozilla/layers/TextureHost.h" // for TextureHost, etc +#include "mozilla/layers/WebRenderImageHost.h" +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsDebug.h" // for NS_WARNING +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "gfxPlatform.h" // for gfxPlatform +#include "IPDLActor.h" + +namespace mozilla { + +using namespace gfx; + +namespace layers { + +class Compositor; + +CompositableHost::CompositableHost(const TextureInfo& aTextureInfo) + : mTextureInfo(aTextureInfo), + mCompositorBridgeID(0), + mLayer(nullptr), + mFlashCounter(0), + mAttached(false), + mKeepAttached(false) { + MOZ_COUNT_CTOR(CompositableHost); +} + +CompositableHost::~CompositableHost() { MOZ_COUNT_DTOR(CompositableHost); } + +void CompositableHost::UseTextureHost(const nsTArray<TimedTexture>& aTextures) { + if (mTextureSourceProvider) { + for (auto& texture : aTextures) { + texture.mTexture->SetTextureSourceProvider(mTextureSourceProvider); + } + } +} + +void CompositableHost::UseComponentAlphaTextures(TextureHost* aTextureOnBlack, + TextureHost* aTextureOnWhite) { + MOZ_ASSERT(aTextureOnBlack && aTextureOnWhite); + if (mTextureSourceProvider) { + aTextureOnBlack->SetTextureSourceProvider(mTextureSourceProvider); + aTextureOnWhite->SetTextureSourceProvider(mTextureSourceProvider); + } +} + +void CompositableHost::RemoveTextureHost(TextureHost* aTexture) {} + +void CompositableHost::SetTextureSourceProvider( + TextureSourceProvider* aProvider) { + MOZ_ASSERT(aProvider); + mTextureSourceProvider = aProvider; +} + +bool CompositableHost::AddMaskEffect(EffectChain& aEffects, + const gfx::Matrix4x4& aTransform) { + CompositableTextureSourceRef source; + RefPtr<TextureHost> host = GetAsTextureHost(); + + if (!host) { + NS_WARNING("Using compositable with no valid TextureHost as mask"); + return false; + } + + if (!host->Lock()) { + NS_WARNING("Failed to lock the mask texture"); + return false; + } + + if (!host->BindTextureSource(source)) { + NS_WARNING( + "The TextureHost was successfully locked but can't provide a " + "TextureSource"); + host->Unlock(); + return false; + } + MOZ_ASSERT(source); + + RefPtr<EffectMask> effect = + new EffectMask(source, source->GetSize(), aTransform); + aEffects.mSecondaryEffects[EffectTypes::MASK] = effect; + return true; +} + +void CompositableHost::RemoveMaskEffect() { + RefPtr<TextureHost> host = GetAsTextureHost(); + if (host) { + host->Unlock(); + } +} + +/* static */ +already_AddRefed<CompositableHost> CompositableHost::Create( + const TextureInfo& aTextureInfo, bool aUseWebRender) { + RefPtr<CompositableHost> result; + switch (aTextureInfo.mCompositableType) { + case CompositableType::IMAGE_BRIDGE: + NS_ERROR("Cannot create an image bridge compositable this way"); + break; + case CompositableType::CONTENT_TILED: + result = new TiledContentHost(aTextureInfo); + break; + case CompositableType::IMAGE: + if (aUseWebRender) { + result = new WebRenderImageHost(aTextureInfo); + } else { + result = new ImageHost(aTextureInfo); + } + break; + case CompositableType::CONTENT_SINGLE: + if (aUseWebRender) { + result = new WebRenderImageHost(aTextureInfo); + } else { + result = new ContentHostSingleBuffered(aTextureInfo); + } + break; + case CompositableType::CONTENT_DOUBLE: + MOZ_ASSERT(!aUseWebRender); + result = new ContentHostDoubleBuffered(aTextureInfo); + break; + default: + NS_ERROR("Unknown CompositableType"); + } + return result.forget(); +} + +void CompositableHost::DumpTextureHost(std::stringstream& aStream, + TextureHost* aTexture) { + if (!aTexture) { + return; + } + RefPtr<gfx::DataSourceSurface> dSurf = aTexture->GetAsSurface(); + if (!dSurf) { + return; + } + aStream << gfxUtils::GetAsDataURI(dSurf).get(); +} + +HostLayerManager* CompositableHost::GetLayerManager() const { + if (!mLayer || !mLayer->Manager()) { + return nullptr; + } + return mLayer->Manager()->AsHostLayerManager(); +} + +TextureSourceProvider* CompositableHost::GetTextureSourceProvider() const { + return mTextureSourceProvider; +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/CompositableHost.h b/gfx/layers/composite/CompositableHost.h new file mode 100644 index 0000000000..6f749d76b8 --- /dev/null +++ b/gfx/layers/composite/CompositableHost.h @@ -0,0 +1,278 @@ +/* -*- 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_BUFFERHOST_H +#define MOZILLA_GFX_BUFFERHOST_H + +#include <stdint.h> // for uint64_t +#include <stdio.h> // for FILE +#include "gfxRect.h" // for gfxRect +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr, RefCounted, etc +#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Polygon.h" // for Polygon +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for SamplingFilter +#include "mozilla/ipc/ProtocolUtils.h" +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorTypes.h" // for TextureInfo, etc +#include "mozilla/layers/Effects.h" // for Texture Effect +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "mozilla/layers/LayersMessages.h" +#include "mozilla/layers/TextureHost.h" // for TextureHost +#include "mozilla/mozalloc.h" // for operator delete +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsRegion.h" // for nsIntRegion +#include "nscore.h" // for nsACString +#include "Units.h" // for CSSToScreenScale + +namespace mozilla { +namespace gfx { +class DataSourceSurface; +} // namespace gfx + +namespace layers { + +class Layer; +class LayerComposite; +class ImageHost; +class Compositor; +class ThebesBufferData; +class TiledContentHost; +class CompositableParentManager; +class WebRenderImageHost; +class ContentHost; +class ContentHostTexture; +class HostLayerManager; +struct EffectChain; + +struct ImageCompositeNotificationInfo { + base::ProcessId mImageBridgeProcessId; + ImageCompositeNotification mNotification; +}; + +struct AsyncCompositableRef { + AsyncCompositableRef() : mProcessId(mozilla::ipc::kInvalidProcessId) {} + AsyncCompositableRef(base::ProcessId aProcessId, + const CompositableHandle& aHandle) + : mProcessId(aProcessId), mHandle(aHandle) {} + explicit operator bool() const { return !!mHandle; } + base::ProcessId mProcessId; + CompositableHandle mHandle; +}; + +/** + * The compositor-side counterpart to CompositableClient. Responsible for + * updating textures and data about textures from IPC and how textures are + * composited (tiling, double buffering, etc.). + * + * Update (for images/canvases) and UpdateThebes (for Thebes) are called during + * the layers transaction to update the Compositbale's textures from the + * content side. The actual update (and any syncronous upload) is done by the + * TextureHost, but it is coordinated by the CompositableHost. + * + * Composite is called by the owning layer when it is composited. + * CompositableHost will use its TextureHost(s) and call Compositor::DrawQuad to + * do the actual rendering. + */ +class CompositableHost { + protected: + virtual ~CompositableHost(); + + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CompositableHost) + explicit CompositableHost(const TextureInfo& aTextureInfo); + + static already_AddRefed<CompositableHost> Create( + const TextureInfo& aTextureInfo, bool aUseWebRender); + + virtual CompositableType GetType() = 0; + + // If base class overrides, it should still call the parent implementation + virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider); + + // composite the contents of this buffer host to the compositor's surface + virtual void Composite(Compositor* aCompositor, LayerComposite* aLayer, + EffectChain& aEffectChain, float aOpacity, + const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, + const nsIntRegion* aVisibleRegion = nullptr, + const Maybe<gfx::Polygon>& aGeometry = Nothing()) = 0; + + /** + * Update the content host. + * aUpdated is the region which should be updated. + */ + virtual bool UpdateThebes(const ThebesBufferData& aData, + const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) { + NS_ERROR("should be implemented or not used"); + return false; + } + + /** + * Returns the front buffer. + * *aPictureRect (if non-null, and the returned TextureHost is non-null) + * is set to the picture rect. + */ + virtual TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) { + return nullptr; + } + + virtual gfx::IntSize GetImageSize() { + MOZ_ASSERT(false, "Should have been overridden"); + return gfx::IntSize(); + } + + const TextureInfo& GetTextureInfo() const { return mTextureInfo; } + + /** + * Adds a mask effect using this texture as the mask, if possible. + * @return true if the effect was added, false otherwise. + */ + bool AddMaskEffect(EffectChain& aEffects, const gfx::Matrix4x4& aTransform); + + void RemoveMaskEffect(); + + TextureSourceProvider* GetTextureSourceProvider() const; + + Layer* GetLayer() const { return mLayer; } + void SetLayer(Layer* aLayer) { mLayer = aLayer; } + + virtual ContentHost* AsContentHost() { return nullptr; } + virtual ContentHostTexture* AsContentHostTexture() { return nullptr; } + virtual ImageHost* AsImageHost() { return nullptr; } + virtual TiledContentHost* AsTiledContentHost() { return nullptr; } + virtual WebRenderImageHost* AsWebRenderImageHost() { return nullptr; } + + typedef uint32_t AttachFlags; + static const AttachFlags NO_FLAGS = 0; + static const AttachFlags ALLOW_REATTACH = 1; + static const AttachFlags KEEP_ATTACHED = 2; + static const AttachFlags FORCE_DETACH = 2; + + virtual void Attach(Layer* aLayer, TextureSourceProvider* aProvider, + AttachFlags aFlags = NO_FLAGS) { + MOZ_ASSERT(aProvider); + NS_ASSERTION(aFlags & ALLOW_REATTACH || !mAttached, + "Re-attaching compositables must be explicitly authorised"); + SetTextureSourceProvider(aProvider); + SetLayer(aLayer); + mAttached = true; + mKeepAttached = aFlags & KEEP_ATTACHED; + } + // Detach this compositable host from its layer. + // If we are used for async video, then it is not safe to blindly detach since + // we might be re-attached to a different layer. aLayer is the layer which the + // caller expects us to be attached to, we will only detach if we are in fact + // attached to that layer. If we are part of a normal layer, then we will be + // detached in any case. if aLayer is null, then we will only detach if we are + // not async. + // Only force detach if the IPDL tree is being shutdown. + virtual void Detach(Layer* aLayer = nullptr, AttachFlags aFlags = NO_FLAGS) { + if (!mKeepAttached || aLayer == mLayer || aFlags & FORCE_DETACH) { + SetLayer(nullptr); + mAttached = false; + mKeepAttached = false; + } + } + bool IsAttached() { return mAttached; } + + virtual void Dump(std::stringstream& aStream, const char* aPrefix = "", + bool aDumpHtml = false) {} + static void DumpTextureHost(std::stringstream& aStream, + TextureHost* aTexture); + + virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() { + return nullptr; + } + + virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) = 0; + + struct TimedTexture { + CompositableTextureHostRef mTexture; + TimeStamp mTimeStamp; + gfx::IntRect mPictureRect; + int32_t mFrameID; + int32_t mProducerID; + }; + virtual void UseTextureHost(const nsTArray<TimedTexture>& aTextures); + virtual void UseComponentAlphaTextures(TextureHost* aTextureOnBlack, + TextureHost* aTextureOnWhite); + virtual void RemoveTextureHost(TextureHost* aTexture); + + // Called every time this is composited + void BumpFlashCounter() { + mFlashCounter = mFlashCounter >= DIAGNOSTIC_FLASH_COUNTER_MAX + ? DIAGNOSTIC_FLASH_COUNTER_MAX + : mFlashCounter + 1; + } + + uint64_t GetCompositorBridgeID() const { return mCompositorBridgeID; } + + const AsyncCompositableRef& GetAsyncRef() const { return mAsyncRef; } + void SetAsyncRef(const AsyncCompositableRef& aRef) { mAsyncRef = aRef; } + + void SetCompositorBridgeID(uint64_t aID) { mCompositorBridgeID = aID; } + + virtual bool Lock() { return false; } + + virtual void Unlock() {} + + virtual already_AddRefed<TexturedEffect> GenEffect( + const gfx::SamplingFilter aSamplingFilter) { + return nullptr; + } + + /// Called when shutting down the layer tree. + /// This is a good place to clear all potential gpu resources before the + /// widget is is destroyed. + virtual void CleanupResources() {} + + virtual void BindTextureSource() {} + + virtual uint32_t GetDroppedFrames() { return 0; } + + protected: + HostLayerManager* GetLayerManager() const; + + protected: + TextureInfo mTextureInfo; + AsyncCompositableRef mAsyncRef; + uint64_t mCompositorBridgeID; + RefPtr<TextureSourceProvider> mTextureSourceProvider; + Layer* mLayer; + uint32_t mFlashCounter; // used when the pref "layers.flash-borders" is true. + bool mAttached; + bool mKeepAttached; +}; + +class AutoLockCompositableHost final { + public: + explicit AutoLockCompositableHost(CompositableHost* aHost) : mHost(aHost) { + mSucceeded = (mHost && mHost->Lock()); + } + + ~AutoLockCompositableHost() { + if (mSucceeded && mHost) { + mHost->Unlock(); + } + } + + bool Failed() const { return !mSucceeded; } + + private: + RefPtr<CompositableHost> mHost; + bool mSucceeded; +}; + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/ConsolasFontData.h b/gfx/layers/composite/ConsolasFontData.h new file mode 100644 index 0000000000..a01c417f14 --- /dev/null +++ b/gfx/layers/composite/ConsolasFontData.h @@ -0,0 +1,457 @@ +/* -*- 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/. */ + +// This is explicitly not guarded as we want only 1 file to include this and +// it's good if things break if someone else does. + +namespace mozilla { +namespace layers { +namespace consolas_font { +const unsigned char sFontPNG[] = { + 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0xa, 0x0, 0x0, 0x0, 0xd, + 0x49, 0x48, 0x44, 0x52, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x8, 0x0, 0x0, 0x0, 0x0, 0x79, 0x19, 0xf7, 0xba, 0x0, 0x0, 0x0, + 0x4, 0x67, 0x41, 0x4d, 0x41, 0x0, 0x0, 0xb1, 0x8f, 0xb, 0xfc, 0x61, + 0x5, 0x0, 0x0, 0x0, 0x20, 0x63, 0x48, 0x52, 0x4d, 0x0, 0x0, 0x7a, + 0x26, 0x0, 0x0, 0x80, 0x84, 0x0, 0x0, 0xfa, 0x0, 0x0, 0x0, 0x80, + 0xe8, 0x0, 0x0, 0x75, 0x30, 0x0, 0x0, 0xea, 0x60, 0x0, 0x0, 0x3a, + 0x98, 0x0, 0x0, 0x17, 0x70, 0x9c, 0xba, 0x51, 0x3c, 0x0, 0x0, 0x0, + 0x2, 0x62, 0x4b, 0x47, 0x44, 0x0, 0xff, 0x87, 0x8f, 0xcc, 0xbf, 0x0, + 0x0, 0x0, 0x9, 0x70, 0x48, 0x59, 0x73, 0x0, 0x0, 0x19, 0xd6, 0x0, + 0x0, 0x19, 0xd6, 0x1, 0x18, 0xd1, 0xca, 0xed, 0x0, 0x0, 0x0, 0x7, + 0x74, 0x49, 0x4d, 0x45, 0x7, 0xe1, 0x4, 0x2, 0x12, 0x27, 0x25, 0xc0, + 0x26, 0x1d, 0xf0, 0x0, 0x0, 0x12, 0x53, 0x49, 0x44, 0x41, 0x54, 0x78, + 0xda, 0xed, 0x9d, 0x3d, 0x9a, 0xe4, 0xaa, 0xe, 0x86, 0xb5, 0x41, 0xf6, + 0xc1, 0x22, 0x58, 0x2, 0x2b, 0xf0, 0x6, 0x9c, 0x3b, 0x27, 0x76, 0x4a, + 0xea, 0x90, 0xd0, 0x19, 0x3b, 0xf0, 0x1, 0x5c, 0x75, 0xee, 0x3d, 0xa5, + 0x4f, 0x65, 0xe8, 0xb2, 0x87, 0x9e, 0x6e, 0xeb, 0x99, 0xe9, 0xc0, 0xe5, + 0xc2, 0xf2, 0x5b, 0xfc, 0x4a, 0x42, 0xd0, 0xf6, 0xcb, 0x85, 0x7a, 0x2b, + 0xd0, 0x5b, 0x6e, 0x0, 0x7f, 0xe2, 0x21, 0xd1, 0xc5, 0xab, 0x9f, 0x50, + 0x7d, 0xb1, 0x5, 0x80, 0xb7, 0x13, 0xba, 0x6c, 0xed, 0x36, 0x59, 0xdf, + 0xa2, 0x5e, 0xa0, 0x95, 0x5f, 0x1c, 0xd5, 0x50, 0x9e, 0xc1, 0xef, 0x9e, + 0x86, 0xb9, 0x45, 0x9f, 0x52, 0x16, 0x78, 0x80, 0x41, 0x17, 0x9b, 0x0, + 0x38, 0xb2, 0xf0, 0x2b, 0xb4, 0xd, 0x4, 0x54, 0xf4, 0x76, 0xdd, 0x6, + 0xa0, 0xa2, 0x1f, 0x34, 0x71, 0x60, 0x4e, 0x39, 0x35, 0x6e, 0x51, 0xb9, + 0xd7, 0xf, 0x16, 0x4a, 0x62, 0xd0, 0x83, 0x67, 0xac, 0x4f, 0x56, 0x14, + 0xdd, 0xef, 0x49, 0x5f, 0x6, 0xc0, 0x51, 0x40, 0xb7, 0xa7, 0xcf, 0x6, + 0x76, 0x79, 0xcc, 0x2f, 0xc4, 0x4b, 0x4a, 0xf5, 0x28, 0xff, 0xe3, 0x3a, + 0xea, 0x54, 0x5d, 0xc, 0x2a, 0x3f, 0x55, 0x24, 0xc, 0x20, 0x8, 0x6f, + 0x3a, 0x1, 0x6d, 0x9a, 0x0, 0x78, 0x1, 0x80, 0x81, 0x0, 0xc2, 0x40, + 0x21, 0xd0, 0xf8, 0xfa, 0x41, 0x24, 0x5a, 0xd3, 0x9b, 0xb2, 0xf6, 0x38, + 0xea, 0xa8, 0x87, 0x19, 0x94, 0x93, 0xf8, 0x26, 0x0, 0xa8, 0xf6, 0x6, + 0xc2, 0x4d, 0xc0, 0x42, 0x5c, 0x85, 0xa5, 0xf0, 0x41, 0x25, 0x0, 0x81, + 0xb8, 0xf7, 0x5b, 0xe0, 0xbd, 0x5a, 0xa0, 0x87, 0xf0, 0xeb, 0xab, 0x6, + 0x8a, 0xaf, 0x8a, 0xd4, 0xa2, 0xc0, 0x7, 0x3, 0x4d, 0x13, 0x7e, 0x70, + 0x74, 0xf0, 0x7d, 0x56, 0xdc, 0x60, 0xb6, 0xdc, 0x66, 0xc6, 0x2b, 0x0, + 0x48, 0x77, 0x1b, 0x13, 0x66, 0x9a, 0x99, 0x8e, 0x3a, 0x41, 0x81, 0x7a, + 0x4, 0xd4, 0x0, 0xd2, 0x6b, 0x2a, 0xaa, 0xd0, 0xfb, 0xff, 0xc4, 0x91, + 0x13, 0x3e, 0x89, 0xa4, 0x3e, 0x4, 0xd0, 0xa4, 0x48, 0xc2, 0xe5, 0x41, + 0x9d, 0x8b, 0x36, 0x11, 0x50, 0x68, 0xd4, 0x98, 0x61, 0xd, 0x4d, 0x7d, + 0x86, 0x5a, 0x57, 0xb1, 0xc3, 0xe7, 0x62, 0xe5, 0x8a, 0x4e, 0xc7, 0xa3, + 0xfc, 0x7b, 0x0, 0xee, 0xf0, 0xfb, 0xff, 0xca, 0x1a, 0x68, 0x8, 0x23, + 0xcd, 0x60, 0xf0, 0x4d, 0xdd, 0x31, 0x21, 0x32, 0x6a, 0x72, 0x4a, 0x2f, + 0xec, 0x66, 0x9b, 0x3a, 0xf5, 0x85, 0x4e, 0x1, 0x60, 0x3f, 0x3, 0xb0, + 0xb6, 0x8c, 0xf6, 0xf6, 0xd1, 0x5, 0x0, 0x66, 0x69, 0x78, 0x30, 0xe0, + 0xfa, 0xa0, 0x13, 0x61, 0xab, 0x58, 0x39, 0x4b, 0x19, 0x38, 0xea, 0x1f, + 0xfd, 0x6, 0x80, 0xfa, 0xc, 0xc0, 0xe6, 0x1b, 0x26, 0x70, 0xeb, 0x4c, + 0x53, 0x48, 0xc3, 0x17, 0xfb, 0x4a, 0xdc, 0x46, 0x93, 0x0, 0xb0, 0x89, + 0xc3, 0x42, 0x8b, 0xa3, 0x32, 0x76, 0xbe, 0xbc, 0x8e, 0xcf, 0xa3, 0xc0, + 0x71, 0xe3, 0xfd, 0x57, 0xe4, 0x3e, 0x60, 0xfb, 0xb0, 0xf, 0x98, 0xab, + 0x66, 0x12, 0x4f, 0x9, 0xe9, 0x87, 0xb0, 0x60, 0x5e, 0x47, 0x5a, 0x29, + 0x5, 0x3a, 0xea, 0x34, 0x11, 0xf4, 0xb4, 0x8c, 0xaf, 0x2a, 0xce, 0x94, + 0x5a, 0x86, 0x6e, 0xa9, 0x1, 0x8b, 0x38, 0xa, 0xf8, 0xf, 0x47, 0x81, + 0x59, 0x2c, 0x19, 0x49, 0x9e, 0x1b, 0x28, 0xe, 0x60, 0xcd, 0x6d, 0x3, + 0x8c, 0x83, 0x43, 0x7e, 0x73, 0x3, 0x5e, 0x74, 0xca, 0xf7, 0x27, 0xc, + 0x35, 0xf3, 0xd8, 0x5d, 0xf4, 0x55, 0xf3, 0x80, 0xad, 0x5e, 0x87, 0xf7, + 0xcf, 0x98, 0xc5, 0x8f, 0xe0, 0x13, 0x42, 0xe3, 0x73, 0x17, 0xa1, 0xa6, + 0xce, 0x35, 0xc3, 0xf8, 0x1f, 0x58, 0xd, 0x86, 0x8a, 0xdf, 0xe1, 0x33, + 0x19, 0xe1, 0x9c, 0x37, 0x54, 0x75, 0x24, 0x3f, 0xc3, 0x1e, 0x0, 0xd7, + 0xe, 0xf6, 0xe3, 0xd5, 0xe0, 0x5f, 0x24, 0x78, 0x8e, 0x5c, 0xf3, 0xcd, + 0x1f, 0x2, 0xe0, 0xeb, 0x72, 0x3, 0xe8, 0xad, 0x40, 0x6f, 0xb9, 0x1, + 0xf4, 0x56, 0xa0, 0xb7, 0xdc, 0x0, 0x7a, 0x2b, 0xd0, 0x5b, 0x6e, 0x0, + 0x5b, 0xe3, 0xba, 0xff, 0x5c, 0x99, 0xec, 0xd5, 0x2e, 0x93, 0x63, 0x0, + 0x31, 0x6c, 0x69, 0x41, 0xdd, 0x7, 0x41, 0x44, 0xcb, 0x98, 0x25, 0x2d, + 0x86, 0x7, 0xc4, 0xc5, 0x61, 0xfb, 0xc6, 0xa8, 0x48, 0x81, 0x65, 0xaf, + 0x4f, 0xc5, 0xa8, 0x63, 0xbb, 0x52, 0x76, 0x72, 0x4c, 0x34, 0xa9, 0x6, + 0x3, 0xc4, 0x89, 0x32, 0x81, 0x65, 0x7f, 0x5a, 0x9, 0x5b, 0xd, 0xc0, + 0xe4, 0x17, 0x42, 0x0, 0x2c, 0x69, 0x8b, 0xcc, 0xa8, 0x4e, 0x5b, 0xab, + 0x8e, 0xd, 0x2, 0xb4, 0x97, 0x3c, 0x22, 0xe2, 0x82, 0x19, 0xfa, 0x44, + 0x41, 0xdc, 0x55, 0xf6, 0x9, 0x58, 0xbe, 0x84, 0x36, 0xca, 0x41, 0x0, + 0xeb, 0x9c, 0xa1, 0xe1, 0xbe, 0x6c, 0x39, 0x5e, 0x10, 0xd2, 0x16, 0x8a, + 0xc5, 0x2, 0x35, 0x81, 0x26, 0xa3, 0xe8, 0x57, 0xc4, 0x3, 0xd3, 0xe7, + 0x52, 0x16, 0xf1, 0x86, 0x2f, 0xe5, 0x43, 0x94, 0x8d, 0xbc, 0x41, 0x4, + 0x70, 0x68, 0x11, 0xa0, 0xd4, 0xb2, 0x2, 0x79, 0x68, 0xa1, 0xbf, 0x1c, + 0x80, 0x26, 0x5e, 0xf1, 0xb2, 0x85, 0x2f, 0x28, 0x82, 0x36, 0xe, 0x11, + 0x80, 0x47, 0xb6, 0xab, 0xe0, 0x9c, 0x52, 0x87, 0x75, 0xb8, 0x14, 0x99, + 0x9e, 0xc9, 0x35, 0x9, 0x61, 0xa6, 0x31, 0x34, 0x58, 0x67, 0x5c, 0x96, + 0x96, 0x4e, 0x3d, 0x20, 0x3b, 0x46, 0x2, 0x30, 0x91, 0x50, 0xdb, 0x25, + 0x0, 0x51, 0xd1, 0x82, 0x4a, 0x22, 0x32, 0x55, 0x0, 0x60, 0x5b, 0x7f, + 0xba, 0xba, 0xea, 0x9d, 0x43, 0xe5, 0xf6, 0x96, 0x5e, 0x63, 0xc0, 0x2e, + 0xd6, 0xfc, 0xcc, 0xd0, 0x54, 0x3, 0xc, 0xec, 0xeb, 0x62, 0x8, 0xa9, + 0xb0, 0xa3, 0x5f, 0x44, 0x9e, 0x8, 0x5d, 0x5e, 0x3, 0xe0, 0x18, 0x98, + 0xfb, 0xb3, 0x59, 0x6a, 0xbc, 0x2, 0x0, 0x23, 0xf7, 0xf5, 0xf6, 0xb0, + 0x15, 0x7f, 0xc5, 0x33, 0x34, 0xb5, 0xb9, 0xcc, 0xd2, 0xfd, 0x6, 0x5f, + 0x46, 0x3d, 0xef, 0xee, 0xcf, 0xb3, 0xd0, 0x90, 0x8a, 0x1, 0x98, 0x37, + 0x5e, 0x24, 0x7d, 0x68, 0x5e, 0xff, 0xa, 0x80, 0x34, 0x6c, 0x34, 0xd9, + 0x6d, 0x85, 0x96, 0x21, 0xcc, 0x3d, 0x6, 0xd2, 0x6e, 0x0, 0xc8, 0x26, + 0x9b, 0x9e, 0x6b, 0xf9, 0xa4, 0xd5, 0x8, 0x1e, 0xa9, 0xc9, 0xb9, 0x49, + 0xd7, 0xc, 0x83, 0xb2, 0x48, 0xf3, 0x80, 0xb5, 0xad, 0xa9, 0xa7, 0x9f, + 0x1a, 0xd5, 0x75, 0x2f, 0xfd, 0x70, 0xd9, 0x31, 0x6, 0x66, 0xc8, 0x56, + 0x78, 0x51, 0xc9, 0x25, 0x57, 0xee, 0x1f, 0xf, 0x9b, 0xe4, 0x97, 0x16, + 0x43, 0x2d, 0x8e, 0xab, 0x42, 0xc, 0x5d, 0xd4, 0x72, 0xff, 0x74, 0xce, + 0xfc, 0x2b, 0x86, 0x9a, 0xe, 0xa9, 0x1d, 0x40, 0x74, 0xb6, 0xc1, 0x6f, + 0x25, 0x17, 0xd3, 0xe0, 0x0, 0xbf, 0x52, 0xda, 0x1, 0x4, 0x3d, 0x5c, + 0x3d, 0x43, 0xfe, 0xde, 0x0, 0x7e, 0x98, 0xdc, 0x0, 0x7a, 0x2b, 0xd0, + 0x5b, 0x6e, 0x0, 0xbd, 0x15, 0xe8, 0x2d, 0x37, 0x80, 0xde, 0xa, 0xf4, + 0x96, 0x1b, 0x40, 0x6f, 0x5, 0x7a, 0xcb, 0xd, 0x20, 0xff, 0x49, 0x2b, + 0x4d, 0xbe, 0x5e, 0xf1, 0x36, 0xb, 0x9a, 0xb0, 0x87, 0x11, 0x5c, 0x5f, + 0xed, 0x2e, 0x7c, 0x99, 0xe0, 0x54, 0x5a, 0xdd, 0x81, 0xf5, 0xd0, 0x84, + 0xed, 0xf9, 0x1d, 0x0, 0x4, 0xb8, 0x60, 0x77, 0x92, 0x45, 0x6c, 0x84, + 0xd7, 0x83, 0xb4, 0x2c, 0x4d, 0x8b, 0x61, 0x37, 0x82, 0xf5, 0x63, 0xb6, + 0xe7, 0xab, 0xa6, 0x70, 0xec, 0xcb, 0x0, 0x68, 0x1a, 0x20, 0x0, 0x6c, + 0xe, 0xf1, 0x6f, 0x2c, 0x8d, 0x11, 0xd8, 0xe0, 0x8a, 0x3b, 0x87, 0x87, + 0xb3, 0xae, 0x99, 0x49, 0xc4, 0xa6, 0x15, 0xc9, 0x1f, 0x21, 0xfa, 0x29, + 0xe6, 0x86, 0xa8, 0x42, 0xe, 0x20, 0xbd, 0xa9, 0x6b, 0x0, 0x60, 0x90, + 0x5, 0xf6, 0x21, 0x23, 0x30, 0x96, 0x95, 0x28, 0x59, 0xc5, 0xc0, 0xec, + 0xdb, 0x51, 0xe0, 0xca, 0x7a, 0x10, 0x4c, 0x99, 0xd2, 0xf5, 0xf4, 0xd8, + 0x63, 0xf3, 0xb7, 0xc, 0x20, 0x2a, 0xbd, 0x61, 0x0, 0xda, 0x8e, 0x40, + 0x3d, 0xa2, 0xd9, 0x5a, 0x6c, 0x69, 0x41, 0x15, 0x20, 0xef, 0x1, 0xb2, + 0xc0, 0x34, 0xb7, 0x47, 0x37, 0xa2, 0x20, 0xea, 0xfc, 0xa2, 0x50, 0x57, + 0xe9, 0xba, 0x25, 0x3, 0x2a, 0xc0, 0xa3, 0x49, 0x1e, 0x91, 0xa1, 0x52, + 0x3b, 0x9d, 0xd8, 0x7, 0xb0, 0x5f, 0xf4, 0xd1, 0xd6, 0x15, 0x22, 0x30, + 0xc2, 0x26, 0x9d, 0xb, 0xd2, 0xfc, 0xf6, 0xd4, 0x5, 0xa6, 0x3e, 0x0, + 0x56, 0xb3, 0x59, 0xd0, 0x1a, 0x5e, 0x5f, 0xd, 0xee, 0x48, 0x1e, 0x9d, + 0xf2, 0x51, 0xdb, 0xa0, 0x25, 0xbf, 0xa3, 0x13, 0x40, 0x79, 0xde, 0x46, + 0x3, 0xed, 0xbe, 0x3b, 0x34, 0x3c, 0x28, 0x54, 0x8c, 0x27, 0x3d, 0x23, + 0xe3, 0x64, 0x1c, 0xb5, 0x1a, 0x8e, 0xad, 0xb6, 0x87, 0xa2, 0x9b, 0x42, + 0xba, 0x39, 0x80, 0x67, 0x9c, 0xbf, 0x64, 0x72, 0x7, 0x9b, 0xa0, 0x36, + 0x61, 0x43, 0x19, 0xde, 0x65, 0x56, 0x9a, 0xbf, 0x11, 0xe2, 0x85, 0x75, + 0x9b, 0x7d, 0x19, 0x49, 0x34, 0xd8, 0xea, 0x5e, 0x5b, 0x3, 0xa6, 0x7c, + 0x97, 0x22, 0x83, 0xc7, 0x23, 0xc5, 0x15, 0x2c, 0x6e, 0xa8, 0x11, 0xd5, + 0x0, 0x58, 0x1, 0x76, 0xbf, 0xe5, 0x84, 0x7b, 0x54, 0xbc, 0x3b, 0x2a, + 0x58, 0xdc, 0xfd, 0x3a, 0x21, 0x7a, 0x7d, 0x80, 0xa1, 0xe5, 0xd5, 0x7d, + 0x40, 0xa1, 0x5, 0xee, 0x9b, 0x26, 0x37, 0x2a, 0xe0, 0xbd, 0x73, 0xa4, + 0xa6, 0x91, 0xa0, 0x5b, 0x13, 0x42, 0x4c, 0x65, 0xb8, 0x89, 0x8f, 0x2, + 0x79, 0xf6, 0xa5, 0x70, 0x50, 0xbc, 0xe4, 0x77, 0x18, 0xa4, 0xd7, 0x99, + 0xf0, 0x9e, 0xa4, 0x2a, 0x91, 0x1, 0x94, 0xbd, 0x4e, 0xe8, 0xa7, 0x28, + 0x1, 0xfd, 0x40, 0x13, 0x85, 0xd5, 0x5b, 0xb3, 0xe7, 0x42, 0xf3, 0xa1, + 0x33, 0x95, 0x6f, 0x26, 0x38, 0x98, 0x8, 0x9e, 0xa4, 0xbc, 0xd3, 0x4e, + 0xf8, 0x3d, 0xfd, 0x47, 0xf3, 0x0, 0x51, 0x44, 0xbb, 0x7a, 0x95, 0xc1, + 0xfd, 0x83, 0xfb, 0xa5, 0xb7, 0x31, 0x87, 0xae, 0xce, 0x73, 0x1, 0x7c, + 0x2f, 0x89, 0x6e, 0x68, 0xd8, 0x4a, 0xf6, 0x3, 0x1, 0x4, 0x35, 0x2c, + 0x9f, 0x97, 0xf2, 0x17, 0x3, 0xb8, 0x48, 0x6e, 0x0, 0xbd, 0x15, 0xe8, + 0x2d, 0x37, 0x80, 0xde, 0xa, 0xf4, 0x96, 0x1b, 0x40, 0x6f, 0x5, 0x7a, + 0xcb, 0xd, 0xa0, 0xb7, 0x2, 0xbd, 0xe5, 0xd, 0x80, 0xc9, 0x4e, 0x78, + 0xea, 0xe5, 0xd, 0xfd, 0x9c, 0x20, 0x91, 0x37, 0x0, 0xac, 0x10, 0x27, + 0x3a, 0x92, 0x75, 0xd0, 0x90, 0x31, 0x40, 0xf3, 0x43, 0x31, 0x4b, 0x40, + 0x1b, 0xe2, 0xa8, 0x89, 0x5b, 0xf3, 0x8a, 0x7f, 0x61, 0x0, 0xab, 0xdb, + 0xdd, 0x4f, 0x61, 0xab, 0xaf, 0x6f, 0x6b, 0x5a, 0xcd, 0x93, 0x39, 0x9a, + 0x3e, 0xbf, 0x1, 0xb0, 0x6, 0x8f, 0xe2, 0xed, 0x8b, 0xd, 0x6d, 0x53, + 0xdc, 0x50, 0x10, 0x71, 0xfe, 0x88, 0x1c, 0xdc, 0xa7, 0x50, 0x5c, 0x59, + 0x5a, 0x26, 0x5b, 0x6e, 0x71, 0xa, 0xbb, 0xa9, 0x10, 0xd9, 0x21, 0xb0, + 0xe1, 0x4a, 0xba, 0xbe, 0xaa, 0x52, 0x7e, 0x45, 0xa4, 0xa8, 0x91, 0x9d, + 0x13, 0xb, 0x28, 0x58, 0x17, 0x13, 0xdc, 0xc8, 0x3f, 0x98, 0x9, 0x1a, + 0xa7, 0x4a, 0x11, 0x60, 0x25, 0x3f, 0x92, 0x41, 0xd5, 0xa2, 0xa4, 0xae, + 0x9, 0x8a, 0xdb, 0xa, 0x25, 0x33, 0xbd, 0x74, 0x5d, 0xef, 0x3f, 0xde, + 0xa1, 0x49, 0x2c, 0xff, 0x12, 0x46, 0x5a, 0x66, 0x3, 0x0, 0x2b, 0xcd, + 0x8b, 0xb5, 0x66, 0xe2, 0x6f, 0x64, 0x9, 0x86, 0xed, 0xd3, 0xee, 0x7b, + 0x59, 0xf9, 0x75, 0x58, 0x3b, 0xf7, 0xdc, 0x3d, 0x20, 0x9, 0x54, 0x23, + 0x80, 0x8a, 0xbd, 0x12, 0x4f, 0x0, 0xd9, 0xaf, 0x0, 0x39, 0x39, 0xa7, + 0x79, 0x13, 0x70, 0x94, 0x93, 0x62, 0xd0, 0xc2, 0x1, 0xa4, 0x27, 0x22, + 0x3f, 0x7, 0x51, 0x58, 0x6, 0x68, 0x5e, 0x87, 0xa, 0xed, 0x0, 0x40, + 0x4e, 0x4, 0x97, 0xba, 0x1e, 0xe7, 0x80, 0xeb, 0x31, 0x87, 0x74, 0xf3, + 0x98, 0x6e, 0x97, 0x11, 0xa6, 0xf, 0xaa, 0xa2, 0xc5, 0x67, 0x9c, 0xb2, + 0x23, 0xb5, 0x2c, 0x6e, 0x81, 0xb0, 0x6a, 0xa6, 0xc5, 0x2a, 0x9e, 0x15, + 0x21, 0xf7, 0xd, 0x33, 0x68, 0xbb, 0x82, 0xcb, 0xf0, 0x3d, 0x0, 0xf0, + 0xa9, 0xe4, 0xab, 0x14, 0xae, 0x97, 0x8d, 0x17, 0xb8, 0x57, 0xe2, 0x0, + 0xb2, 0xbf, 0x13, 0xd4, 0x1, 0x8d, 0x54, 0x34, 0x76, 0xa2, 0x4d, 0x5b, + 0x9e, 0x32, 0x69, 0x4c, 0x10, 0x57, 0x50, 0xef, 0x52, 0xd, 0xc8, 0xbd, + 0xe9, 0xab, 0x59, 0xfc, 0xa8, 0x6, 0xb0, 0xde, 0x44, 0xf8, 0xa5, 0xa5, + 0x9a, 0xe1, 0xd2, 0x8f, 0x97, 0x83, 0x5a, 0xab, 0x0, 0x38, 0x6c, 0x55, + 0x9d, 0x60, 0xcc, 0xbe, 0xb5, 0xb4, 0xe5, 0x64, 0x47, 0xaf, 0x75, 0x2b, + 0x9b, 0xd6, 0x2d, 0x68, 0xd8, 0x82, 0x1f, 0x41, 0xf0, 0x8b, 0x9e, 0xd6, + 0x7, 0xec, 0x19, 0x60, 0x5c, 0x15, 0x0, 0xa9, 0xf, 0x58, 0x60, 0xbb, + 0xb0, 0x3, 0xad, 0xe9, 0xcf, 0xeb, 0x4f, 0x9d, 0x7e, 0xfc, 0x34, 0x1a, + 0x6b, 0xde, 0x68, 0x68, 0xf7, 0xe, 0xb3, 0x4e, 0x40, 0x63, 0x2b, 0xfa, + 0x73, 0x14, 0x60, 0x5d, 0x4c, 0x23, 0x80, 0x58, 0x9a, 0x75, 0xd, 0x0, + 0xc9, 0xb3, 0x92, 0xa3, 0xe2, 0x1, 0x1, 0x63, 0x53, 0x8f, 0x1, 0x7c, + 0x7a, 0xbb, 0xeb, 0x3, 0x24, 0x31, 0xcc, 0xf3, 0x0, 0x94, 0x4a, 0x2b, + 0x8d, 0x30, 0x9, 0x19, 0x9c, 0x7, 0x18, 0xb8, 0xf, 0x90, 0x34, 0x9c, + 0xf0, 0x38, 0x71, 0x5b, 0x47, 0xaa, 0x92, 0xba, 0x6a, 0x1e, 0x20, 0x84, + 0x69, 0x44, 0x85, 0x53, 0x93, 0x6c, 0xf3, 0xbc, 0x3a, 0xbe, 0xad, 0x6f, + 0xaf, 0xd1, 0xbc, 0x62, 0x17, 0x57, 0x2a, 0x9a, 0x3a, 0x87, 0xe2, 0x30, + 0x0, 0xbe, 0x47, 0x22, 0xb4, 0x97, 0x57, 0x9e, 0x8, 0x9, 0xef, 0x98, + 0x23, 0x53, 0x48, 0x7d, 0x30, 0x13, 0xc4, 0x59, 0x49, 0x67, 0x3a, 0xd1, + 0x36, 0x7b, 0xf1, 0x8a, 0x62, 0xad, 0x70, 0x48, 0x34, 0xaf, 0x6, 0x63, + 0xd9, 0x8b, 0xe7, 0x4f, 0xca, 0xb1, 0xd4, 0x5f, 0xda, 0x97, 0xc3, 0xbe, + 0xd4, 0xc4, 0x5f, 0xc, 0x60, 0x8b, 0xb3, 0x6b, 0x49, 0x33, 0xf7, 0xcd, + 0xe5, 0x36, 0x88, 0xf4, 0x56, 0xa0, 0xb7, 0xdc, 0x0, 0x7a, 0x2b, 0xd0, + 0x5b, 0x6e, 0x0, 0xbd, 0x15, 0xe8, 0x2d, 0x37, 0x80, 0xde, 0xa, 0xf4, + 0x96, 0x1b, 0xc0, 0x9e, 0xc4, 0xda, 0xf3, 0xf5, 0xd7, 0xf4, 0xd6, 0xe, + 0xcf, 0x97, 0x6b, 0xc5, 0x29, 0x30, 0xf0, 0xf, 0xa4, 0x2c, 0xd9, 0xd6, + 0x86, 0xfc, 0xc7, 0xb3, 0xdb, 0xf3, 0x25, 0xf4, 0xa5, 0x39, 0xe7, 0x17, + 0x5a, 0x41, 0x39, 0x49, 0x60, 0xc0, 0x2d, 0xbe, 0xff, 0x15, 0xc0, 0x6e, + 0x81, 0x1, 0x6b, 0xca, 0x29, 0x2d, 0xcb, 0x95, 0x0, 0x0, 0x2d, 0xb3, + 0xa9, 0xc4, 0x1c, 0xf3, 0xb0, 0xd5, 0x20, 0x19, 0x3e, 0xd2, 0x9a, 0xdf, + 0x73, 0xbb, 0x42, 0x28, 0xf9, 0x53, 0xc0, 0x97, 0xd2, 0xfa, 0x3e, 0xfb, + 0x17, 0xd8, 0x24, 0x3c, 0x2d, 0xfb, 0xd, 0xca, 0xb9, 0x92, 0x96, 0xcf, + 0x46, 0xe1, 0x98, 0xe6, 0x3a, 0x0, 0xef, 0xb2, 0xcb, 0x3b, 0xc, 0x60, + 0x45, 0x8b, 0x24, 0x11, 0x80, 0x56, 0xd9, 0x37, 0x4, 0x0, 0x90, 0x7, + 0x5f, 0xda, 0x4d, 0x68, 0x6, 0x59, 0x9c, 0xc2, 0x16, 0x35, 0xb3, 0x39, + 0x3e, 0xef, 0x3f, 0xda, 0x93, 0x72, 0x2a, 0x0, 0xd3, 0x50, 0x4a, 0xa0, + 0x91, 0x82, 0x9a, 0x0, 0x80, 0x9c, 0x86, 0x9a, 0x7f, 0x69, 0x37, 0x38, + 0x43, 0x8b, 0x53, 0x40, 0x36, 0x47, 0xf1, 0x7e, 0xe, 0x40, 0x3b, 0x87, + 0xad, 0xa7, 0xad, 0x0, 0x2c, 0x8e, 0xfc, 0x95, 0x0, 0x2c, 0xe9, 0xb, + 0x2b, 0xfb, 0x30, 0x64, 0xab, 0x6b, 0xe0, 0x5f, 0x1a, 0xcb, 0x23, 0x81, + 0x2d, 0xb9, 0x0, 0xe0, 0xb1, 0xcb, 0xe2, 0xfd, 0x1c, 0x80, 0x98, 0x15, + 0xbe, 0x15, 0x0, 0xf6, 0xf5, 0x88, 0x0, 0x52, 0x85, 0xd1, 0x1b, 0x2, + 0xe0, 0xc9, 0xf2, 0x2f, 0x59, 0x19, 0xc0, 0x9c, 0xd3, 0xe5, 0x84, 0xda, + 0xfb, 0x39, 0x0, 0x13, 0x42, 0x18, 0xcf, 0x0, 0x30, 0x40, 0x6f, 0x94, + 0x50, 0x8a, 0xa3, 0x9c, 0xa6, 0x7, 0x2, 0xc8, 0xb9, 0x5f, 0xd8, 0xf5, + 0x41, 0x6, 0x40, 0x28, 0x1b, 0x7f, 0x3, 0x80, 0xf3, 0xfa, 0x0, 0x8b, + 0x52, 0x43, 0xc9, 0x0, 0xd6, 0x34, 0x10, 0x42, 0x0, 0x33, 0x71, 0x9b, + 0x79, 0x71, 0x75, 0x21, 0x97, 0x59, 0x1a, 0x4d, 0x90, 0x81, 0xe6, 0x79, + 0xff, 0x51, 0x7e, 0xf8, 0xaf, 0x1, 0x40, 0x69, 0x7e, 0xf6, 0x51, 0x60, + 0xa9, 0x2d, 0xe5, 0xb1, 0x49, 0x5, 0x2, 0xd8, 0x14, 0xf7, 0x75, 0x2d, + 0x65, 0x44, 0xb3, 0x78, 0x14, 0x0, 0xf2, 0xbc, 0xff, 0xd0, 0x2c, 0xde, + 0x3c, 0xf, 0x70, 0x26, 0x75, 0x99, 0x20, 0x6c, 0x7b, 0x9f, 0x7, 0xf0, + 0x46, 0x10, 0x8a, 0xc7, 0x84, 0x85, 0x4e, 0x3c, 0x0, 0x30, 0xf7, 0x5b, + 0xd1, 0xc7, 0xa1, 0x83, 0x89, 0x8a, 0xc3, 0x0, 0xba, 0xde, 0xe0, 0x9b, + 0x19, 0xe1, 0xfe, 0x6a, 0x0, 0x56, 0xb0, 0xc3, 0x7b, 0x1c, 0xfe, 0xbf, + 0x2b, 0xa2, 0x79, 0x23, 0x8, 0x78, 0xe7, 0xc6, 0xc3, 0xb7, 0x66, 0x21, + 0x80, 0x88, 0xbc, 0xa0, 0x25, 0x62, 0x85, 0xcf, 0x33, 0xc4, 0x4d, 0x21, + 0xc2, 0xfd, 0xaf, 0x5f, 0x3f, 0xba, 0x1, 0x48, 0x6b, 0xf8, 0xff, 0x69, + 0xd2, 0xf8, 0xe0, 0xf0, 0xe9, 0x49, 0x53, 0x7f, 0xbb, 0xa4, 0x7a, 0x34, + 0x8c, 0x87, 0x13, 0xa1, 0xde, 0x5a, 0x5e, 0x29, 0x5e, 0xc1, 0xa4, 0x5c, + 0xbf, 0x7, 0x40, 0xcd, 0x91, 0x83, 0x3f, 0x1c, 0xc0, 0xb1, 0xdc, 0x0, + 0x7a, 0x2b, 0xd0, 0x5b, 0x6e, 0x0, 0xbd, 0x15, 0xe8, 0x2d, 0x37, 0x80, + 0xde, 0xa, 0xf4, 0x96, 0x1b, 0x40, 0x6f, 0x5, 0xae, 0x13, 0x27, 0x66, + 0x45, 0xf8, 0x2f, 0x0, 0xd1, 0xae, 0xee, 0x60, 0x82, 0xfe, 0x67, 0xbe, + 0xa0, 0x89, 0x5d, 0xdf, 0xfd, 0xb, 0xcc, 0x36, 0x67, 0xcb, 0xca, 0xd1, + 0xbe, 0x4e, 0x49, 0x1f, 0x51, 0x98, 0x2c, 0x18, 0x73, 0xb1, 0x79, 0x5, + 0xe3, 0x98, 0x46, 0xce, 0x66, 0x13, 0x44, 0xe4, 0xeb, 0x73, 0x39, 0x7f, + 0x51, 0xe, 0x21, 0xad, 0x0, 0x50, 0x72, 0x9c, 0x80, 0xd5, 0xe7, 0x54, + 0x2, 0xfc, 0xd8, 0xf5, 0x35, 0x7b, 0x5, 0x14, 0x7, 0xf0, 0x5c, 0x56, + 0x73, 0x63, 0x66, 0x7e, 0x21, 0x1e, 0x43, 0x3b, 0x8, 0xcb, 0xe1, 0x2d, + 0x47, 0xca, 0x47, 0x42, 0xf1, 0x83, 0x1b, 0x4c, 0x53, 0x23, 0xda, 0x34, + 0x8f, 0x83, 0x24, 0x9f, 0x0, 0x4a, 0x4c, 0x24, 0x70, 0x38, 0x48, 0xf1, + 0x70, 0x30, 0x53, 0x82, 0x4, 0x60, 0xf, 0x5b, 0x77, 0x4c, 0xf1, 0x87, + 0x41, 0x84, 0x3, 0xc8, 0xc7, 0x3c, 0xa2, 0x74, 0x3c, 0xd9, 0xb8, 0x23, + 0x1d, 0x23, 0x8b, 0x1c, 0x32, 0x4d, 0x0, 0x40, 0x7c, 0xe3, 0x46, 0xe2, + 0x31, 0x81, 0x4d, 0x0, 0xf6, 0xbd, 0x12, 0x3c, 0xf9, 0x50, 0x6, 0xe0, + 0xc2, 0x66, 0xf9, 0x1b, 0x69, 0x82, 0x39, 0xd1, 0x73, 0x15, 0x18, 0xf1, + 0x3b, 0xe1, 0x4c, 0xcf, 0xd, 0x0, 0xe2, 0x8, 0x8, 0xe6, 0xc, 0xf, + 0x18, 0x41, 0x1b, 0x80, 0xb2, 0xeb, 0x1f, 0x45, 0xbf, 0x87, 0x6c, 0xb0, + 0x0, 0x36, 0xb7, 0x45, 0x8, 0x72, 0xb7, 0x34, 0xb, 0x15, 0x0, 0x67, + 0x17, 0xaf, 0x7, 0x20, 0xa4, 0xa0, 0x16, 0xcf, 0xb, 0x6e, 0x3, 0x90, + 0xf, 0x3f, 0xf0, 0x28, 0xf8, 0x3b, 0xa4, 0x5e, 0x6, 0x1, 0xc8, 0x26, + 0x51, 0x7c, 0xf2, 0xb6, 0x10, 0xfd, 0xef, 0xb0, 0xfb, 0xa7, 0x1e, 0x80, + 0x13, 0x3c, 0x68, 0x71, 0xc2, 0xaa, 0xb4, 0x1, 0x48, 0xf, 0x88, 0x23, + 0xb7, 0xdb, 0x7b, 0xa, 0xda, 0x10, 0x4a, 0xa3, 0xef, 0xa5, 0xa3, 0xaa, + 0x2d, 0xae, 0x0, 0x52, 0xaa, 0xf3, 0x96, 0x3e, 0x40, 0xc9, 0xc7, 0x96, + 0xc2, 0x73, 0x84, 0xdf, 0x0, 0xe0, 0xf7, 0x5b, 0xf2, 0x20, 0x8f, 0x78, + 0x48, 0x15, 0xda, 0x13, 0xca, 0x3d, 0xa5, 0xc8, 0xe1, 0x57, 0x12, 0xd2, + 0xd4, 0x48, 0xe9, 0xf5, 0x5b, 0x0, 0x4c, 0x92, 0x7, 0x0, 0x66, 0x7a, + 0x82, 0x8a, 0xac, 0x8f, 0x61, 0x8a, 0x77, 0x1b, 0x78, 0x37, 0x59, 0xf1, + 0xe, 0xf, 0x60, 0x7f, 0x81, 0x2b, 0xa3, 0x0, 0xf2, 0x67, 0x60, 0x0, + 0x52, 0x76, 0xa1, 0x26, 0x0, 0x70, 0xdc, 0x35, 0x65, 0xc4, 0xaf, 0x56, + 0x44, 0x93, 0x81, 0x79, 0x3, 0xcb, 0x7e, 0x42, 0x8e, 0x45, 0x8a, 0xf, + 0x28, 0xaa, 0x44, 0xaa, 0x6, 0x9f, 0x6e, 0xd5, 0xd2, 0x44, 0xa8, 0x61, + 0x18, 0xe4, 0x55, 0x31, 0xef, 0x3b, 0x14, 0xec, 0xea, 0x18, 0xc0, 0x7e, + 0xc0, 0x30, 0xba, 0x5f, 0xe3, 0xb0, 0x81, 0x34, 0x32, 0x46, 0xe, 0x60, + 0xd7, 0x4, 0x92, 0x14, 0x9a, 0xde, 0xa7, 0x13, 0x21, 0x59, 0x42, 0x6b, + 0x38, 0x7f, 0x37, 0x87, 0x1, 0x94, 0xcf, 0x1, 0xfc, 0xe5, 0x52, 0xb6, + 0x99, 0xfd, 0x6e, 0x0, 0x75, 0xab, 0xc1, 0x1f, 0x2b, 0x31, 0x84, 0xdf, + 0x5d, 0x3, 0xea, 0xe4, 0x6, 0xd0, 0x5b, 0x81, 0xde, 0x72, 0x3, 0xe8, + 0xad, 0x40, 0x6f, 0xb9, 0x1, 0xf4, 0x56, 0xa0, 0xb7, 0xdc, 0x0, 0xb6, + 0x51, 0x8e, 0x85, 0x3b, 0xce, 0xbf, 0x50, 0x21, 0x53, 0xe3, 0x99, 0x5a, + 0xd3, 0x71, 0x60, 0xd3, 0x49, 0x5f, 0x7a, 0x0, 0x10, 0xd7, 0xc, 0xde, + 0x9, 0x36, 0xc8, 0xc5, 0x36, 0x71, 0x69, 0x3c, 0x9e, 0xd0, 0xb6, 0x1d, + 0x65, 0xf7, 0xc1, 0x97, 0x1e, 0x0, 0x36, 0x39, 0xa0, 0x5a, 0x38, 0x70, + 0x50, 0xab, 0xb6, 0xc7, 0x2d, 0xae, 0xe5, 0xe7, 0xf9, 0xf3, 0x0, 0x46, + 0x31, 0xbf, 0x37, 0x6, 0xe0, 0x68, 0xd5, 0x47, 0x1, 0xa8, 0x35, 0xe2, + 0x61, 0x52, 0x98, 0xfc, 0x2e, 0xde, 0x41, 0x73, 0x74, 0xc4, 0x5f, 0xc8, + 0x5, 0x69, 0x98, 0xd5, 0xdc, 0x55, 0x1c, 0x9c, 0x5c, 0xbc, 0x22, 0x52, + 0x2f, 0x0, 0x1, 0xc4, 0x7c, 0x50, 0xb7, 0xe8, 0x33, 0xa8, 0x17, 0x21, + 0x7b, 0x7d, 0x2, 0x90, 0x3b, 0x1f, 0x40, 0x78, 0x92, 0x33, 0x46, 0xc1, + 0x14, 0xda, 0x86, 0x24, 0xeb, 0xea, 0xb, 0x80, 0xf4, 0x48, 0xa1, 0x8a, + 0x42, 0x0, 0xc5, 0x95, 0x61, 0xf, 0xb7, 0xa2, 0x1c, 0x4a, 0x4e, 0x8, + 0x83, 0x3c, 0x52, 0x96, 0x94, 0xf, 0x7c, 0x7, 0x48, 0x76, 0x17, 0xb8, + 0x10, 0x78, 0x87, 0x5a, 0x72, 0x1d, 0x19, 0x94, 0xa9, 0x6a, 0xae, 0x49, + 0xde, 0x9e, 0x1, 0x78, 0x89, 0x13, 0x4, 0x50, 0xaa, 0xd5, 0x7a, 0xca, + 0xa9, 0xdc, 0x21, 0x18, 0x94, 0x90, 0xca, 0x3f, 0x63, 0xbd, 0xff, 0x23, + 0x42, 0x5a, 0xe5, 0xf5, 0x71, 0x48, 0x2b, 0xcf, 0xeb, 0x44, 0x69, 0x35, + 0x3c, 0xd4, 0xa5, 0xd1, 0xd1, 0xc2, 0x6c, 0xe0, 0xd2, 0xa3, 0xa7, 0xe3, + 0x80, 0xab, 0xae, 0xc5, 0x5b, 0x60, 0x36, 0x8d, 0xfb, 0xb9, 0xf0, 0x38, + 0xaa, 0x83, 0x9f, 0x61, 0x22, 0x6e, 0x4, 0xe1, 0x0, 0xa4, 0x91, 0xf0, + 0x52, 0x0, 0x39, 0x29, 0x21, 0xae, 0x1, 0x1, 0xd6, 0x0, 0x83, 0xfb, + 0x6a, 0x9, 0x40, 0x2c, 0x35, 0xa0, 0x32, 0x95, 0x96, 0x34, 0x12, 0x5e, + 0xa, 0xe0, 0x91, 0x64, 0xd, 0x3, 0x0, 0x1b, 0x12, 0x6, 0x6c, 0xff, + 0x2f, 0x4d, 0xc0, 0x83, 0x9a, 0xa4, 0xea, 0xd2, 0x7c, 0x3c, 0x53, 0x69, + 0x9, 0x74, 0x2f, 0x4, 0x90, 0xcf, 0x1d, 0x50, 0xb0, 0x9, 0x8c, 0xce, + 0xc2, 0xfd, 0x87, 0xd9, 0x1, 0x80, 0x9c, 0xc9, 0x76, 0x22, 0x98, 0x78, + 0x49, 0x4d, 0xce, 0x1d, 0xc6, 0x8b, 0xd3, 0x3, 0xa3, 0xb0, 0xb1, 0xe9, + 0x42, 0x0, 0xc5, 0x5, 0x8, 0xb2, 0xf2, 0x95, 0xd1, 0xe, 0x85, 0x38, + 0xa7, 0xa1, 0x1, 0x6d, 0x90, 0x5c, 0xd3, 0xe5, 0x9, 0x1d, 0x92, 0x32, + 0x95, 0x3c, 0x42, 0x75, 0x0, 0x84, 0x91, 0xf0, 0x52, 0x0, 0x72, 0x16, + 0xa1, 0x18, 0xda, 0xbe, 0x21, 0x9f, 0x83, 0x50, 0x31, 0x54, 0x3d, 0x0, + 0x2c, 0x96, 0xcf, 0x6c, 0xd6, 0x30, 0x37, 0x0, 0x8, 0x4f, 0xb9, 0x84, + 0xd5, 0x75, 0x72, 0x90, 0x54, 0xb5, 0x1e, 0xc0, 0xf3, 0xb0, 0x9a, 0x2f, + 0x4f, 0xca, 0xbf, 0x1f, 0x80, 0xb5, 0x62, 0x10, 0xf9, 0x9f, 0xb8, 0xa7, + 0x7c, 0x2b, 0xf7, 0xd8, 0x47, 0x0, 0x7e, 0x87, 0xdc, 0x0, 0x7a, 0x2b, + 0xd0, 0x5b, 0x6e, 0x0, 0xbd, 0x15, 0xe8, 0x2d, 0x37, 0x80, 0xde, 0xa, + 0xf4, 0x96, 0x1b, 0x40, 0xfe, 0xb3, 0x58, 0x65, 0xaa, 0x8d, 0xf7, 0xb2, + 0x9, 0x3e, 0x88, 0x9b, 0xf5, 0xd, 0x38, 0x13, 0x54, 0x2a, 0xc7, 0xe3, + 0x64, 0xf9, 0x57, 0x2, 0xc8, 0xa7, 0x82, 0xda, 0x8a, 0x7d, 0xc6, 0xbb, + 0xc8, 0x16, 0x68, 0x27, 0x45, 0xa4, 0x44, 0x14, 0x27, 0x27, 0x95, 0xe3, + 0x73, 0x56, 0xdd, 0x3f, 0xb, 0xc0, 0x36, 0x9d, 0x7b, 0xf9, 0xc6, 0x4, + 0xef, 0xa4, 0x0, 0xfb, 0xc5, 0xb5, 0x94, 0x73, 0x9c, 0xf7, 0xe2, 0x64, + 0x0, 0xc2, 0x2, 0x26, 0x96, 0xa9, 0x3d, 0x48, 0xce, 0x81, 0xed, 0xf6, + 0x21, 0xdf, 0xd, 0x8a, 0xf1, 0xc2, 0xa, 0xa1, 0x0, 0x98, 0x11, 0x33, + 0x8, 0x20, 0xb8, 0x98, 0x9e, 0x3a, 0x3b, 0x50, 0xfe, 0x26, 0xf8, 0x11, + 0x66, 0xe7, 0x8e, 0x53, 0x0, 0x53, 0x5a, 0xc7, 0xe6, 0x3c, 0x2c, 0x7c, + 0xd9, 0xb3, 0x2a, 0x82, 0x87, 0x6c, 0x58, 0x7c, 0x59, 0xc, 0xca, 0xb2, + 0xc2, 0x1a, 0x31, 0x3, 0xc0, 0x47, 0x2b, 0x42, 0x0, 0x8e, 0xf2, 0x89, + 0x14, 0xc0, 0xd0, 0x6f, 0xf3, 0x7, 0x40, 0x9f, 0xdd, 0x5f, 0x70, 0xec, + 0x17, 0x10, 0x23, 0x2d, 0xf3, 0x69, 0xd4, 0x2b, 0x48, 0x41, 0x90, 0xed, + 0xf6, 0xb, 0xb0, 0xe7, 0xc7, 0x30, 0x43, 0x0, 0x79, 0x51, 0x69, 0x30, + 0x0, 0x8f, 0x33, 0x5d, 0x9, 0x0, 0x6c, 0xde, 0x32, 0x1, 0x53, 0x6b, + 0x40, 0x7d, 0x34, 0x8d, 0x61, 0x51, 0x87, 0xad, 0x5b, 0xae, 0x1, 0x65, + 0x33, 0xb, 0x3c, 0x33, 0xdc, 0xb, 0xd, 0x58, 0x6e, 0xbb, 0xf8, 0x48, + 0xcf, 0x59, 0x48, 0xea, 0x2e, 0x0, 0x58, 0x2, 0x4d, 0x10, 0x0, 0xd4, + 0x27, 0x14, 0xeb, 0xd9, 0xb1, 0x63, 0x56, 0xee, 0x3, 0xd2, 0x77, 0xc3, + 0x4, 0x5d, 0x57, 0xe1, 0x24, 0x0, 0x24, 0x5a, 0xe3, 0x21, 0x80, 0x90, + 0x2d, 0x74, 0x8, 0x0, 0xd4, 0x67, 0x7e, 0x9c, 0x53, 0x70, 0x34, 0xa2, + 0xca, 0x0, 0x66, 0xe1, 0xf0, 0xf9, 0xf3, 0x0, 0xcc, 0xe2, 0x11, 0x3, + 0x27, 0x0, 0xd8, 0x53, 0x31, 0xcd, 0x1f, 0x0, 0x50, 0x1a, 0x5b, 0x1b, + 0xcf, 0x3, 0x10, 0x1c, 0x36, 0xda, 0x9e, 0x2, 0x60, 0x77, 0x3b, 0xda, + 0x43, 0x2f, 0xee, 0x1b, 0x0, 0x64, 0x47, 0x7, 0x3c, 0xfb, 0x12, 0x80, + 0x1c, 0x4f, 0x41, 0x82, 0x43, 0x5a, 0x0, 0x90, 0x7b, 0xf0, 0xad, 0xb2, + 0x9c, 0x56, 0x0, 0xe9, 0x92, 0x9e, 0x6c, 0x9d, 0x59, 0x5c, 0xda, 0xa0, + 0x42, 0x30, 0x3f, 0x9a, 0xfc, 0x40, 0xd9, 0x17, 0x27, 0x1, 0xd8, 0x14, + 0x1a, 0xd6, 0x60, 0x39, 0xcd, 0x0, 0x3e, 0xcd, 0x23, 0xb4, 0x96, 0x5e, + 0xf4, 0xb8, 0xd, 0x55, 0x89, 0xe9, 0x63, 0x2b, 0xae, 0xb1, 0xe9, 0x8a, + 0x0, 0xf6, 0x61, 0x64, 0x68, 0x8b, 0xef, 0x41, 0x32, 0x85, 0x30, 0x57, + 0x1e, 0x7a, 0xd4, 0x43, 0xe4, 0x59, 0xb7, 0x11, 0xce, 0xf5, 0x69, 0x7e, + 0x82, 0xb4, 0xfd, 0xf0, 0x7b, 0xc8, 0x9b, 0x65, 0x47, 0x9a, 0xdc, 0xcf, + 0x27, 0x9c, 0xa3, 0xb0, 0xe2, 0xc0, 0x9e, 0xef, 0x22, 0xb7, 0x41, 0xa4, + 0xb7, 0x2, 0xbd, 0xe5, 0x6, 0xd0, 0x5b, 0x81, 0xde, 0x72, 0x3, 0xe8, + 0xad, 0x40, 0x6f, 0xb9, 0x1, 0xf4, 0x56, 0xa0, 0xb7, 0xdc, 0x0, 0xae, + 0x7f, 0xc4, 0x6a, 0xfe, 0xa0, 0x9f, 0xe3, 0x3b, 0x2, 0x8, 0xe7, 0xac, + 0x28, 0x2f, 0x3, 0x20, 0xdb, 0xd5, 0x7d, 0x9a, 0xc5, 0xcf, 0x3c, 0xf7, + 0x85, 0x8b, 0xc1, 0xc1, 0x2d, 0x10, 0xb3, 0x3, 0xd7, 0x83, 0x1b, 0x4b, + 0xfe, 0x7a, 0x50, 0x7a, 0x7c, 0xfc, 0x79, 0xb9, 0x5c, 0x56, 0xce, 0xec, + 0xb, 0x8f, 0xb, 0xe1, 0xf5, 0xb, 0x6b, 0xf9, 0x80, 0x1f, 0x80, 0x28, + 0x95, 0xc3, 0x1, 0xec, 0x76, 0x75, 0x6e, 0x99, 0x91, 0xe2, 0xf0, 0x5d, + 0xf1, 0xb, 0xa8, 0x88, 0xef, 0x77, 0xfc, 0x76, 0x21, 0x41, 0xb3, 0x68, + 0xcc, 0xcc, 0xaa, 0x78, 0xa6, 0x90, 0x7d, 0x66, 0x9e, 0x7a, 0x7d, 0x70, + 0x49, 0x21, 0xa2, 0xaa, 0xcb, 0x41, 0x0, 0x70, 0x7c, 0xbe, 0x14, 0x87, + 0xef, 0x72, 0xd2, 0x9d, 0x1, 0xf9, 0x11, 0xb2, 0x7f, 0x15, 0xba, 0xb, + 0xc, 0xa, 0x1f, 0x94, 0x2c, 0x39, 0xc5, 0x96, 0x37, 0x30, 0x7d, 0x6, + 0x29, 0xf3, 0x54, 0x4e, 0x22, 0x83, 0x42, 0xe9, 0x1f, 0xe5, 0x1c, 0xfb, + 0x5, 0x84, 0xf8, 0x7c, 0x31, 0xe, 0xbf, 0xdc, 0xa, 0xe, 0x65, 0x49, + 0x35, 0x1d, 0x3f, 0x4c, 0xe8, 0x3, 0x24, 0x0, 0xa3, 0x94, 0x78, 0xc9, + 0x2f, 0xe9, 0xc9, 0x60, 0xb3, 0xce, 0x4c, 0xa, 0x5, 0x7b, 0xb, 0xe5, + 0x20, 0x0, 0x30, 0x3e, 0x5f, 0xa, 0x43, 0x17, 0x63, 0xeb, 0x73, 0xcc, + 0x2e, 0xd, 0x28, 0xc6, 0xb7, 0xd, 0x40, 0x36, 0x45, 0xcd, 0xdc, 0x10, + 0xe5, 0x29, 0x1b, 0x4b, 0x37, 0x54, 0x96, 0x21, 0x6c, 0xa3, 0x86, 0xe5, + 0x88, 0x0, 0x6, 0xf6, 0xfd, 0x46, 0x0, 0x49, 0xc7, 0x11, 0xfe, 0x14, + 0x8d, 0x0, 0x72, 0x8, 0xbd, 0x41, 0x5c, 0x46, 0x95, 0x1a, 0x2a, 0x78, + 0x78, 0xee, 0x7c, 0x50, 0x74, 0x3, 0x2e, 0x47, 0x0, 0xc0, 0xed, 0xe7, + 0x62, 0x1c, 0xfe, 0xbb, 0xdc, 0x24, 0x2b, 0xf4, 0xeb, 0xe2, 0xdd, 0x8, + 0xf9, 0xb9, 0xa8, 0xfc, 0x6c, 0x88, 0x45, 0xdf, 0x48, 0x15, 0xdd, 0xa7, + 0xff, 0xfc, 0xe1, 0xa9, 0x17, 0x54, 0x28, 0xf3, 0x9d, 0x50, 0xe, 0x0, + 0x80, 0xe3, 0xf3, 0x4b, 0x1c, 0x7e, 0x3, 0x80, 0x71, 0x9a, 0x97, 0x1, + 0x3e, 0x31, 0x87, 0xb3, 0xf3, 0x9f, 0x68, 0x20, 0x3, 0xe3, 0xfc, 0x8b, + 0x15, 0x71, 0x86, 0x57, 0xd3, 0x77, 0x50, 0x9f, 0x91, 0x8f, 0xa4, 0x40, + 0x56, 0x57, 0xa2, 0x8a, 0xcd, 0x6d, 0xb4, 0xdb, 0xe1, 0x41, 0x7c, 0x7e, + 0x89, 0xc3, 0x6f, 0x68, 0x2, 0x65, 0xb, 0x90, 0x41, 0xf3, 0x83, 0x9c, + 0xe3, 0x1c, 0x6c, 0x77, 0x93, 0xe2, 0xfc, 0xf3, 0x49, 0xe8, 0xa0, 0x94, + 0x7c, 0x7e, 0x87, 0xe7, 0xce, 0x34, 0xff, 0x38, 0x49, 0xc2, 0xd6, 0x96, + 0x3, 0x0, 0x2c, 0x42, 0x43, 0x9, 0xb1, 0x6d, 0x47, 0xa6, 0x1c, 0x2a, + 0x8f, 0x3f, 0xb9, 0x3a, 0xed, 0x90, 0xad, 0xb1, 0xe9, 0xd3, 0xfb, 0x77, + 0xfc, 0xfa, 0x96, 0xd4, 0xde, 0x12, 0xc3, 0x58, 0xe5, 0x8d, 0xf8, 0xb1, + 0x0, 0xd2, 0x7c, 0x4d, 0xd5, 0x18, 0xf5, 0x69, 0x5b, 0xdf, 0xbd, 0xe2, + 0xfa, 0xb7, 0xbe, 0x7f, 0x5a, 0x34, 0xd4, 0x79, 0x23, 0x6e, 0x7b, 0x40, + 0x6f, 0x5, 0x7a, 0xcb, 0xd, 0xa0, 0xb7, 0x2, 0xbd, 0xe5, 0x6, 0xd0, + 0x5b, 0x81, 0xde, 0xf2, 0x15, 0x0, 0xf1, 0x94, 0xe4, 0x1, 0xdf, 0x44, + 0xbe, 0x74, 0xd4, 0xd6, 0xb5, 0x3b, 0x6a, 0xbf, 0x11, 0x0, 0xaf, 0xe0, + 0xab, 0x6, 0xe1, 0x6a, 0x53, 0x38, 0xd, 0x9, 0xa1, 0xc5, 0xa7, 0xca, + 0x68, 0xf4, 0xb1, 0x49, 0x4c, 0x96, 0x95, 0x14, 0xac, 0xec, 0x18, 0x40, + 0x74, 0xc7, 0x47, 0xbc, 0xfe, 0x7, 0x80, 0x68, 0xaf, 0x5a, 0xcc, 0x49, + 0x41, 0x35, 0x69, 0x95, 0x6f, 0x3f, 0x1, 0xe0, 0x48, 0x32, 0xf2, 0x9, + 0x4d, 0xa0, 0xc2, 0xfe, 0x50, 0x1, 0xc0, 0xe7, 0x44, 0x1, 0xea, 0x84, + 0x56, 0x16, 0x6b, 0x56, 0x43, 0xf4, 0x88, 0xe7, 0xc7, 0x9, 0x83, 0x84, + 0xed, 0xea, 0x22, 0x80, 0x86, 0x3a, 0x2d, 0x3, 0x50, 0xc5, 0x8c, 0x71, + 0xc2, 0x52, 0xb9, 0xca, 0x23, 0x43, 0xe2, 0xc1, 0x8a, 0x9d, 0x0, 0xac, + 0x8e, 0x54, 0x8, 0x27, 0x4, 0x67, 0xa1, 0x53, 0x1d, 0x20, 0x80, 0x1c, + 0xcf, 0xaf, 0xe0, 0xad, 0x63, 0x2b, 0x0, 0x98, 0x8d, 0x26, 0xce, 0xb0, + 0x21, 0x49, 0x0, 0xec, 0x49, 0xd1, 0x79, 0x5b, 0x4e, 0xc, 0xae, 0xed, + 0x61, 0xa8, 0x68, 0xd1, 0x1, 0x6e, 0xdc, 0xf0, 0xa3, 0xe4, 0x55, 0x11, + 0x1, 0x38, 0xd2, 0xec, 0x93, 0xa8, 0x8a, 0xdb, 0x89, 0x39, 0x34, 0xc4, + 0x26, 0x70, 0x7c, 0x4e, 0x6a, 0x9d, 0x54, 0xa6, 0x33, 0xd8, 0x13, 0x29, + 0x21, 0xd3, 0x81, 0x15, 0xf, 0x19, 0x11, 0x1, 0x64, 0x33, 0xdf, 0xeb, + 0xb5, 0x99, 0xdc, 0x94, 0xb8, 0xb0, 0xdf, 0x54, 0x2, 0x30, 0xa9, 0xfc, + 0xbb, 0xb5, 0x65, 0xe0, 0x13, 0xa4, 0xca, 0x9a, 0x43, 0xc5, 0xae, 0xe, + 0x2b, 0x69, 0x4, 0xa7, 0x2, 0xbc, 0x7, 0x30, 0x0, 0x64, 0xde, 0xee, + 0xf9, 0x52, 0x5e, 0x3f, 0x91, 0x0, 0x78, 0x9b, 0x6, 0xdf, 0x73, 0x42, + 0x2b, 0xab, 0x12, 0xe9, 0x90, 0x7c, 0x40, 0xc1, 0x89, 0x9d, 0x60, 0xe4, + 0xf6, 0x4f, 0xb1, 0x9, 0xac, 0xcd, 0x59, 0x38, 0xa4, 0x7d, 0x31, 0x55, + 0x7d, 0x32, 0x65, 0xe3, 0xb1, 0xb0, 0x57, 0xb3, 0xd3, 0x30, 0x68, 0xf3, + 0x59, 0xa9, 0xa6, 0xa1, 0x23, 0xb0, 0x78, 0xe7, 0x49, 0xd5, 0x34, 0xa0, + 0xe7, 0x30, 0x28, 0x4e, 0x85, 0x47, 0x78, 0x98, 0xb8, 0x2c, 0x42, 0x9d, + 0xf1, 0x35, 0xa7, 0xee, 0x1e, 0xcc, 0x4, 0x71, 0x2f, 0x28, 0x3, 0x38, + 0x2b, 0x2a, 0xbe, 0x71, 0x1e, 0x80, 0x9e, 0x6b, 0xad, 0xa2, 0xe3, 0x6d, + 0x93, 0xef, 0x1, 0x2c, 0x64, 0x16, 0xbc, 0xaf, 0xf, 0x2, 0x8, 0x43, + 0x15, 0xf2, 0xb3, 0x25, 0x3a, 0xb8, 0xf5, 0x57, 0x93, 0xa9, 0xaa, 0x44, + 0x6f, 0x2b, 0xed, 0x48, 0x6d, 0xab, 0x41, 0xdd, 0x23, 0x85, 0x4e, 0xd0, + 0xc3, 0x27, 0xe6, 0x89, 0xf7, 0xad, 0x36, 0x42, 0xef, 0x95, 0x60, 0x10, + 0xf9, 0xeb, 0x92, 0x48, 0x55, 0x0, 0xf8, 0x5, 0x72, 0x3, 0xe8, 0xad, + 0x40, 0x6f, 0xb9, 0x1, 0xf4, 0x56, 0xa0, 0xb7, 0xdc, 0x0, 0x7a, 0x2b, + 0xd0, 0x5b, 0x6e, 0x0, 0xbd, 0x15, 0xe8, 0x2d, 0x37, 0x80, 0xde, 0xa, + 0xf4, 0x96, 0x1b, 0x40, 0x6f, 0x5, 0x7a, 0xcb, 0xd, 0xa0, 0xb7, 0x2, + 0xbd, 0xe5, 0x6, 0xd0, 0x5b, 0x81, 0xde, 0x72, 0x3, 0xe8, 0xad, 0x40, + 0x6f, 0xf9, 0xf5, 0x0, 0xfe, 0x1, 0x35, 0x69, 0x45, 0xec, 0xa0, 0xf0, + 0xdf, 0x8c, 0x0, 0x0, 0x0, 0x25, 0x74, 0x45, 0x58, 0x74, 0x64, 0x61, + 0x74, 0x65, 0x3a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x0, 0x32, 0x30, + 0x31, 0x37, 0x2d, 0x30, 0x34, 0x2d, 0x30, 0x32, 0x54, 0x31, 0x38, 0x3a, + 0x33, 0x39, 0x3a, 0x33, 0x37, 0x2b, 0x30, 0x30, 0x3a, 0x30, 0x30, 0x98, + 0xbb, 0xf, 0xb3, 0x0, 0x0, 0x0, 0x25, 0x74, 0x45, 0x58, 0x74, 0x64, + 0x61, 0x74, 0x65, 0x3a, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x0, 0x32, + 0x30, 0x31, 0x37, 0x2d, 0x30, 0x34, 0x2d, 0x30, 0x32, 0x54, 0x31, 0x38, + 0x3a, 0x33, 0x39, 0x3a, 0x33, 0x37, 0x2b, 0x30, 0x30, 0x3a, 0x30, 0x30, + 0xe9, 0xe6, 0xb7, 0xf, 0x0, 0x0, 0x0, 0x11, 0x74, 0x45, 0x58, 0x74, + 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x0, 0x55, 0x6e, 0x64, 0x65, + 0x66, 0x69, 0x6e, 0x65, 0x64, 0xdb, 0xa5, 0x33, 0x1b, 0x0, 0x0, 0x0, + 0x4a, 0x74, 0x45, 0x58, 0x74, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x0, 0x65, 0x34, 0x39, 0x30, 0x38, 0x64, 0x62, 0x62, 0x30, + 0x62, 0x64, 0x38, 0x62, 0x36, 0x62, 0x66, 0x64, 0x32, 0x38, 0x39, 0x33, + 0x34, 0x39, 0x38, 0x39, 0x35, 0x39, 0x39, 0x62, 0x66, 0x32, 0x66, 0x61, + 0x39, 0x38, 0x63, 0x63, 0x33, 0x64, 0x35, 0x36, 0x35, 0x31, 0x39, 0x66, + 0x36, 0x66, 0x36, 0x35, 0x31, 0x64, 0x61, 0x32, 0x65, 0x34, 0x36, 0x30, + 0x34, 0x38, 0x38, 0x38, 0x33, 0x34, 0x35, 0xfb, 0xa7, 0xec, 0xfc, 0x0, + 0x0, 0x0, 0x0, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82}; +} // namespace consolas_font +const unsigned int sGlyphWidth = 9; +const unsigned int sTextureWidth = 256; +const unsigned int sTextureHeight = 256; +const unsigned int sCellWidth = 24; +const unsigned int sCellHeight = 24; +const unsigned int sFirstChar = 32; + +const FontBitmapInfo sFixedWidthCompositorFont = { + mozilla::Some(9), + mozilla::Nothing(), + 256, + 256, + 24, + 24, + 32, + consolas_font::sFontPNG, + sizeof(consolas_font::sFontPNG)}; + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ContainerLayerComposite.cpp b/gfx/layers/composite/ContainerLayerComposite.cpp new file mode 100644 index 0000000000..34b91714e0 --- /dev/null +++ b/gfx/layers/composite/ContainerLayerComposite.cpp @@ -0,0 +1,820 @@ +/* -*- 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 "ContainerLayerComposite.h" +#include <algorithm> // for min +#include "FrameMetrics.h" // for FrameMetrics +#include "Units.h" // for LayerRect, LayerPixel, etc +#include "CompositableHost.h" // for CompositableHost +#include "gfxEnv.h" // for gfxEnv +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/StaticPrefs_apz.h" +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/UniquePtr.h" // for UniquePtr +#include "mozilla/gfx/BaseRect.h" // for BaseRect +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point, IntPoint +#include "mozilla/gfx/Rect.h" // for IntRect, Rect +#include "mozilla/layers/APZSampler.h" // for APZSampler +#include "mozilla/layers/BSPTree.h" +#include "mozilla/layers/Compositor.h" // for Compositor, etc +#include "mozilla/layers/CompositorBridgeParent.h" // for CompositorBridgeParent +#include "mozilla/layers/CompositorTypes.h" // for DiagnosticFlags::CONTAINER +#include "mozilla/layers/Effects.h" // for Effect, EffectChain, etc +#include "mozilla/layers/TextureHost.h" // for CompositingRenderTarget +#include "mozilla/layers/APZUtils.h" // for AsyncTransform +#include "mozilla/layers/LayerManagerCompositeUtils.h" +#include "mozilla/layers/LayerMetricsWrapper.h" // for LayerMetricsWrapper +#include "mozilla/layers/LayersHelpers.h" +#include "mozilla/mozalloc.h" // for operator delete, etc +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsDebug.h" // for NS_ASSERTION +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "nsISupportsUtils.h" // for NS_ADDREF, NS_RELEASE +#include "nsRegion.h" // for nsIntRegion +#include "nsTArray.h" // for AutoTArray +#include <stack> +#include "TextRenderer.h" // for TextRenderer +#include <vector> +#include "GeckoProfiler.h" // for GeckoProfiler + +static mozilla::LazyLogModule sGfxCullLog("gfx.culling"); +#define CULLING_LOG(...) MOZ_LOG(sGfxCullLog, LogLevel::Debug, (__VA_ARGS__)) + +#define DUMP(...) \ + do { \ + if (gfxEnv::DumpDebug()) { \ + printf_stderr(__VA_ARGS__); \ + } \ + } while (0) +#define XYWH(k) (k).X(), (k).Y(), (k).Width(), (k).Height() +#define XY(k) (k).X(), (k).Y() +#define WH(k) (k).Width(), (k).Height() + +namespace mozilla { +namespace layers { + +using namespace gfx; + +static void DrawLayerInfo(const RenderTargetIntRect& aClipRect, + LayerManagerComposite* aManager, Layer* aLayer) { + if (aLayer->GetType() == Layer::LayerType::TYPE_CONTAINER) { + // XXX - should figure out a way to render this, but for now this + // is hard to do, since it will often get superimposed over the first + // child of the layer, which is bad. + return; + } + + std::stringstream ss; + aLayer->PrintInfo(ss, ""); + + LayerIntRegion visibleRegion = aLayer->GetVisibleRegion(); + + uint32_t maxWidth = + std::min<uint32_t>(visibleRegion.GetBounds().Width(), 500); + + IntPoint topLeft = visibleRegion.GetBounds().ToUnknownRect().TopLeft(); + aManager->GetTextRenderer()->RenderText( + aManager->GetCompositor(), ss.str().c_str(), topLeft, + aLayer->GetEffectiveTransform(), 16, maxWidth); +} + +static void PrintUniformityInfo(Layer* aLayer) { +#if defined(MOZ_GECKO_PROFILER) + if (!profiler_thread_is_being_profiled()) { + return; + } + + // Don't want to print a log for smaller layers + if (aLayer->GetLocalVisibleRegion().GetBounds().Width() < 300 || + aLayer->GetLocalVisibleRegion().GetBounds().Height() < 300) { + return; + } + + Matrix4x4 transform = aLayer->AsHostLayer()->GetShadowBaseTransform(); + if (!transform.Is2D()) { + return; + } + + Point translation = transform.As2D().GetTranslation(); + + // Contains the translation applied to a 2d layer so we can track the layer + // position at each frame. + struct LayerTranslationMarker { + static constexpr Span<const char> MarkerTypeName() { + return MakeStringSpan("LayerTranslation"); + } + static void StreamJSONMarkerData( + baseprofiler::SpliceableJSONWriter& aWriter, + ProfileBufferRawPointer<layers::Layer> aLayer, gfx::Point aPoint) { + const size_t bufferSize = 32; + char buffer[bufferSize]; + SprintfLiteral(buffer, "%p", aLayer.mRawPointer); + + aWriter.StringProperty("layer", buffer); + aWriter.IntProperty("x", aPoint.x); + aWriter.IntProperty("y", aPoint.y); + } + static MarkerSchema MarkerTypeDisplay() { + using MS = MarkerSchema; + MS schema{MS::Location::markerChart, MS::Location::markerTable}; + schema.AddKeyLabelFormat("layer", "Layer", MS::Format::string); + schema.AddKeyLabelFormat("x", "X", MS::Format::integer); + schema.AddKeyLabelFormat("y", "Y", MS::Format::integer); + return schema; + } + }; + + profiler_add_marker("LayerTranslation", geckoprofiler::category::GRAPHICS, {}, + LayerTranslationMarker{}, + WrapProfileBufferRawPointer(aLayer), translation); +#endif +} + +static Maybe<gfx::Polygon> SelectLayerGeometry( + const Maybe<gfx::Polygon>& aParentGeometry, + const Maybe<gfx::Polygon>& aChildGeometry) { + // Both the parent and the child layer were split. + if (aParentGeometry && aChildGeometry) { + return Some(aParentGeometry->ClipPolygon(*aChildGeometry)); + } + + // The parent layer was split. + if (aParentGeometry) { + return aParentGeometry; + } + + // The child layer was split. + if (aChildGeometry) { + return aChildGeometry; + } + + // No split. + return Nothing(); +} + +void TransformLayerGeometry(Layer* aLayer, Maybe<gfx::Polygon>& aGeometry) { + Layer* parent = aLayer; + gfx::Matrix4x4 transform; + + // Collect all parent transforms. + while (parent != nullptr && !parent->Is3DContextLeaf()) { + transform = transform * parent->GetLocalTransform(); + parent = parent->GetParent(); + } + + // Transform the geometry to the parent 3D context leaf coordinate space. + transform = transform.ProjectTo2D(); + + if (!transform.IsSingular()) { + aGeometry->TransformToScreenSpace(transform.Inverse(), transform); + } else { + // Discard the geometry since the result might not be correct. + aGeometry.reset(); + } +} + +template <class ContainerT> +static gfx::IntRect ContainerVisibleRect(ContainerT* aContainer) { + gfx::IntRect surfaceRect = + aContainer->GetLocalVisibleRegion().GetBounds().ToUnknownRect(); + return surfaceRect; +} + +/* all of the per-layer prepared data we need to maintain */ +struct PreparedLayer { + PreparedLayer(Layer* aLayer, RenderTargetIntRect aClipRect, + Maybe<gfx::Polygon>&& aGeometry) + : mLayer(aLayer), mClipRect(aClipRect), mGeometry(std::move(aGeometry)) {} + + RefPtr<Layer> mLayer; + RenderTargetIntRect mClipRect; + Maybe<Polygon> mGeometry; +}; + +/* all of the prepared data that we need in RenderLayer() */ +struct PreparedData { + RefPtr<CompositingRenderTarget> mTmpTarget; + AutoTArray<PreparedLayer, 12> mLayers; + bool mNeedsSurfaceCopy; +}; + +// ContainerPrepare is shared between RefLayer and ContainerLayer +template <class ContainerT> +void ContainerPrepare(ContainerT* aContainer, LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect) { + // We can end up calling prepare multiple times if we duplicated + // layers due to preserve-3d plane splitting. The results + // should be identical, so we only need to do it once. + if (aContainer->mPrepared) { + return; + } + aContainer->mPrepared = MakeUnique<PreparedData>(); + aContainer->mPrepared->mNeedsSurfaceCopy = false; + + const ContainerLayerComposite::SortMode sortMode = + aManager->GetCompositor()->SupportsLayerGeometry() + ? ContainerLayerComposite::SortMode::WITH_GEOMETRY + : ContainerLayerComposite::SortMode::WITHOUT_GEOMETRY; + + nsTArray<LayerPolygon> polygons = + aContainer->SortChildrenBy3DZOrder(sortMode); + + for (LayerPolygon& layer : polygons) { + LayerComposite* layerToRender = + static_cast<LayerComposite*>(layer.layer->ImplData()); + + RenderTargetIntRect clipRect = + layerToRender->GetLayer()->CalculateScissorRect(aClipRect); + + if (layerToRender->GetLayer()->IsBackfaceHidden()) { + continue; + } + + // We don't want to skip container layers because otherwise their mPrepared + // may be null which is not allowed. + if (!layerToRender->GetLayer()->AsContainerLayer()) { + if (!layerToRender->GetLayer()->IsVisible()) { + CULLING_LOG("Sublayer %p has no effective visible region\n", + layerToRender->GetLayer()); + continue; + } + + if (clipRect.IsEmpty()) { + CULLING_LOG("Sublayer %p has an empty world clip rect\n", + layerToRender->GetLayer()); + continue; + } + } + + CULLING_LOG("Preparing sublayer %p\n", layerToRender->GetLayer()); + + layerToRender->Prepare(clipRect); + aContainer->mPrepared->mLayers.AppendElement(PreparedLayer( + layerToRender->GetLayer(), clipRect, std::move(layer.geometry))); + } + + CULLING_LOG("Preparing container layer %p\n", aContainer->GetLayer()); + + /** + * Setup our temporary surface for rendering the contents of this container. + */ + + gfx::IntRect surfaceRect = ContainerVisibleRect(aContainer); + if (surfaceRect.IsEmpty()) { + return; + } + + bool surfaceCopyNeeded; + // DefaultComputeSupportsComponentAlphaChildren can mutate aContainer so call + // it unconditionally + aContainer->DefaultComputeSupportsComponentAlphaChildren(&surfaceCopyNeeded); + if (aContainer->UseIntermediateSurface()) { + if (!surfaceCopyNeeded) { + RefPtr<CompositingRenderTarget> surface = nullptr; + + RefPtr<CompositingRenderTarget>& lastSurf = + aContainer->mLastIntermediateSurface; + if (lastSurf && !aContainer->mChildrenChanged && + lastSurf->GetRect().IsEqualEdges(surfaceRect)) { + surface = lastSurf; + } + + if (!surface) { + // If we don't need a copy we can render to the intermediate now to + // avoid unecessary render target switching. This brings a big perf + // boost on mobile gpus. + surface = CreateOrRecycleTarget(aContainer, aManager); + + MOZ_PERFORMANCE_WARNING( + "gfx", + "[%p] Container layer requires intermediate surface rendering\n", + aContainer); + RenderIntermediate(aContainer, aManager, aClipRect.ToUnknownRect(), + surface); + aContainer->SetChildrenChanged(false); + } + + aContainer->mPrepared->mTmpTarget = surface; + } else { + MOZ_PERFORMANCE_WARNING( + "gfx", "[%p] Container layer requires intermediate surface copy\n", + aContainer); + aContainer->mPrepared->mNeedsSurfaceCopy = true; + aContainer->mLastIntermediateSurface = nullptr; + } + } else { + aContainer->mLastIntermediateSurface = nullptr; + } +} + +template <class ContainerT> +void RenderMinimap(ContainerT* aContainer, const RefPtr<APZSampler>& aSampler, + LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect, Layer* aLayer) { + Compositor* compositor = aManager->GetCompositor(); + MOZ_ASSERT(aSampler); + + if (aLayer->GetScrollMetadataCount() < 1) { + return; + } + + LayerMetricsWrapper wrapper(aLayer, 0); + if (!wrapper.GetApzc()) { + return; + } + const FrameMetrics& fm = wrapper.Metrics(); + MOZ_ASSERT(fm.IsScrollable()); + + ParentLayerPoint scrollOffset = + aSampler->GetCurrentAsyncScrollOffset(wrapper); + + // Options + const int verticalPadding = 10; + const int horizontalPadding = 5; + gfx::DeviceColor backgroundColor(0.3f, 0.3f, 0.3f, 0.3f); + gfx::DeviceColor tileActiveColor(1, 1, 1, 0.4f); + gfx::DeviceColor tileBorderColor(0, 0, 0, 0.1f); + gfx::DeviceColor pageBorderColor(0, 0, 0); + gfx::DeviceColor criticalDisplayPortColor(1.f, 1.f, 0); + gfx::DeviceColor displayPortColor(0, 1.f, 0); + gfx::DeviceColor layoutPortColor(1.f, 0, 0); + gfx::DeviceColor visualPortColor(0, 0, 1.f, 0.3f); + + // Rects + ParentLayerRect compositionBounds = fm.GetCompositionBounds(); + LayerRect scrollRect = fm.GetScrollableRect() * fm.LayersPixelsPerCSSPixel(); + LayerRect visualRect = + ParentLayerRect(scrollOffset, compositionBounds.Size()) / + LayerToParentLayerScale(1); + LayerRect dp = (fm.GetDisplayPort() + fm.GetLayoutScrollOffset()) * + fm.LayersPixelsPerCSSPixel(); + Maybe<LayerRect> layoutRect; + Maybe<LayerRect> cdp; + if (fm.IsRootContent()) { + CSSRect viewport = aSampler->GetCurrentAsyncLayoutViewport(wrapper); + layoutRect = Some(viewport * fm.LayersPixelsPerCSSPixel()); + } + if (!fm.GetCriticalDisplayPort().IsEmpty()) { + cdp = Some((fm.GetCriticalDisplayPort() + fm.GetLayoutScrollOffset()) * + fm.LayersPixelsPerCSSPixel()); + } + + // Don't render trivial minimap. They can show up from textboxes and other + // tiny frames. + if (visualRect.Width() < 64 && visualRect.Height() < 64) { + return; + } + + // Compute a scale with an appropriate aspect ratio + // We allocate up to 100px of width and the height of this layer. + float scaleFactor; + float scaleFactorX; + float scaleFactorY; + Rect dest = Rect(aClipRect.ToUnknownRect()); + if (aLayer->GetLocalClipRect()) { + dest = Rect(aLayer->GetLocalClipRect().value().ToUnknownRect()); + } else { + dest = aContainer->GetEffectiveTransform().Inverse().TransformBounds(dest); + } + dest = dest.Intersect(compositionBounds.ToUnknownRect()); + scaleFactorX = std::min(100.f, dest.Width() - (2 * horizontalPadding)) / + scrollRect.Width(); + scaleFactorY = (dest.Height() - (2 * verticalPadding)) / scrollRect.Height(); + scaleFactor = std::min(scaleFactorX, scaleFactorY); + if (scaleFactor <= 0) { + return; + } + + Matrix4x4 transform = Matrix4x4::Scaling(scaleFactor, scaleFactor, 1); + transform.PostTranslate(horizontalPadding + dest.X(), + verticalPadding + dest.Y(), 0); + + Rect transformedScrollRect = + transform.TransformBounds(scrollRect.ToUnknownRect()); + + IntRect clipRect = + RoundedOut(aContainer->GetEffectiveTransform().TransformBounds( + transformedScrollRect)); + + // Render the scrollable area. + compositor->FillRect(transformedScrollRect, backgroundColor, clipRect, + aContainer->GetEffectiveTransform()); + compositor->SlowDrawRect(transformedScrollRect, pageBorderColor, clipRect, + aContainer->GetEffectiveTransform()); + + // Render the displayport. + Rect r = transform.TransformBounds(dp.ToUnknownRect()); + compositor->FillRect(r, tileActiveColor, clipRect, + aContainer->GetEffectiveTransform()); + compositor->SlowDrawRect(r, displayPortColor, clipRect, + aContainer->GetEffectiveTransform()); + + // Render the critical displayport if there is one + if (cdp) { + r = transform.TransformBounds(cdp->ToUnknownRect()); + compositor->SlowDrawRect(r, criticalDisplayPortColor, clipRect, + aContainer->GetEffectiveTransform()); + } + + // Render the layout viewport if it exists (which is only in the root + // content APZC). + if (layoutRect) { + r = transform.TransformBounds(layoutRect->ToUnknownRect()); + compositor->SlowDrawRect(r, layoutPortColor, clipRect, + aContainer->GetEffectiveTransform()); + } + + // Render the visual viewport. + r = transform.TransformBounds(visualRect.ToUnknownRect()); + compositor->SlowDrawRect(r, visualPortColor, clipRect, + aContainer->GetEffectiveTransform(), 2); +} + +template <class ContainerT> +void RenderLayers(ContainerT* aContainer, LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + Compositor* compositor = aManager->GetCompositor(); + + RefPtr<APZSampler> sampler; + if (CompositorBridgeParent* cbp = compositor->GetCompositorBridgeParent()) { + sampler = cbp->GetAPZSampler(); + } + + for (size_t i = 0u; i < aContainer->mPrepared->mLayers.Length(); i++) { + PreparedLayer& preparedData = aContainer->mPrepared->mLayers[i]; + + const gfx::IntRect clipRect = preparedData.mClipRect.ToUnknownRect(); + LayerComposite* layerToRender = + static_cast<LayerComposite*>(preparedData.mLayer->ImplData()); + const Maybe<gfx::Polygon>& childGeometry = preparedData.mGeometry; + + Layer* layer = layerToRender->GetLayer(); + + if (layerToRender->HasStaleCompositor()) { + continue; + } + + if (StaticPrefs::layers_acceleration_draw_fps()) { + for (const auto& metadata : layer->GetAllScrollMetadata()) { + if (metadata.IsApzForceDisabled()) { + aManager->DisabledApzWarning(); + break; + } + } + } + + if (layerToRender->HasLayerBeenComposited()) { + // Composer2D will compose this layer so skip GPU composition + // this time. The flag will be reset for the next composition phase + // at the beginning of LayerManagerComposite::Rener(). + gfx::IntRect clearRect = layerToRender->GetClearRect(); + if (!clearRect.IsEmpty()) { + // Clear layer's visible rect on FrameBuffer with transparent pixels + gfx::Rect fbRect(clearRect.X(), clearRect.Y(), clearRect.Width(), + clearRect.Height()); + compositor->ClearRect(fbRect); + layerToRender->SetClearRect(gfx::IntRect(0, 0, 0, 0)); + } + } else { + // Since we force an intermediate surface for nested 3D contexts, + // aGeometry and childGeometry are both in the same coordinate space. + Maybe<gfx::Polygon> geometry = + SelectLayerGeometry(aGeometry, childGeometry); + + // If we are dealing with a nested 3D context, we might need to transform + // the geometry back to the coordinate space of the current layer before + // rendering the layer. + ContainerLayer* container = layer->AsContainerLayer(); + const bool isLeafLayer = + !container || container->UseIntermediateSurface(); + + if (geometry && isLeafLayer) { + TransformLayerGeometry(layer, geometry); + } + + layerToRender->RenderLayer(clipRect, geometry); + } + + if (StaticPrefs::layers_uniformity_info_AtStartup()) { + PrintUniformityInfo(layer); + } + + if (StaticPrefs::layers_draw_layer_info()) { + DrawLayerInfo(preparedData.mClipRect, aManager, layer); + } + + // Draw a border around scrollable layers. + // A layer can be scrolled by multiple scroll frames. Draw a border + // for each. + // Within the list of scroll frames for a layer, the layer border for a + // scroll frame lower down is affected by the async transforms on scroll + // frames higher up, so loop from the top down, and accumulate an async + // transform as we go along. + Matrix4x4 asyncTransform; + if (sampler) { + for (uint32_t i = layer->GetScrollMetadataCount(); i > 0; --i) { + LayerMetricsWrapper wrapper(layer, i - 1); + if (wrapper.GetApzc()) { + MOZ_ASSERT(wrapper.Metrics().IsScrollable()); + // Since the composition bounds are in the parent layer's coordinates, + // use the parent's effective transform rather than the layer's own. + ParentLayerRect compositionBounds = + wrapper.Metrics().GetCompositionBounds(); + aManager->GetCompositor()->DrawDiagnostics( + DiagnosticFlags::CONTAINER, compositionBounds.ToUnknownRect(), + aClipRect.ToUnknownRect(), + asyncTransform * aContainer->GetEffectiveTransform()); + asyncTransform = + sampler->GetCurrentAsyncTransformWithOverscroll(wrapper) + .ToUnknownMatrix() * + asyncTransform; + } + } + + if (StaticPrefs::apz_minimap_enabled()) { + RenderMinimap(aContainer, sampler, aManager, aClipRect, layer); + } + } + + // invariant: our GL context should be current here, I don't think we can + // assert it though + } +} + +template <class ContainerT> +RefPtr<CompositingRenderTarget> CreateOrRecycleTarget( + ContainerT* aContainer, LayerManagerComposite* aManager) { + Compositor* compositor = aManager->GetCompositor(); + SurfaceInitMode mode = INIT_MODE_CLEAR; + gfx::IntRect surfaceRect = ContainerVisibleRect(aContainer); + if (aContainer->GetLocalVisibleRegion().GetNumRects() == 1 && + (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE)) { + mode = INIT_MODE_NONE; + } + + RefPtr<CompositingRenderTarget>& lastSurf = + aContainer->mLastIntermediateSurface; + if (lastSurf && lastSurf->GetRect().IsEqualEdges(surfaceRect)) { + if (mode == INIT_MODE_CLEAR) { + lastSurf->ClearOnBind(); + } + + return lastSurf; + } else { + lastSurf = compositor->CreateRenderTarget(surfaceRect, mode); + + return lastSurf; + } +} + +template <class ContainerT> +RefPtr<CompositingRenderTarget> CreateTemporaryTargetAndCopyFromBackground( + ContainerT* aContainer, LayerManagerComposite* aManager) { + Compositor* compositor = aManager->GetCompositor(); + gfx::IntRect visibleRect = + aContainer->GetLocalVisibleRegion().GetBounds().ToUnknownRect(); + RefPtr<CompositingRenderTarget> previousTarget = + compositor->GetCurrentRenderTarget(); + gfx::IntRect surfaceRect = + gfx::IntRect(visibleRect.X(), visibleRect.Y(), visibleRect.Width(), + visibleRect.Height()); + + gfx::IntPoint sourcePoint = gfx::IntPoint(visibleRect.X(), visibleRect.Y()); + + gfx::Matrix4x4 transform = aContainer->GetEffectiveTransform(); + DebugOnly<gfx::Matrix> transform2d; + MOZ_ASSERT(transform.Is2D(&transform2d) && + !gfx::ThebesMatrix(transform2d).HasNonIntegerTranslation()); + sourcePoint += gfx::IntPoint::Truncate(transform._41, transform._42); + + sourcePoint -= previousTarget->GetOrigin(); + + return compositor->CreateRenderTargetFromSource(surfaceRect, previousTarget, + sourcePoint); +} + +template <class ContainerT> +void RenderIntermediate(ContainerT* aContainer, LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect, + RefPtr<CompositingRenderTarget> surface) { + Compositor* compositor = aManager->GetCompositor(); + RefPtr<CompositingRenderTarget> previousTarget = + compositor->GetCurrentRenderTarget(); + + if (!surface) { + return; + } + + compositor->SetRenderTarget(surface); + // pre-render all of the layers into our temporary + RenderLayers(aContainer, aManager, + RenderTargetIntRect::FromUnknownRect(aClipRect), Nothing()); + + // Unbind the current surface and rebind the previous one. + compositor->SetRenderTarget(previousTarget); +} + +template <class ContainerT> +void ContainerRender(ContainerT* aContainer, LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + MOZ_ASSERT(aContainer->mPrepared); + + if (aContainer->UseIntermediateSurface()) { + RefPtr<CompositingRenderTarget> surface; + + if (aContainer->mPrepared->mNeedsSurfaceCopy) { + // we needed to copy the background so we waited until now to render the + // intermediate + surface = + CreateTemporaryTargetAndCopyFromBackground(aContainer, aManager); + RenderIntermediate(aContainer, aManager, aClipRect, surface); + } else { + surface = aContainer->mPrepared->mTmpTarget; + } + + if (!surface) { + return; + } + + gfx::Rect visibleRect( + aContainer->GetLocalVisibleRegion().GetBounds().ToUnknownRect()); + + RefPtr<Compositor> compositor = aManager->GetCompositor(); +#ifdef MOZ_DUMP_PAINTING + if (gfxEnv::DumpCompositorTextures()) { + RefPtr<gfx::DataSourceSurface> surf = surface->Dump(compositor); + if (surf) { + WriteSnapshotToDumpFile(aContainer, surf); + } + } +#endif + + RefPtr<ContainerT> container = aContainer; + RenderWithAllMasks(aContainer, compositor, aClipRect, + [&, surface, compositor, container]( + EffectChain& effectChain, const IntRect& clipRect) { + effectChain.mPrimaryEffect = + new EffectRenderTarget(surface); + + compositor->DrawGeometry( + visibleRect, clipRect, effectChain, + container->GetEffectiveOpacity(), + container->GetEffectiveTransform(), aGeometry); + }); + + } else { + RenderLayers(aContainer, aManager, + RenderTargetIntRect::FromUnknownRect(aClipRect), aGeometry); + } + + // If it is a scrollable container layer with no child layers, and one of the + // APZCs attached to it has a nonempty async transform, then that transform is + // not applied to any visible content. Display a warning box (conditioned on + // the FPS display being enabled). + if (StaticPrefs::layers_acceleration_draw_fps() && + aContainer->IsScrollableWithoutContent()) { + RefPtr<APZSampler> sampler = + aManager->GetCompositor()->GetCompositorBridgeParent()->GetAPZSampler(); + // Since aContainer doesn't have any children we can just iterate from the + // top metrics on it down to the bottom using GetFirstChild and not worry + // about walking onto another underlying layer. + for (LayerMetricsWrapper i(aContainer); i; i = i.GetFirstChild()) { + if (sampler->HasUnusedAsyncTransform(i)) { + aManager->UnusedApzTransformWarning(); + break; + } + } + } +} + +ContainerLayerComposite::ContainerLayerComposite( + LayerManagerComposite* aManager) + : ContainerLayer(aManager, nullptr), LayerComposite(aManager) { + MOZ_COUNT_CTOR(ContainerLayerComposite); + mImplData = static_cast<LayerComposite*>(this); +} + +ContainerLayerComposite::~ContainerLayerComposite() { + MOZ_COUNT_DTOR(ContainerLayerComposite); + + // We don't Destroy() on destruction here because this destructor + // can be called after remote content has crashed, and it may not be + // safe to free the IPC resources of our children. Those resources + // are automatically cleaned up by IPDL-generated code. + // + // In the common case of normal shutdown, either + // LayerManagerComposite::Destroy(), a parent + // *ContainerLayerComposite::Destroy(), or Disconnect() will trigger + // cleanup of our resources. + RemoveAllChildren(); +} + +void ContainerLayerComposite::Destroy() { + if (!mDestroyed) { + while (mFirstChild) { + GetFirstChildComposite()->Destroy(); + RemoveChild(mFirstChild); + } + mDestroyed = true; + } +} + +LayerComposite* ContainerLayerComposite::GetFirstChildComposite() { + if (!mFirstChild) { + return nullptr; + } + return static_cast<LayerComposite*>(mFirstChild->AsHostLayer()); +} + +void ContainerLayerComposite::Cleanup() { + mPrepared = nullptr; + + for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) { + static_cast<LayerComposite*>(l->AsHostLayer())->Cleanup(); + } +} + +void ContainerLayerComposite::RenderLayer( + const gfx::IntRect& aClipRect, const Maybe<gfx::Polygon>& aGeometry) { + ContainerRender(this, mCompositeManager, aClipRect, aGeometry); +} + +void ContainerLayerComposite::Prepare(const RenderTargetIntRect& aClipRect) { + ContainerPrepare(this, mCompositeManager, aClipRect); +} + +void ContainerLayerComposite::CleanupResources() { + mLastIntermediateSurface = nullptr; + mPrepared = nullptr; + + for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) { + static_cast<LayerComposite*>(l->AsHostLayer())->CleanupResources(); + } +} + +const LayerIntRegion& ContainerLayerComposite::GetShadowVisibleRegion() { + if (!UseIntermediateSurface()) { + RecomputeShadowVisibleRegionFromChildren(); + } + + return mShadowVisibleRegion; +} + +const LayerIntRegion& RefLayerComposite::GetShadowVisibleRegion() { + if (!UseIntermediateSurface()) { + RecomputeShadowVisibleRegionFromChildren(); + } + + return mShadowVisibleRegion; +} + +RefLayerComposite::RefLayerComposite(LayerManagerComposite* aManager) + : RefLayer(aManager, nullptr), LayerComposite(aManager) { + mImplData = static_cast<LayerComposite*>(this); +} + +RefLayerComposite::~RefLayerComposite() { Destroy(); } + +void RefLayerComposite::Destroy() { + MOZ_ASSERT(!mFirstChild); + mDestroyed = true; +} + +LayerComposite* RefLayerComposite::GetFirstChildComposite() { + if (!mFirstChild) { + return nullptr; + } + return static_cast<LayerComposite*>(mFirstChild->AsHostLayer()); +} + +void RefLayerComposite::RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + ContainerRender(this, mCompositeManager, aClipRect, aGeometry); +} + +void RefLayerComposite::Prepare(const RenderTargetIntRect& aClipRect) { + ContainerPrepare(this, mCompositeManager, aClipRect); +} + +void RefLayerComposite::Cleanup() { + mPrepared = nullptr; + + for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) { + static_cast<LayerComposite*>(l->AsHostLayer())->Cleanup(); + } +} + +void RefLayerComposite::CleanupResources() { + mLastIntermediateSurface = nullptr; + mPrepared = nullptr; +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ContainerLayerComposite.h b/gfx/layers/composite/ContainerLayerComposite.h new file mode 100644 index 0000000000..68ad26db2f --- /dev/null +++ b/gfx/layers/composite/ContainerLayerComposite.h @@ -0,0 +1,197 @@ +/* -*- 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_ContainerLayerComposite_H +#define GFX_ContainerLayerComposite_H + +#include "Layers.h" // for Layer (ptr only), etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/UniquePtr.h" // for UniquePtr +#include "mozilla/layers/LayerManagerComposite.h" +#include "mozilla/gfx/Rect.h" + +namespace mozilla { +namespace layers { + +class APZSampler; +class CompositableHost; +class CompositingRenderTarget; +struct PreparedData; + +class ContainerLayerComposite : public ContainerLayer, public LayerComposite { + template <class ContainerT> + friend void ContainerPrepare(ContainerT* aContainer, + LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect); + template <class ContainerT> + friend void ContainerRender(ContainerT* aContainer, + LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry); + template <class ContainerT> + friend void RenderLayers(ContainerT* aContainer, + LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry); + template <class ContainerT> + friend void RenderIntermediate(ContainerT* aContainer, + LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect, + RefPtr<CompositingRenderTarget> surface); + template <class ContainerT> + friend RefPtr<CompositingRenderTarget> + CreateTemporaryTargetAndCopyFromBackground( + ContainerT* aContainer, LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect); + template <class ContainerT> + friend RefPtr<CompositingRenderTarget> CreateOrRecycleTarget( + ContainerT* aContainer, LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect); + + template <class ContainerT> + void RenderMinimap(ContainerT* aContainer, const RefPtr<APZSampler>& aSampler, + LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect, Layer* aLayer); + + public: + explicit ContainerLayerComposite(LayerManagerComposite* aManager); + + protected: + virtual ~ContainerLayerComposite(); + + public: + // LayerComposite Implementation + Layer* GetLayer() override { return this; } + + void SetLayerManager(HostLayerManager* aManager) override { + LayerComposite::SetLayerManager(aManager); + mManager = aManager; + mLastIntermediateSurface = nullptr; + } + + void Destroy() override; + + LayerComposite* GetFirstChildComposite() override; + + void Cleanup() override; + + void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) override; + + void Prepare(const RenderTargetIntRect& aClipRect) override; + + void ComputeEffectiveTransforms( + const gfx::Matrix4x4& aTransformToSurface) override { + DefaultComputeEffectiveTransforms(aTransformToSurface); + } + + const LayerIntRegion& GetShadowVisibleRegion() override; + + void CleanupResources() override; + + HostLayer* AsHostLayer() override { return this; } + + // container layers don't use a compositable + CompositableHost* GetCompositableHost() override { return nullptr; } + + // If the layer has a pres shell resolution, add a post-scale + // to the layer's transform equal to the pres shell resolution we're + // scaling to. This cancels out the post scale of '1 / resolution' + // added by Layout. TODO: It would be nice to get rid of both of these + // post-scales. + float GetPostXScale() const override { + return mSimpleAttrs.GetPostXScale() * mPresShellResolution; + } + float GetPostYScale() const override { + return mSimpleAttrs.GetPostYScale() * mPresShellResolution; + } + + const char* Name() const override { return "ContainerLayerComposite"; } + UniquePtr<PreparedData> mPrepared; + + RefPtr<CompositingRenderTarget> mLastIntermediateSurface; +}; + +class RefLayerComposite : public RefLayer, public LayerComposite { + template <class ContainerT> + friend void ContainerPrepare(ContainerT* aContainer, + LayerManagerComposite* aManager, + const RenderTargetIntRect& aClipRect); + template <class ContainerT> + friend void ContainerRender(ContainerT* aContainer, + LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry); + template <class ContainerT> + friend void RenderLayers(ContainerT* aContainer, + LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry); + template <class ContainerT> + friend void RenderIntermediate(ContainerT* aContainer, + LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect, + RefPtr<CompositingRenderTarget> surface); + template <class ContainerT> + friend RefPtr<CompositingRenderTarget> + CreateTemporaryTargetAndCopyFromBackground(ContainerT* aContainer, + LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect); + template <class ContainerT> + friend RefPtr<CompositingRenderTarget> CreateTemporaryTarget( + ContainerT* aContainer, LayerManagerComposite* aManager, + const gfx::IntRect& aClipRect); + + public: + explicit RefLayerComposite(LayerManagerComposite* aManager); + + protected: + virtual ~RefLayerComposite(); + + public: + /** LayerOGL implementation */ + Layer* GetLayer() override { return this; } + + void SetLayerManager(HostLayerManager* aManager) override { + LayerComposite::SetLayerManager(aManager); + mManager = aManager; + mLastIntermediateSurface = nullptr; + } + + void Destroy() override; + + LayerComposite* GetFirstChildComposite() override; + + void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) override; + + void Prepare(const RenderTargetIntRect& aClipRect) override; + + void ComputeEffectiveTransforms( + const gfx::Matrix4x4& aTransformToSurface) override { + DefaultComputeEffectiveTransforms(aTransformToSurface); + } + + const LayerIntRegion& GetShadowVisibleRegion() override; + + void Cleanup() override; + + void CleanupResources() override; + + HostLayer* AsHostLayer() override { return this; } + + // ref layers don't use a compositable + CompositableHost* GetCompositableHost() override { return nullptr; } + + const char* Name() const override { return "RefLayerComposite"; } + UniquePtr<PreparedData> mPrepared; + RefPtr<CompositingRenderTarget> mLastIntermediateSurface; +}; + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_ContainerLayerComposite_H */ diff --git a/gfx/layers/composite/ContentHost.cpp b/gfx/layers/composite/ContentHost.cpp new file mode 100644 index 0000000000..d4be5b0dc7 --- /dev/null +++ b/gfx/layers/composite/ContentHost.cpp @@ -0,0 +1,460 @@ +/* -*- 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/layers/ContentHost.h" +#include "gfx2DGlue.h" // for ContentForFormat +#include "mozilla/gfx/Point.h" // for IntSize +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/gfx/BaseRect.h" // for BaseRect +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/Effects.h" // for TexturedEffect, Effect, etc +#include "mozilla/layers/LayersMessages.h" // for ThebesBufferData +#include "nsAString.h" +#include "nsPrintfCString.h" // for nsPrintfCString +#include "nsString.h" // for nsAutoCString +#include "mozilla/layers/TextureHostOGL.h" // for TextureHostOGL + +namespace mozilla { +using namespace gfx; + +namespace layers { + +ContentHostBase::ContentHostBase(const TextureInfo& aTextureInfo) + : ContentHost(aTextureInfo), mInitialised(false) {} + +ContentHostBase::~ContentHostBase() = default; + +void ContentHostTexture::Composite( + Compositor* aCompositor, LayerComposite* aLayer, EffectChain& aEffectChain, + float aOpacity, const gfx::Matrix4x4& aTransform, + const SamplingFilter aSamplingFilter, const IntRect& aClipRect, + const nsIntRegion* aVisibleRegion, const Maybe<gfx::Polygon>& aGeometry) { + NS_ASSERTION(aVisibleRegion, "Requires a visible region"); + + AutoLockCompositableHost lock(this); + if (lock.Failed()) { + return; + } + + if (!mTextureHost->BindTextureSource(mTextureSource)) { + return; + } + MOZ_ASSERT(mTextureSource.get()); + + if (!mTextureHostOnWhite) { + mTextureSourceOnWhite = nullptr; + } + if (mTextureHostOnWhite && + !mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) { + return; + } + + RefPtr<TexturedEffect> effect = CreateTexturedEffect( + mTextureSource.get(), mTextureSourceOnWhite.get(), aSamplingFilter, true); + if (!effect) { + return; + } + + aEffectChain.mPrimaryEffect = effect; + + nsIntRegion tmpRegion; + const nsIntRegion* renderRegion; +#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE + if (PaintWillResample()) { + // If we're resampling, then the texture image will contain exactly the + // entire visible region's bounds, and we should draw it all in one quad + // to avoid unexpected aliasing. + tmpRegion = aVisibleRegion->GetBounds(); + renderRegion = &tmpRegion; + } else { + renderRegion = aVisibleRegion; + } +#else + renderRegion = aVisibleRegion; +#endif + + nsIntRegion region(*renderRegion); + nsIntPoint origin = GetOriginOffset(); + // translate into TexImage space, buffer origin might not be at texture (0,0) + region.MoveBy(-origin); + + // Figure out the intersecting draw region + gfx::IntSize texSize = mTextureSource->GetSize(); + IntRect textureRect = IntRect(0, 0, texSize.width, texSize.height); + textureRect.MoveBy(region.GetBounds().TopLeft()); + nsIntRegion subregion; + subregion.And(region, textureRect); + if (subregion.IsEmpty()) { + // Region is empty, nothing to draw + return; + } + + nsIntRegion screenRects; + nsIntRegion regionRects; + + // Collect texture/screen coordinates for drawing + for (auto iter = subregion.RectIter(); !iter.Done(); iter.Next()) { + IntRect regionRect = iter.Get(); + IntRect screenRect = iter.Get(); + screenRect.MoveBy(origin); + + screenRects.Or(screenRects, screenRect); + regionRects.Or(regionRects, regionRect); + } + + BigImageIterator* bigImgIter = mTextureSource->AsBigImageIterator(); + BigImageIterator* iterOnWhite = nullptr; + if (bigImgIter) { + bigImgIter->BeginBigImageIteration(); + } + + if (mTextureSourceOnWhite) { + iterOnWhite = mTextureSourceOnWhite->AsBigImageIterator(); + MOZ_ASSERT(!bigImgIter || + bigImgIter->GetTileCount() == iterOnWhite->GetTileCount(), + "Tile count mismatch on component alpha texture"); + if (iterOnWhite) { + iterOnWhite->BeginBigImageIteration(); + } + } + + bool usingTiles = (bigImgIter && bigImgIter->GetTileCount() > 1); + do { + if (iterOnWhite && bigImgIter) { + MOZ_ASSERT(iterOnWhite->GetTileRect() == bigImgIter->GetTileRect(), + "component alpha textures should be the same size."); + } + + IntRect texRect = bigImgIter ? bigImgIter->GetTileRect() + : IntRect(0, 0, texSize.width, texSize.height); + + // Draw texture. If we're using tiles, we do repeating manually, as texture + // repeat would cause each individual tile to repeat instead of the + // compound texture as a whole. This involves drawing at most 4 sections, + // 2 for each axis that has texture repeat. + for (int y = 0; y < (usingTiles ? 2 : 1); y++) { + for (int x = 0; x < (usingTiles ? 2 : 1); x++) { + IntRect currentTileRect(texRect); + currentTileRect.MoveBy(x * texSize.width, y * texSize.height); + + for (auto screenIter = screenRects.RectIter(), + regionIter = regionRects.RectIter(); + !screenIter.Done() && !regionIter.Done(); + screenIter.Next(), regionIter.Next()) { + const IntRect& screenRect = screenIter.Get(); + const IntRect& regionRect = regionIter.Get(); + IntRect tileScreenRect(screenRect); + IntRect tileRegionRect(regionRect); + + // When we're using tiles, find the intersection between the tile + // rect and this region rect. Tiling is then handled by the + // outer for-loops and modifying the tile rect. + if (usingTiles) { + tileScreenRect.MoveBy(-origin); + tileScreenRect = tileScreenRect.Intersect(currentTileRect); + tileScreenRect.MoveBy(origin); + + if (tileScreenRect.IsEmpty()) continue; + + tileRegionRect = regionRect.Intersect(currentTileRect); + tileRegionRect.MoveBy(-currentTileRect.TopLeft()); + } + gfx::Rect rect(tileScreenRect.X(), tileScreenRect.Y(), + tileScreenRect.Width(), tileScreenRect.Height()); + + effect->mTextureCoords = + Rect(Float(tileRegionRect.X()) / texRect.Width(), + Float(tileRegionRect.Y()) / texRect.Height(), + Float(tileRegionRect.Width()) / texRect.Width(), + Float(tileRegionRect.Height()) / texRect.Height()); + + aCompositor->DrawGeometry(rect, aClipRect, aEffectChain, aOpacity, + aTransform, aGeometry); + + if (usingTiles) { + DiagnosticFlags diagnostics = + DiagnosticFlags::CONTENT | DiagnosticFlags::BIGIMAGE; + if (iterOnWhite) { + diagnostics |= DiagnosticFlags::COMPONENT_ALPHA; + } + aCompositor->DrawDiagnostics(diagnostics, rect, aClipRect, + aTransform, mFlashCounter); + } + } + } + } + + if (iterOnWhite) { + iterOnWhite->NextTile(); + } + } while (usingTiles && bigImgIter->NextTile()); + + if (bigImgIter) { + bigImgIter->EndBigImageIteration(); + } + if (iterOnWhite) { + iterOnWhite->EndBigImageIteration(); + } + + DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT; + if (iterOnWhite) { + diagnostics |= DiagnosticFlags::COMPONENT_ALPHA; + } + aCompositor->DrawDiagnostics(diagnostics, nsIntRegion(mBufferRect), aClipRect, + aTransform, mFlashCounter); +} + +RefPtr<TextureSource> ContentHostTexture::AcquireTextureSource() { + if (!mTextureHost || !mTextureHost->AcquireTextureSource(mTextureSource)) { + return nullptr; + } + return mTextureSource.get(); +} + +RefPtr<TextureSource> ContentHostTexture::AcquireTextureSourceOnWhite() { + if (!mTextureHostOnWhite || + !mTextureHostOnWhite->AcquireTextureSource(mTextureSourceOnWhite)) { + return nullptr; + } + return mTextureSourceOnWhite.get(); +} + +void ContentHostTexture::UseTextureHost( + const nsTArray<TimedTexture>& aTextures) { + ContentHostBase::UseTextureHost(aTextures); + MOZ_ASSERT(aTextures.Length() == 1); + const TimedTexture& t = aTextures[0]; + MOZ_ASSERT(t.mPictureRect.IsEqualInterior( + nsIntRect(nsIntPoint(0, 0), nsIntSize(t.mTexture->GetSize()))), + "Only default picture rect supported"); + + if (t.mTexture != mTextureHost) { + mReceivedNewHost = true; + } + + mTextureHost = t.mTexture; + mTextureHostOnWhite = nullptr; + mTextureSourceOnWhite = nullptr; + if (mTextureHost) { + mTextureHost->PrepareTextureSource(mTextureSource); + } +} + +void ContentHostTexture::UseComponentAlphaTextures( + TextureHost* aTextureOnBlack, TextureHost* aTextureOnWhite) { + ContentHostBase::UseComponentAlphaTextures(aTextureOnBlack, aTextureOnWhite); + mTextureHost = aTextureOnBlack; + mTextureHostOnWhite = aTextureOnWhite; + if (mTextureHost) { + mTextureHost->PrepareTextureSource(mTextureSource); + } + if (mTextureHostOnWhite) { + mTextureHostOnWhite->PrepareTextureSource(mTextureSourceOnWhite); + } +} + +void ContentHostTexture::SetTextureSourceProvider( + TextureSourceProvider* aProvider) { + ContentHostBase::SetTextureSourceProvider(aProvider); + if (mTextureHost) { + mTextureHost->SetTextureSourceProvider(aProvider); + } + if (mTextureHostOnWhite) { + mTextureHostOnWhite->SetTextureSourceProvider(aProvider); + } +} + +void ContentHostTexture::Dump(std::stringstream& aStream, const char* aPrefix, + bool aDumpHtml) { +#ifdef MOZ_DUMP_PAINTING + if (aDumpHtml) { + aStream << "<ul>"; + } + if (mTextureHost) { + aStream << aPrefix; + if (aDumpHtml) { + aStream << "<li> <a href="; + } else { + aStream << "Front buffer: "; + } + DumpTextureHost(aStream, mTextureHost); + if (aDumpHtml) { + aStream << "> Front buffer </a></li> "; + } else { + aStream << "\n"; + } + } + if (mTextureHostOnWhite) { + aStream << aPrefix; + if (aDumpHtml) { + aStream << "<li> <a href="; + } else { + aStream << "Front buffer on white: "; + } + DumpTextureHost(aStream, mTextureHostOnWhite); + if (aDumpHtml) { + aStream << "> Front buffer on white </a> </li> "; + } else { + aStream << "\n"; + } + } + if (aDumpHtml) { + aStream << "</ul>"; + } +#endif +} + +static inline void AddWrappedRegion(const nsIntRegion& aInput, + nsIntRegion& aOutput, const IntSize& aSize, + const nsIntPoint& aShift) { + nsIntRegion tempRegion; + tempRegion.And(IntRect(aShift, aSize), aInput); + tempRegion.MoveBy(-aShift); + aOutput.Or(aOutput, tempRegion); +} + +bool ContentHostSingleBuffered::UpdateThebes( + const ThebesBufferData& aData, const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) { + if (!mTextureHost) { + mInitialised = false; + return true; // FIXME should we return false? Returning true for now + } // to preserve existing behavior of NOT causing IPC errors. + + // updated is in screen coordinates. Convert it to buffer coordinates. + nsIntRegion destRegion(aUpdated); + + if (mReceivedNewHost) { + destRegion.Or(destRegion, aOldValidRegionBack); + mReceivedNewHost = false; + } + destRegion.MoveBy(-aData.rect().TopLeft()); + + if (!aData.rect().Contains(aUpdated.GetBounds()) || + aData.rotation().x > aData.rect().Width() || + aData.rotation().y > aData.rect().Height()) { + NS_ERROR("Invalid update data"); + return false; + } + + // destRegion is now in logical coordinates relative to the buffer, but we + // need to account for rotation. We do that by moving the region to the + // rotation offset and then wrapping any pixels that extend off the + // bottom/right edges. + + // Shift to the rotation point + destRegion.MoveBy(aData.rotation()); + + IntSize bufferSize = aData.rect().Size(); + + // Select only the pixels that are still within the buffer. + nsIntRegion finalRegion; + finalRegion.And(IntRect(IntPoint(), bufferSize), destRegion); + + // For each of the overlap areas (right, bottom-right, bottom), select those + // pixels and wrap them around to the opposite edge of the buffer rect. + AddWrappedRegion(destRegion, finalRegion, bufferSize, + nsIntPoint(aData.rect().Width(), 0)); + AddWrappedRegion(destRegion, finalRegion, bufferSize, + nsIntPoint(aData.rect().Width(), aData.rect().Height())); + AddWrappedRegion(destRegion, finalRegion, bufferSize, + nsIntPoint(0, aData.rect().Height())); + + MOZ_ASSERT(IntRect(0, 0, aData.rect().Width(), aData.rect().Height()) + .Contains(finalRegion.GetBounds())); + + mTextureHost->Updated(&finalRegion); + if (mTextureHostOnWhite) { + mTextureHostOnWhite->Updated(&finalRegion); + } + mInitialised = true; + + mBufferRect = aData.rect(); + mBufferRotation = aData.rotation(); + + return true; +} + +bool ContentHostDoubleBuffered::UpdateThebes( + const ThebesBufferData& aData, const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) { + if (!mTextureHost) { + mInitialised = false; + return true; + } + + // We don't need to calculate an update region because we assume that if we + // are using double buffering then we have render-to-texture and thus no + // upload to do. + mTextureHost->Updated(); + if (mTextureHostOnWhite) { + mTextureHostOnWhite->Updated(); + } + mInitialised = true; + + mBufferRect = aData.rect(); + mBufferRotation = aData.rotation(); + + // Save the current valid region of our front buffer, because if + // we're double buffering, it's going to be the valid region for the + // next back buffer sent back to the renderer. + // + // NB: we rely here on the fact that mValidRegion is initialized to + // empty, and that the first time Swap() is called we don't have a + // valid front buffer that we're going to return to content. + mValidRegionForNextBackBuffer = aOldValidRegionBack; + + return true; +} + +void ContentHostTexture::PrintInfo(std::stringstream& aStream, + const char* aPrefix) { + aStream << aPrefix; + aStream << nsPrintfCString("ContentHost (0x%p)", this).get() + << " [buffer-rect=" << mBufferRect << "]" + << " [buffer-rotation=" << mBufferRotation << "]"; + if (PaintWillResample()) { + aStream << " [paint-will-resample]"; + } + + if (mTextureHost) { + nsAutoCString pfx(aPrefix); + pfx += " "; + + aStream << "\n"; + mTextureHost->PrintInfo(aStream, pfx.get()); + } +} + +already_AddRefed<TexturedEffect> ContentHostTexture::GenEffect( + const gfx::SamplingFilter aSamplingFilter) { + if (!mTextureHost) { + return nullptr; + } + if (!mTextureHost->BindTextureSource(mTextureSource)) { + return nullptr; + } + if (!mTextureHostOnWhite) { + mTextureSourceOnWhite = nullptr; + } + if (mTextureHostOnWhite && + !mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) { + return nullptr; + } + return CreateTexturedEffect(mTextureSource.get(), mTextureSourceOnWhite.get(), + aSamplingFilter, true); +} + +already_AddRefed<gfx::DataSourceSurface> ContentHostTexture::GetAsSurface() { + if (!mTextureHost) { + return nullptr; + } + + return mTextureHost->GetAsSurface(); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ContentHost.h b/gfx/layers/composite/ContentHost.h new file mode 100644 index 0000000000..6833ebd74f --- /dev/null +++ b/gfx/layers/composite/ContentHost.h @@ -0,0 +1,236 @@ +/* -*- 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_CONTENTHOST_H +#define GFX_CONTENTHOST_H + +#include <stdint.h> // for uint32_t +#include <stdio.h> // for FILE +#include "mozilla-config.h" // for MOZ_DUMP_PAINTING +#include "CompositableHost.h" // for CompositableHost, etc +#include "RotatedBuffer.h" // for RotatedBuffer, etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/gfx/BasePoint.h" // for BasePoint +#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Polygon.h" // for Polygon +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for SamplingFilter +#include "mozilla/layers/CompositorTypes.h" // for TextureInfo, etc +#include "mozilla/layers/ContentClient.h" // for ContentClient +#include "mozilla/layers/ISurfaceAllocator.h" // for ISurfaceAllocator +#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor +#include "mozilla/layers/LayersTypes.h" // for etc +#include "mozilla/layers/TextureHost.h" // for TextureHost +#include "mozilla/mozalloc.h" // for operator delete +#include "mozilla/UniquePtr.h" // for UniquePtr +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "nsPoint.h" // for nsIntPoint +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nsRegion.h" // for nsIntRegion +#include "nsTArray.h" // for nsTArray +#include "nscore.h" // for nsACString + +namespace mozilla { +namespace layers { +class Compositor; +class ThebesBufferData; +struct EffectChain; + +struct TexturedEffect; + +/** + * ContentHosts are used for compositing Painted layers, always matched by a + * ContentClient of the same type. + * + * ContentHosts support only UpdateThebes(), not Update(). + */ +class ContentHost : public CompositableHost { + public: + virtual bool UpdateThebes( + const ThebesBufferData& aData, const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) override = 0; + + virtual void SetPaintWillResample(bool aResample) { + mPaintWillResample = aResample; + } + bool PaintWillResample() { return mPaintWillResample; } + + // We use this to allow TiledContentHost to invalidate regions where + // tiles are fading in. + virtual void AddAnimationInvalidation(nsIntRegion& aRegion) {} + + virtual gfx::IntRect GetBufferRect() { + MOZ_ASSERT_UNREACHABLE("Must be implemented in derived class"); + return gfx::IntRect(); + } + + ContentHost* AsContentHost() override { return this; } + + protected: + explicit ContentHost(const TextureInfo& aTextureInfo) + : CompositableHost(aTextureInfo), mPaintWillResample(false) {} + + bool mPaintWillResample; +}; + +/** + * Base class for non-tiled ContentHosts. + * + * Ownership of the SurfaceDescriptor and the resources it represents is passed + * from the ContentClient to the ContentHost when the TextureClient/Hosts are + * created, that is recevied here by SetTextureHosts which assigns one or two + * texture hosts (for single and double buffering) to the ContentHost. + * + * It is the responsibility of the ContentHost to destroy its resources when + * they are recreated or the ContentHost dies. + */ +class ContentHostBase : public ContentHost { + public: + typedef ContentClient::ContentType ContentType; + typedef ContentClient::PaintState PaintState; + + explicit ContentHostBase(const TextureInfo& aTextureInfo); + virtual ~ContentHostBase(); + + gfx::IntRect GetBufferRect() override { return mBufferRect; } + + virtual nsIntPoint GetOriginOffset() { + return mBufferRect.TopLeft() - mBufferRotation; + } + + gfx::IntPoint GetBufferRotation() { return mBufferRotation.ToUnknownPoint(); } + + protected: + gfx::IntRect mBufferRect; + nsIntPoint mBufferRotation; + bool mInitialised; +}; + +/** + * Shared ContentHostBase implementation for content hosts that + * use up to two TextureHosts. + */ +class ContentHostTexture : public ContentHostBase { + public: + explicit ContentHostTexture(const TextureInfo& aTextureInfo) + : ContentHostBase(aTextureInfo), + mLocked(false), + mReceivedNewHost(false) {} + + void Composite(Compositor* aCompositor, LayerComposite* aLayer, + EffectChain& aEffectChain, float aOpacity, + const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, + const nsIntRegion* aVisibleRegion = nullptr, + const Maybe<gfx::Polygon>& aGeometry = Nothing()) override; + + void SetTextureSourceProvider(TextureSourceProvider* aProvider) override; + + already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override; + + void Dump(std::stringstream& aStream, const char* aPrefix = "", + bool aDumpHtml = false) override; + + void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; + + void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override; + void UseComponentAlphaTextures(TextureHost* aTextureOnBlack, + TextureHost* aTextureOnWhite) override; + + bool Lock() override { + MOZ_ASSERT(!mLocked); + if (!mTextureHost) { + return false; + } + if (!mTextureHost->Lock()) { + return false; + } + + if (mTextureHostOnWhite && !mTextureHostOnWhite->Lock()) { + return false; + } + + mLocked = true; + return true; + } + void Unlock() override { + MOZ_ASSERT(mLocked); + mTextureHost->Unlock(); + if (mTextureHostOnWhite) { + mTextureHostOnWhite->Unlock(); + } + mLocked = false; + } + + bool HasComponentAlpha() const { return !!mTextureHostOnWhite; } + + RefPtr<TextureSource> AcquireTextureSource(); + RefPtr<TextureSource> AcquireTextureSourceOnWhite(); + + ContentHostTexture* AsContentHostTexture() override { return this; } + + already_AddRefed<TexturedEffect> GenEffect( + const gfx::SamplingFilter aSamplingFilter) override; + + protected: + CompositableTextureHostRef mTextureHost; + CompositableTextureHostRef mTextureHostOnWhite; + CompositableTextureSourceRef mTextureSource; + CompositableTextureSourceRef mTextureSourceOnWhite; + bool mLocked; + bool mReceivedNewHost; +}; + +/** + * Double buffering is implemented by swapping the front and back TextureHosts. + * We assume that whenever we use double buffering, then we have + * render-to-texture and thus no texture upload to do. + */ +class ContentHostDoubleBuffered : public ContentHostTexture { + public: + explicit ContentHostDoubleBuffered(const TextureInfo& aTextureInfo) + : ContentHostTexture(aTextureInfo) {} + + virtual ~ContentHostDoubleBuffered() = default; + + CompositableType GetType() override { + return CompositableType::CONTENT_DOUBLE; + } + + virtual bool UpdateThebes(const ThebesBufferData& aData, + const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) override; + + protected: + nsIntRegion mValidRegionForNextBackBuffer; +}; + +/** + * Single buffered, therefore we must synchronously upload the image from the + * TextureHost in the layers transaction (i.e., in UpdateThebes). + */ +class ContentHostSingleBuffered : public ContentHostTexture { + public: + explicit ContentHostSingleBuffered(const TextureInfo& aTextureInfo) + : ContentHostTexture(aTextureInfo) {} + virtual ~ContentHostSingleBuffered() = default; + + CompositableType GetType() override { + return CompositableType::CONTENT_SINGLE; + } + + bool UpdateThebes(const ThebesBufferData& aData, const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) override; +}; + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/Diagnostics.cpp b/gfx/layers/composite/Diagnostics.cpp new file mode 100644 index 0000000000..0be1f978c8 --- /dev/null +++ b/gfx/layers/composite/Diagnostics.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 "Diagnostics.h" +#include "mozilla/layers/LayersMessages.h" +#include "nsPrintfCString.h" + +namespace mozilla { +namespace layers { + +float TimedMetric::Average() const { + // We take at most 2 seconds of history. + TimeStamp latest = TimeStamp::Now(); + float total = 0.0f; + size_t count = 0; + for (auto iter = mHistory.rbegin(); iter != mHistory.rend(); iter++) { + if ((latest - iter->second).ToSeconds() > 2.0f) { + break; + } + total += iter->first; + count++; + } + + if (!count) { + return 0.0f; + } + return total / float(count); +} + +Diagnostics::Diagnostics() + : mCompositeFps("Compositor"), mTransactionFps("LayerTransactions") {} + +void Diagnostics::RecordPaintTimes(const PaintTiming& aPaintTimes) { + mDlbMs.Add(aPaintTimes.dlMs()); + mDlb2Ms.Add(aPaintTimes.dl2Ms()); + mFlbMs.Add(aPaintTimes.flbMs()); + mRasterMs.Add(aPaintTimes.rasterMs()); + mSerializeMs.Add(aPaintTimes.serializeMs()); + mSendMs.Add(aPaintTimes.sendMs()); +} + +std::string Diagnostics::GetFrameOverlayString(const GPUStats& aStats) { + TimeStamp now = TimeStamp::Now(); + unsigned fps = unsigned(mCompositeFps.AddFrameAndGetFps(now)); + unsigned txnFps = unsigned(mTransactionFps.GetFPS(now)); + + float pixelFillRatio = + aStats.mInvalidPixels + ? float(aStats.mPixelsFilled) / float(aStats.mInvalidPixels) + : 0.0f; + float screenFillRatio = aStats.mScreenPixels ? float(aStats.mPixelsFilled) / + float(aStats.mScreenPixels) + : 0.0f; + + if (aStats.mDrawTime) { + mGPUDrawMs.Add(aStats.mDrawTime.value()); + } + + std::string gpuTimeString; + if (mGPUDrawMs.Empty()) { + gpuTimeString = "N/A"; + } else { + gpuTimeString = nsPrintfCString("%0.1fms", mGPUDrawMs.Average()).get(); + } + + // DL = nsDisplayListBuilder, p = partial, f = full + // FLB = FrameLayerBuilder + // R = ClientLayerManager::EndTransaction + // CP = ShadowLayerForwarder::EndTransaction (txn build) + // TX = LayerTransactionChild::SendUpdate (IPDL serialize+send) + // UP = LayerTransactionParent::RecvUpdate (IPDL deserialize, update, APZ + // update) + // CC_BUILD = Container prepare/composite frame building + // CC_EXEC = Container render/composite drawing + nsPrintfCString line1("FPS: %d (TXN: %d)", fps, txnFps); + nsPrintfCString line2( + "[CC] Build: %0.1fms Exec: %0.1fms GPU: %s Fill Ratio: %0.1f/%0.1f", + mPrepareMs.Average(), mCompositeMs.Average(), gpuTimeString.c_str(), + pixelFillRatio, screenFillRatio); + nsPrintfCString line3( + "[Content] DL p: %0.1f DL f: %0.1fms FLB: %0.1fms Raster: %0.1fms", + mDlbMs.Average(), mDlb2Ms.Average(), mFlbMs.Average(), + mRasterMs.Average()); + nsPrintfCString line4("[IPDL] Build: %0.1fms Send: %0.1fms Update: %0.1fms", + mSerializeMs.Average(), mSendMs.Average(), + mUpdateMs.Average()); + + return std::string(line1.get()) + "\n" + std::string(line2.get()) + "\n" + + std::string(line3.get()) + "\n" + std::string(line4.get()); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/Diagnostics.h b/gfx/layers/composite/Diagnostics.h new file mode 100644 index 0000000000..4619ff6aa5 --- /dev/null +++ b/gfx/layers/composite/Diagnostics.h @@ -0,0 +1,100 @@ +/* -*- 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_layers_composite_Diagnostics_h +#define mozilla_gfx_layers_composite_Diagnostics_h + +#include "FPSCounter.h" +#include "mozilla/Maybe.h" +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/TimeStamp.h" +#include <deque> +#include <string> +#include <utility> + +namespace mozilla { +namespace layers { + +class PaintTiming; + +class TimedMetric { + typedef std::pair<float, TimeStamp> Entry; + + public: + void Add(float aValue) { + if (mHistory.size() > kMaxHistory) { + mHistory.pop_front(); + } + mHistory.push_back(Entry(aValue, TimeStamp::Now())); + } + + float Average() const; + bool Empty() const { return mHistory.empty(); } + + private: + static const size_t kMaxHistory = 60; + + std::deque<Entry> mHistory; +}; + +// These statistics are collected by layers backends, preferably by the GPU +struct GPUStats { + GPUStats() : mInvalidPixels(0), mScreenPixels(0), mPixelsFilled(0) {} + + uint32_t mInvalidPixels; + uint32_t mScreenPixels; + uint32_t mPixelsFilled; + Maybe<float> mDrawTime; +}; + +// Collects various diagnostics about layers performance. +class Diagnostics { + public: + Diagnostics(); + + void RecordPaintTimes(const PaintTiming& aPaintTimes); + void RecordUpdateTime(float aValue) { mUpdateMs.Add(aValue); } + void RecordPrepareTime(float aValue) { mPrepareMs.Add(aValue); } + void RecordCompositeTime(float aValue) { mCompositeMs.Add(aValue); } + void AddTxnFrame() { mTransactionFps.AddFrame(TimeStamp::Now()); } + + std::string GetFrameOverlayString(const GPUStats& aStats); + + class Record { + public: + explicit Record(TimeStamp aStart = TimeStamp()) { + if (StaticPrefs::layers_acceleration_draw_fps()) { + mStart = aStart.IsNull() ? TimeStamp::Now() : aStart; + } + } + bool Recording() const { return !mStart.IsNull(); } + float Duration() const { + return (TimeStamp::Now() - mStart).ToMilliseconds(); + } + + private: + TimeStamp mStart; + }; + + private: + FPSCounter mCompositeFps; + FPSCounter mTransactionFps; + TimedMetric mDlbMs; + TimedMetric mDlb2Ms; + TimedMetric mFlbMs; + TimedMetric mRasterMs; + TimedMetric mSerializeMs; + TimedMetric mSendMs; + TimedMetric mUpdateMs; + TimedMetric mPrepareMs; + TimedMetric mCompositeMs; + TimedMetric mGPUDrawMs; +}; + +} // namespace layers +} // namespace mozilla + +#endif // mozilla_gfx_layers_composite_Diagnostics_h diff --git a/gfx/layers/composite/FPSCounter.cpp b/gfx/layers/composite/FPSCounter.cpp new file mode 100644 index 0000000000..cf3d0725ed --- /dev/null +++ b/gfx/layers/composite/FPSCounter.cpp @@ -0,0 +1,343 @@ +/* -*- 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 <stddef.h> // for size_t +#include "Units.h" // for ScreenIntRect +#include "gfxRect.h" // for gfxRect +#include "mozilla/gfx/Point.h" // for IntSize, Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for Color, SurfaceFormat +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorTypes.h" +#include "mozilla/layers/Effects.h" // for Effect, EffectChain, etc +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration +#include "nsPoint.h" // for nsIntPoint +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nsIFile.h" // for nsIFile +#include "nsDirectoryServiceDefs.h" // for NS_OS_TMP_DIR +#include "mozilla/Sprintf.h" +#include "FPSCounter.h" + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +FPSCounter::FPSCounter(const char* aName) + : mWriteIndex(0), mIteratorIndex(-1), mFPSName(aName) { + Init(); +} + +FPSCounter::~FPSCounter() = default; + +void FPSCounter::Init() { + for (int i = 0; i < kMaxFrames; i++) { + mFrameTimestamps.AppendElement(TimeStamp()); + } + mLastInterval = TimeStamp::Now(); +} + +// Returns true if we captured a full interval of data +bool FPSCounter::CapturedFullInterval(TimeStamp aTimestamp) { + TimeDuration duration = aTimestamp - mLastInterval; + return duration.ToSeconds() >= kFpsDumpInterval; +} + +void FPSCounter::AddFrame(TimeStamp aTimestamp) { + NS_ASSERTION(mWriteIndex < kMaxFrames, + "We probably have a bug with the circular buffer"); + NS_ASSERTION(mWriteIndex >= 0, + "Circular Buffer index should never be negative"); + + int index = mWriteIndex++; + if (mWriteIndex == kMaxFrames) { + mWriteIndex = 0; + } + + mFrameTimestamps[index] = aTimestamp; + + if (CapturedFullInterval(aTimestamp)) { + PrintFPS(); + WriteFrameTimeStamps(); + mLastInterval = aTimestamp; + } +} + +double FPSCounter::AddFrameAndGetFps(TimeStamp aTimestamp) { + AddFrame(aTimestamp); + return GetFPS(aTimestamp); +} + +int FPSCounter::GetLatestReadIndex() { + if (mWriteIndex == 0) { + return kMaxFrames - 1; + } + + return mWriteIndex - 1; +} + +TimeStamp FPSCounter::GetLatestTimeStamp() { + TimeStamp timestamp = mFrameTimestamps[GetLatestReadIndex()]; + MOZ_ASSERT(!timestamp.IsNull(), "Cannot use null timestamps"); + return timestamp; +} + +// Returns true if we iterated over a full interval of data +bool FPSCounter::IteratedFullInterval(TimeStamp aTimestamp, double aDuration) { + MOZ_ASSERT(mIteratorIndex >= 0, "Cannot be negative"); + MOZ_ASSERT(mIteratorIndex < kMaxFrames, + "Iterator index cannot be greater than kMaxFrames"); + + TimeStamp currentStamp = mFrameTimestamps[mIteratorIndex]; + TimeDuration duration = aTimestamp - currentStamp; + return duration.ToSeconds() >= aDuration; +} + +void FPSCounter::ResetReverseIterator() { + mIteratorIndex = GetLatestReadIndex(); +} + +/*** + * Returns true if we have another timestamp that is valid and + * is within the given duration that we're interested in. + * Duration is in seconds + */ +bool FPSCounter::HasNext(TimeStamp aTimestamp, double aDuration) { + // Order of evaluation here has to stay the same + // otherwise IteratedFullInterval reads from mFrameTimestamps which cannot + // be null + return (mIteratorIndex != mWriteIndex) // Didn't loop around the buffer + && !mFrameTimestamps[mIteratorIndex].IsNull() // valid data + && !IteratedFullInterval(aTimestamp, aDuration); +} + +TimeStamp FPSCounter::GetNextTimeStamp() { + TimeStamp timestamp = mFrameTimestamps[mIteratorIndex--]; + MOZ_ASSERT(!timestamp.IsNull(), "Reading Invalid Timestamp Data"); + + if (mIteratorIndex == -1) { + mIteratorIndex = kMaxFrames - 1; + } + return timestamp; +} + +/** + * GetFPS calculates how many frames we've already composited from the current + * frame timestamp and we iterate from the latest timestamp we recorded, + * going back in time. When we hit a frame that is longer than the 1 second + * from the current composited frame, we return how many frames we've counted. + * Just a visualization: + * + * aTimestamp + * Frames: 1 2 3 4 5 6 7 8 9 10 11 12 + * Time --------------------------> + * + * GetFPS iterates from aTimestamp, which is the current frame. + * Then starting at frame 12, going back to frame 11, 10, etc, we calculate + * the duration of the recorded frame timestamp from aTimestamp. + * Once duration is greater than 1 second, we return how many frames + * we composited. + */ +double FPSCounter::GetFPS(TimeStamp aTimestamp) { + int frameCount = 0; + int duration = 1.0; // Only care about the last 1s of data + + ResetReverseIterator(); + while (HasNext(aTimestamp, duration)) { + GetNextTimeStamp(); + frameCount++; + } + + return frameCount; +} + +// Iterate the same way we do in GetFPS() +int FPSCounter::BuildHistogram(std::map<int, int>& aFpsData) { + TimeStamp currentIntervalStart = GetLatestTimeStamp(); + TimeStamp currentTimeStamp = GetLatestTimeStamp(); + TimeStamp startTimeStamp = GetLatestTimeStamp(); + + int frameCount = 0; + int totalFrameCount = 0; + + ResetReverseIterator(); + while (HasNext(startTimeStamp)) { + currentTimeStamp = GetNextTimeStamp(); + TimeDuration interval = currentIntervalStart - currentTimeStamp; + + if (interval.ToSeconds() >= 1.0) { + currentIntervalStart = currentTimeStamp; + aFpsData[frameCount]++; + frameCount = 0; + } + + frameCount++; + totalFrameCount++; + } + + TimeDuration totalTime = currentIntervalStart - currentTimeStamp; + printf_stderr("Discarded %d frames over %f ms in histogram for %s\n", + frameCount, totalTime.ToMilliseconds(), mFPSName); + return totalFrameCount; +} + +// Iterate the same way we do in GetFPS() +void FPSCounter::WriteFrameTimeStamps(PRFileDesc* fd) { + const int bufferSize = 256; + char buffer[bufferSize]; + int writtenCount = SprintfLiteral(buffer, "FPS Data for: %s\n", mFPSName); + MOZ_ASSERT(writtenCount < bufferSize); + if (writtenCount >= bufferSize) { + return; + } + PR_Write(fd, buffer, writtenCount); + + ResetReverseIterator(); + TimeStamp startTimeStamp = GetLatestTimeStamp(); + + MOZ_ASSERT(HasNext(startTimeStamp)); + TimeStamp previousSample = GetNextTimeStamp(); + + MOZ_ASSERT(HasNext(startTimeStamp)); + TimeStamp nextTimeStamp = GetNextTimeStamp(); + + while (HasNext(startTimeStamp)) { + TimeDuration duration = previousSample - nextTimeStamp; + writtenCount = SprintfLiteral(buffer, "%f,\n", duration.ToMilliseconds()); + MOZ_ASSERT(writtenCount < bufferSize); + if (writtenCount >= bufferSize) { + continue; + } + PR_Write(fd, buffer, writtenCount); + + previousSample = nextTimeStamp; + nextTimeStamp = GetNextTimeStamp(); + } +} + +double FPSCounter::GetMean(std::map<int, int> aHistogram) { + double average = 0.0; + double samples = 0.0; + + for (std::map<int, int>::iterator iter = aHistogram.begin(); + iter != aHistogram.end(); ++iter) { + int fps = iter->first; + int count = iter->second; + + average += fps * count; + samples += count; + } + + return average / samples; +} + +double FPSCounter::GetStdDev(std::map<int, int> aHistogram) { + double sumOfDifferences = 0; + double average = GetMean(aHistogram); + double samples = 0.0; + + for (std::map<int, int>::iterator iter = aHistogram.begin(); + iter != aHistogram.end(); ++iter) { + int fps = iter->first; + int count = iter->second; + + double diff = ((double)fps) - average; + diff *= diff; + + for (int i = 0; i < count; i++) { + sumOfDifferences += diff; + } + samples += count; + } + + double stdDev = sumOfDifferences / samples; + return sqrt(stdDev); +} + +void FPSCounter::PrintFPS() { + if (!StaticPrefs::layers_acceleration_draw_fps_print_histogram()) { + return; + } + + std::map<int, int> histogram; + int totalFrames = BuildHistogram(histogram); + + TimeDuration measurementInterval = + mFrameTimestamps[GetLatestReadIndex()] - mLastInterval; + printf_stderr("FPS for %s. Total Frames: %d Time Interval: %f seconds\n", + mFPSName, totalFrames, + measurementInterval.ToSecondsSigDigits()); + + PrintHistogram(histogram); +} + +void FPSCounter::PrintHistogram(std::map<int, int>& aHistogram) { + if (aHistogram.empty()) { + return; + } + + int length = 0; + const int kBufferLength = 512; + int availableSpace = kBufferLength; + char buffer[kBufferLength]; + + for (std::map<int, int>::iterator iter = aHistogram.begin(); + iter != aHistogram.end(); iter++) { + int fps = iter->first; + int count = iter->second; + + int lengthRequired = + snprintf(buffer + length, availableSpace, "FPS: %d = %d. ", fps, count); + // Ran out of buffer space. Oh well - just print what we have. + if (lengthRequired > availableSpace) { + break; + } + length += lengthRequired; + availableSpace -= lengthRequired; + } + + printf_stderr("%s\n", buffer); + printf_stderr("Mean: %f , std dev %f\n", GetMean(aHistogram), + GetStdDev(aHistogram)); +} + +// Write FPS timestamp data to a file only if +// draw-fps.write-to-file is true +nsresult FPSCounter::WriteFrameTimeStamps() { + if (!StaticPrefs::layers_acceleration_draw_fps_write_to_file()) { + return NS_OK; + } + + MOZ_ASSERT(mWriteIndex == 0); + + nsCOMPtr<nsIFile> resultFile; + nsresult rv = + NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(resultFile)); + NS_ENSURE_SUCCESS(rv, rv); + + if (!strncmp(mFPSName, "Compositor", strlen(mFPSName))) { + resultFile->Append(u"fps.txt"_ns); + } else { + resultFile->Append(u"txn.txt"_ns); + } + + PRFileDesc* fd = nullptr; + int mode = 644; + int openFlags = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE; + rv = resultFile->OpenNSPRFileDesc(openFlags, mode, &fd); + NS_ENSURE_SUCCESS(rv, rv); + + WriteFrameTimeStamps(fd); + PR_Close(fd); + + printf_stderr("Wrote FPS data to file: %s\n", + resultFile->HumanReadablePath().get()); + return NS_OK; +} + +} // end namespace layers +} // end namespace mozilla diff --git a/gfx/layers/composite/FPSCounter.h b/gfx/layers/composite/FPSCounter.h new file mode 100644 index 0000000000..c61b13a7b5 --- /dev/null +++ b/gfx/layers/composite/FPSCounter.h @@ -0,0 +1,102 @@ +/* -*- 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_opengl_FPSCounter_h_ +#define mozilla_layers_opengl_FPSCounter_h_ + +#include <algorithm> // for min +#include <stddef.h> // for size_t +#include <map> // for std::map +#include "GLDefs.h" // for GLuint +#include "mozilla/RefPtr.h" // for already_AddRefed, RefCounted +#include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration +#include "nsTArray.h" // for AutoTArray, nsTArray_Impl, etc +#include "prio.h" // for NSPR file i/o + +namespace mozilla { +namespace layers { + +class DataTextureSource; +class Compositor; + +// Dump the FPS histogram every 10 seconds or kMaxFrameFPS +const int kFpsDumpInterval = 10; + +// On desktop, we can have 240 hz monitors, so 10 seconds +// times 240 frames = 2400 +const int kMaxFrames = 2400; + +/** + * The FPSCounter tracks how often we composite or have a layer transaction. + * At each composite / layer transaction, we record the timestamp. + * After kFpsDumpInterval number of composites / transactions, we calculate + * the average and standard deviation of frames composited. We dump a histogram, + * which allows for more statistically significant measurements. We also dump + * absolute frame composite times to a file on the device. + * The FPS counters displayed on screen are based on how many frames we + * composited within the last ~1 second. The more accurate measurement is to + * grab the histogram from stderr or grab the FPS timestamp dumps written to + * file. + * + * To enable dumping to file, enable + * layers.acceleration.draw-fps.write-to-file pref. + + double AddFrameAndGetFps(TimeStamp aCurrentFrame) { + AddFrame(aCurrentFrame); + return EstimateFps(aCurrentFrame); + } + * To enable printing histogram data to logcat, + * enable layers.acceleration.draw-fps.print-histogram + * + * Use the HasNext(), GetNextTimeStamp() like an iterator to read the data, + * backwards in time. This abstracts away the mechanics of reading the data. + */ +class FPSCounter final { + public: + explicit FPSCounter(const char* aName); + ~FPSCounter(); + + void AddFrame(TimeStamp aTimestamp); + double AddFrameAndGetFps(TimeStamp aTimestamp); + double GetFPS(TimeStamp aTimestamp); + + private: + void Init(); + bool CapturedFullInterval(TimeStamp aTimestamp); + + // Used while iterating backwards over the data + void ResetReverseIterator(); + bool HasNext(TimeStamp aTimestamp, double aDuration = kFpsDumpInterval); + TimeStamp GetNextTimeStamp(); + int GetLatestReadIndex(); + TimeStamp GetLatestTimeStamp(); + void WriteFrameTimeStamps(PRFileDesc* fd); + bool IteratedFullInterval(TimeStamp aTimestamp, double aDuration); + + void PrintFPS(); + int BuildHistogram(std::map<int, int>& aHistogram); + void PrintHistogram(std::map<int, int>& aHistogram); + double GetMean(std::map<int, int> aHistogram); + double GetStdDev(std::map<int, int> aHistogram); + nsresult WriteFrameTimeStamps(); + + /*** + * mFrameTimestamps is a psuedo circular buffer + * Since we have a constant write time and don't + * read at an offset except our latest write + * we don't need an explicit read pointer. + */ + AutoTArray<TimeStamp, kMaxFrames> mFrameTimestamps; + int mWriteIndex; // points to next open write slot + int mIteratorIndex; // used only when iterating + const char* mFPSName; + TimeStamp mLastInterval; +}; + +} // namespace layers +} // namespace mozilla + +#endif // mozilla_layers_opengl_FPSCounter_h_ diff --git a/gfx/layers/composite/FontData.h b/gfx/layers/composite/FontData.h new file mode 100644 index 0000000000..aa315f2519 --- /dev/null +++ b/gfx/layers/composite/FontData.h @@ -0,0 +1,304 @@ +/* -*- 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/. */ + +// This is explicitly not guarded as we want only 1 file to include this and +// it's good if things break if someone else does. + +namespace mozilla { +namespace layers { +namespace normal_font { +const unsigned char sFontPNG[] = { + 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0xa, 0x0, 0x0, 0x0, 0xd, + 0x49, 0x48, 0x44, 0x52, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x8, 0x0, 0x0, 0x0, 0x0, 0x79, 0x19, 0xf7, 0xba, 0x0, 0x0, 0xb, + 0xfe, 0x49, 0x44, 0x41, 0x54, 0x78, 0xda, 0xed, 0x5d, 0xd1, 0xb6, 0xe3, + 0x20, 0x8, 0x74, 0x72, 0xf2, 0xff, 0xbf, 0x3c, 0xfb, 0xd0, 0xbb, 0xbd, + 0x51, 0x8, 0x48, 0xd4, 0xc4, 0xde, 0xda, 0xb3, 0x67, 0x77, 0x6d, 0x13, + 0x63, 0x10, 0x81, 0x41, 0x40, 0x30, 0x7d, 0xf7, 0x67, 0x4b, 0x8b, 0x0, + 0xdf, 0xfd, 0xd9, 0x2f, 0xdc, 0x3, 0xc6, 0xda, 0x76, 0x67, 0x29, 0xa5, + 0x94, 0xb8, 0x38, 0x20, 0x42, 0x33, 0xc0, 0x68, 0xaa, 0x37, 0x64, 0x14, + 0x47, 0xc2, 0x67, 0x13, 0x80, 0x5, 0xbf, 0x91, 0xb0, 0x5f, 0x9f, 0x73, + 0x71, 0x40, 0x39, 0x61, 0x1c, 0xcd, 0xff, 0x39, 0x7d, 0x8, 0x1e, 0x29, + 0x72, 0x3f, 0x1, 0x90, 0x12, 0x8a, 0xf9, 0xc, 0x52, 0x20, 0x9f, 0x51, + 0x2, 0x8e, 0xd0, 0x99, 0x8d, 0x3, 0x7a, 0x2f, 0x2, 0x7a, 0x4, 0xa4, + 0x90, 0xba, 0x8, 0x68, 0x1, 0x28, 0x32, 0x1a, 0x87, 0x6f, 0x50, 0x71, + 0x7f, 0x5f, 0x29, 0xf, 0x85, 0xa3, 0x18, 0x5b, 0x10, 0xc, 0x10, 0x80, + 0xf2, 0x1d, 0x79, 0x4e, 0x5e, 0x8f, 0xfc, 0xaf, 0x1, 0xb0, 0x60, 0x50, + 0x4, 0x17, 0x40, 0xc6, 0xd3, 0xf4, 0xd5, 0x2e, 0x3a, 0xdb, 0x1, 0x5d, + 0x85, 0x78, 0x8a, 0xbd, 0x7e, 0x33, 0xc3, 0x24, 0xe4, 0x52, 0x70, 0xff, + 0xbc, 0xf5, 0x8f, 0xf0, 0x82, 0xe2, 0x5c, 0x1c, 0xd0, 0x9b, 0x83, 0x1c, + 0x7a, 0x50, 0xb4, 0x33, 0xa9, 0xf9, 0xf5, 0x58, 0x0, 0xb, 0xe, 0x2f, + 0x2, 0x2c, 0x2, 0x7c, 0x3d, 0x1, 0xea, 0x8c, 0xb9, 0xc, 0x4f, 0x16, + 0x70, 0x14, 0x21, 0xc5, 0x8e, 0x60, 0xfb, 0x1, 0xe, 0x80, 0xf5, 0xc2, + 0x52, 0x8c, 0xb6, 0x9, 0x52, 0xdc, 0xfb, 0xc6, 0x35, 0x4, 0x40, 0xa, + 0x81, 0x8d, 0x66, 0xbd, 0xce, 0xc9, 0x8, 0x80, 0x6f, 0x93, 0x1, 0x6d, + 0xef, 0xcf, 0xf1, 0xf4, 0xc2, 0xc0, 0xf9, 0xd9, 0xdb, 0xe7, 0x7f, 0x30, + 0x5, 0x50, 0x98, 0x6b, 0x48, 0xe8, 0x9, 0xaf, 0x77, 0x14, 0xf8, 0xbe, + 0xf5, 0x7d, 0xa0, 0xfa, 0xb, 0x18, 0xa2, 0x6f, 0x3e, 0x9e, 0xc2, 0x5c, + 0x65, 0x5f, 0xe3, 0x75, 0xa7, 0x30, 0x87, 0x3d, 0xa, 0xd8, 0x42, 0x8b, + 0x8a, 0x3f, 0x81, 0xb6, 0x7f, 0xa1, 0xa6, 0x8f, 0x80, 0x7, 0xa2, 0x5d, + 0x8, 0xd2, 0xd1, 0xfb, 0x7f, 0x4a, 0x4a, 0x6e, 0xfe, 0xc, 0x3c, 0xab, + 0xa6, 0x9e, 0x31, 0x84, 0x4c, 0x9e, 0xa3, 0xfb, 0x45, 0x47, 0x7f, 0xc5, + 0xc2, 0x2, 0xcb, 0x1f, 0xb0, 0x38, 0x60, 0x11, 0x60, 0x7a, 0x2, 0xe0, + 0x6f, 0x11, 0x0, 0x1e, 0x5a, 0x85, 0x3, 0x97, 0x5f, 0xde, 0x1, 0x94, + 0x5f, 0x9c, 0x93, 0x2b, 0xf2, 0x73, 0x77, 0x68, 0xd1, 0xce, 0x1, 0x60, + 0x6e, 0x3b, 0x82, 0x44, 0x26, 0x5c, 0xe1, 0x6d, 0x5f, 0xd3, 0xb2, 0x43, + 0x91, 0xb4, 0xcd, 0xb0, 0x27, 0x97, 0x0, 0x12, 0x4, 0x53, 0xc, 0x54, + 0x25, 0x44, 0x6f, 0x4d, 0x95, 0x77, 0xe7, 0x13, 0x80, 0xd2, 0x30, 0xf4, + 0x2d, 0x1f, 0xf0, 0xb4, 0x45, 0x47, 0x11, 0x13, 0xb7, 0xda, 0x49, 0x7b, + 0xf7, 0x29, 0x22, 0x12, 0xc1, 0x23, 0xa2, 0x3, 0x1b, 0xec, 0xd, 0x30, + 0xc7, 0x7f, 0x3f, 0x4b, 0x82, 0x9d, 0x18, 0xe0, 0x2, 0x1, 0xca, 0xdd, + 0xd9, 0x32, 0xe4, 0xe2, 0x35, 0xb6, 0xdf, 0xab, 0xd0, 0x86, 0xaf, 0x59, + 0xf0, 0x80, 0x4b, 0xcc, 0xe0, 0xd6, 0xe1, 0x7e, 0x41, 0x4, 0xb8, 0xf, + 0x11, 0xf8, 0x9a, 0x37, 0x1a, 0x9c, 0xc1, 0x27, 0x6d, 0xd1, 0xe, 0x5e, + 0x22, 0x80, 0x21, 0x99, 0xcc, 0x89, 0xc, 0xee, 0x72, 0x28, 0xbe, 0x1d, + 0x10, 0x17, 0xd3, 0x60, 0x4a, 0x7c, 0x7, 0xee, 0x10, 0x0, 0x81, 0x71, + 0x73, 0x1c, 0xdd, 0x86, 0xe8, 0xf, 0x86, 0x1a, 0xfb, 0x50, 0xc8, 0x77, + 0xe3, 0xe3, 0xb7, 0xfb, 0x57, 0xdd, 0x5c, 0x78, 0x76, 0x86, 0xd5, 0x99, + 0x8d, 0xe1, 0xee, 0x1, 0x2d, 0x7f, 0xc0, 0x82, 0xc3, 0x8b, 0x0, 0xdf, + 0xfd, 0xd9, 0x15, 0xcb, 0x1a, 0x22, 0xb6, 0x94, 0x56, 0xbb, 0x94, 0x62, + 0xa5, 0x62, 0x80, 0x68, 0x9a, 0xbf, 0xf7, 0xdd, 0xf9, 0xd2, 0xed, 0x82, + 0x2c, 0x52, 0x54, 0x40, 0x15, 0xc8, 0xb7, 0xcb, 0xd0, 0x88, 0xb0, 0xc6, + 0x6d, 0x6c, 0x5c, 0x5e, 0xcf, 0xe2, 0xe, 0xbf, 0xff, 0x36, 0x59, 0xe, + 0x7b, 0x3c, 0x9b, 0x7b, 0x3, 0x3b, 0x68, 0xfd, 0x96, 0x94, 0x92, 0x8a, + 0x0, 0x12, 0x33, 0x5c, 0xbc, 0xb4, 0x42, 0xe9, 0x81, 0xa1, 0xf0, 0xb, + 0x96, 0x70, 0x4f, 0x2e, 0xa9, 0xd4, 0x64, 0xeb, 0x79, 0x33, 0x80, 0xa4, + 0xf0, 0x63, 0xc6, 0x72, 0x16, 0x76, 0xdb, 0x2f, 0x30, 0x98, 0x83, 0x5, + 0x29, 0x4d, 0x1b, 0x7b, 0x86, 0xc2, 0xd6, 0x7d, 0x88, 0x63, 0x93, 0x8c, + 0xa7, 0x6, 0x63, 0x4, 0x90, 0x8f, 0x28, 0xd7, 0xac, 0x39, 0x0, 0xfa, + 0xbd, 0x83, 0x85, 0x43, 0x25, 0x6, 0xc6, 0xfc, 0x68, 0xf1, 0x73, 0x7, + 0xd5, 0xde, 0x24, 0x60, 0xfe, 0xcf, 0x57, 0xc8, 0x9, 0x1, 0xc6, 0x58, + 0xde, 0x5f, 0x22, 0xd9, 0xe3, 0xc5, 0x12, 0x40, 0x63, 0xb0, 0xb4, 0x97, + 0x14, 0xc7, 0xce, 0xc6, 0xfc, 0x85, 0xfb, 0x33, 0x96, 0xa4, 0xdb, 0x9f, + 0x92, 0xae, 0x60, 0xe9, 0x69, 0x57, 0x6f, 0x2b, 0x5a, 0xd1, 0x6e, 0x33, + 0xa5, 0xa6, 0xeb, 0x5b, 0xad, 0x84, 0x47, 0xc1, 0xd7, 0x74, 0xf8, 0x6d, + 0xfb, 0xf2, 0xf7, 0x5f, 0x70, 0x78, 0xa1, 0xc1, 0x45, 0x80, 0x45, 0x80, + 0xaf, 0xf7, 0x7, 0x28, 0xd1, 0x9c, 0xb4, 0xc0, 0x45, 0x91, 0x4c, 0xaa, + 0xda, 0xd, 0x87, 0x6f, 0xdc, 0xfb, 0x99, 0x3f, 0x12, 0x34, 0xf1, 0xbb, + 0x7b, 0xfd, 0xff, 0x76, 0xfe, 0x6f, 0xb9, 0xbd, 0xc8, 0x23, 0x1, 0xde, + 0x9b, 0x78, 0xbf, 0xf0, 0x4e, 0xdb, 0xeb, 0xcb, 0x9e, 0x50, 0x98, 0x5e, + 0x25, 0xe0, 0x37, 0xd1, 0x1b, 0x63, 0xda, 0x47, 0xcb, 0x2c, 0xb5, 0x6e, + 0xff, 0x79, 0x63, 0xdb, 0x90, 0x7a, 0x7f, 0xb9, 0xfd, 0xfe, 0xbf, 0x12, + 0x82, 0xbc, 0x2e, 0xf7, 0xf6, 0xb4, 0x83, 0xf7, 0x8f, 0x54, 0xde, 0x25, + 0x5a, 0x67, 0xf6, 0xe5, 0xf6, 0x42, 0x63, 0xc7, 0x98, 0x87, 0x32, 0xe4, + 0xe3, 0xd3, 0x6c, 0x21, 0x22, 0x42, 0xa2, 0xfd, 0x8d, 0x48, 0x6d, 0x8f, + 0x4c, 0x4, 0xed, 0x29, 0x42, 0x41, 0x1, 0xfc, 0xbc, 0x84, 0xfe, 0xaf, + 0xdc, 0x60, 0xee, 0xcd, 0xee, 0xa, 0x53, 0x6a, 0x3e, 0xbe, 0xd0, 0x9a, + 0xad, 0xf0, 0x50, 0x1c, 0x1e, 0xc2, 0xe0, 0x4b, 0x81, 0x2e, 0xb, 0x50, + 0x44, 0x30, 0xb8, 0x70, 0x18, 0x85, 0x2c, 0x9c, 0xd8, 0x44, 0x66, 0xd7, + 0xfd, 0xf6, 0x2d, 0xfd, 0x6c, 0x60, 0x57, 0xf7, 0x49, 0x28, 0x33, 0x16, + 0x61, 0x10, 0x84, 0x6e, 0x40, 0x8d, 0x60, 0xf3, 0x78, 0xfe, 0x78, 0x79, + 0xf1, 0xfc, 0xfd, 0xcd, 0x84, 0xb9, 0xfa, 0x3c, 0xf4, 0x51, 0xae, 0x69, + 0xc2, 0x5e, 0xe3, 0x5e, 0xcd, 0x8, 0x22, 0x22, 0x53, 0xa8, 0x6f, 0x13, + 0x14, 0xe3, 0x63, 0x15, 0xd5, 0xb5, 0xe7, 0x1f, 0x63, 0x79, 0xbe, 0xd2, + 0x12, 0xfc, 0x55, 0x0, 0x5f, 0x8a, 0x8b, 0x97, 0x3f, 0x60, 0xa1, 0xc1, + 0x45, 0x80, 0x45, 0x80, 0x2f, 0xf7, 0x7, 0x54, 0xe1, 0xfd, 0xf3, 0x8d, + 0x82, 0x12, 0xfe, 0x97, 0x96, 0xa4, 0x5, 0xcf, 0x7f, 0x77, 0xc5, 0x60, + 0xf8, 0x7, 0xe4, 0xe3, 0x2d, 0xbf, 0x3e, 0x82, 0x7b, 0xd1, 0x7b, 0x1d, + 0xde, 0x17, 0xe, 0x88, 0x77, 0xdb, 0xdb, 0xcd, 0x67, 0x79, 0x7d, 0xd1, + 0x13, 0xe5, 0xde, 0x20, 0xa5, 0xbb, 0xc1, 0xc1, 0x16, 0x96, 0xf7, 0xc0, + 0x89, 0xd3, 0x3d, 0x8b, 0xf, 0xf0, 0xf3, 0x67, 0xdb, 0x94, 0x2f, 0x8e, + 0x86, 0x99, 0x48, 0x99, 0x8, 0xc4, 0x4e, 0xb6, 0x22, 0xf7, 0xf1, 0x32, + 0x20, 0x6, 0xcf, 0x47, 0x18, 0x3a, 0x74, 0x6a, 0x89, 0x79, 0x78, 0xbf, + 0xf8, 0x9d, 0x68, 0xe3, 0x80, 0x17, 0x58, 0x3d, 0x40, 0x56, 0x5, 0xba, + 0x34, 0x6, 0xcf, 0xc6, 0x84, 0x60, 0x45, 0x3d, 0x38, 0xb0, 0xc5, 0x3f, + 0x50, 0xb1, 0x1e, 0x22, 0xc1, 0xf7, 0x21, 0x77, 0x87, 0xcc, 0x37, 0xb8, + 0xb4, 0x4, 0x1a, 0x53, 0x1e, 0x30, 0xb3, 0xc1, 0xbd, 0x55, 0xe1, 0xf5, + 0x23, 0x5, 0xd0, 0xba, 0xe6, 0xf9, 0x2b, 0xfd, 0x6b, 0x16, 0x29, 0x38, + 0x74, 0x7a, 0xf6, 0x3a, 0xbc, 0x7e, 0xe0, 0x33, 0x57, 0x6, 0x8, 0x4, + 0x4f, 0xd7, 0x89, 0x6d, 0x5f, 0x31, 0x14, 0xaa, 0xea, 0x4f, 0x9e, 0x19, + 0x23, 0x82, 0xad, 0x17, 0x54, 0xc8, 0x80, 0xbe, 0x19, 0x1e, 0x93, 0x9b, + 0xc2, 0x3, 0xec, 0x9c, 0xc1, 0x2c, 0x60, 0x8e, 0xae, 0x32, 0x81, 0x86, + 0xcb, 0x21, 0xb2, 0xd0, 0xe0, 0x22, 0xc0, 0xf, 0x1, 0xf0, 0xed, 0x4, + 0xf0, 0xec, 0x88, 0xba, 0xd2, 0x4f, 0xd7, 0x3b, 0x40, 0xe7, 0x76, 0x7c, + 0x9, 0xc, 0x16, 0x83, 0x51, 0x31, 0xdb, 0x23, 0x3c, 0xbf, 0x4d, 0x6, + 0x88, 0x3, 0xb, 0x0, 0xf3, 0x77, 0x79, 0x79, 0x79, 0x9e, 0x81, 0xe8, + 0xce, 0xea, 0xa0, 0x66, 0x86, 0x4d, 0xd3, 0x39, 0x1, 0xc7, 0x3e, 0x61, + 0x8f, 0x7f, 0x57, 0x67, 0xcc, 0xa, 0x77, 0x57, 0x32, 0x3c, 0x60, 0xdc, + 0x4f, 0x25, 0x40, 0x43, 0x44, 0x2c, 0x4, 0xb9, 0xc4, 0x45, 0x8f, 0x38, + 0x42, 0x58, 0x7b, 0xfc, 0x15, 0xc9, 0xd3, 0x74, 0xd9, 0xb4, 0xad, 0xd4, + 0x35, 0x3b, 0x2f, 0x2a, 0x25, 0xe1, 0x3e, 0x66, 0x9, 0xb6, 0xaa, 0x85, + 0xd1, 0x6a, 0x65, 0x78, 0x41, 0x45, 0x36, 0x3e, 0x63, 0xf8, 0x89, 0x19, + 0x5d, 0xcd, 0xd7, 0x8a, 0xa2, 0xaa, 0x70, 0x27, 0x1, 0x8d, 0x9a, 0xef, + 0x82, 0x8b, 0x65, 0x20, 0x7, 0x10, 0x5, 0x8d, 0x8b, 0x9c, 0x94, 0x12, + 0xee, 0x97, 0x29, 0x2e, 0x74, 0xf2, 0xfe, 0xa2, 0x29, 0x31, 0xe7, 0x3e, + 0x95, 0xeb, 0xd4, 0xe3, 0xd3, 0xc8, 0x1f, 0x1c, 0x73, 0xed, 0x47, 0x60, + 0x81, 0xc9, 0x4c, 0xef, 0x7, 0x38, 0x20, 0x96, 0x1a, 0xb, 0xfe, 0x39, + 0x2, 0x2c, 0x38, 0xbc, 0x8, 0xb0, 0x8, 0xf0, 0xa7, 0x8, 0x70, 0xbb, + 0x54, 0xb7, 0x4f, 0x33, 0x88, 0xfa, 0xb3, 0x3f, 0xef, 0x98, 0x1d, 0x17, + 0xa, 0x79, 0xa5, 0xc6, 0x52, 0x51, 0x4e, 0x4f, 0xc1, 0xcb, 0x79, 0x81, + 0x3, 0x17, 0xef, 0xcb, 0x19, 0xc1, 0x69, 0xf3, 0xdd, 0x86, 0x71, 0x7d, + 0x51, 0x8f, 0x12, 0x23, 0xeb, 0x50, 0xed, 0x1a, 0x5e, 0x36, 0x2b, 0xe, + 0x78, 0x78, 0xff, 0x82, 0x59, 0xb, 0xaf, 0x58, 0x39, 0xda, 0xd6, 0xa8, + 0xc5, 0x15, 0xaa, 0x4b, 0x8c, 0x41, 0x2a, 0x6, 0x4d, 0x71, 0x58, 0xfb, + 0xc5, 0xda, 0xde, 0x6a, 0x13, 0x8d, 0x41, 0x5a, 0x15, 0x26, 0xb6, 0xb, + 0x6f, 0x0, 0x44, 0x5f, 0xb8, 0xd, 0xd9, 0x4, 0x93, 0x9d, 0x29, 0x18, + 0xd8, 0x3a, 0xd3, 0xf2, 0x82, 0x16, 0xf0, 0xce, 0xf8, 0x8c, 0x4f, 0x11, + 0x4c, 0x8a, 0xd9, 0x45, 0x57, 0x5b, 0x8d, 0xdb, 0x2d, 0x5c, 0xc8, 0x16, + 0x35, 0xab, 0xce, 0x99, 0xf0, 0x88, 0xe0, 0xc0, 0xf0, 0x9a, 0xa2, 0x12, + 0xef, 0x9b, 0x54, 0xd6, 0xfc, 0x1, 0xc9, 0xf4, 0xf, 0xb8, 0x27, 0x82, + 0xd2, 0x3c, 0x42, 0x62, 0x6c, 0x7c, 0xc0, 0x9e, 0x3c, 0x17, 0xa7, 0xeb, + 0x24, 0x55, 0xda, 0xf4, 0xae, 0xe7, 0x69, 0xb3, 0xa7, 0xc0, 0xad, 0x61, + 0xcf, 0x9, 0xd, 0xa1, 0xb1, 0x3c, 0xcf, 0xd9, 0x2d, 0x41, 0xb7, 0x1e, + 0xb, 0xbd, 0xf8, 0x0, 0x4e, 0x44, 0xee, 0x85, 0x6, 0x3b, 0x31, 0x5, + 0xc6, 0xdd, 0xff, 0x11, 0x1c, 0x30, 0xb2, 0x32, 0xcf, 0xf3, 0x4, 0x78, + 0x78, 0x4, 0xfb, 0x15, 0x3d, 0x1b, 0x14, 0x34, 0x66, 0x21, 0x20, 0x50, + 0xad, 0x54, 0x86, 0xf3, 0x2, 0x5, 0xe7, 0x8a, 0x8d, 0xa7, 0xbf, 0x5a, + 0xa9, 0xb3, 0xd1, 0x74, 0xfe, 0xce, 0x73, 0x46, 0x59, 0x6a, 0x2e, 0x87, + 0xa7, 0x6e, 0x2a, 0xaf, 0x53, 0x80, 0xd0, 0x41, 0x93, 0xfb, 0x18, 0x6b, + 0x23, 0x9f, 0x81, 0xb2, 0xd6, 0x17, 0x12, 0xa3, 0x24, 0x66, 0xcb, 0x74, + 0x98, 0xd9, 0xe3, 0xf1, 0xc3, 0xdb, 0x82, 0xb1, 0xcf, 0x32, 0xd8, 0x7c, + 0xaa, 0x52, 0xc8, 0x7b, 0xdc, 0xa1, 0x31, 0xb6, 0x54, 0xfa, 0xeb, 0x78, + 0x2, 0xbc, 0x32, 0xec, 0x99, 0x64, 0x6c, 0x32, 0x4e, 0x57, 0x3a, 0xaf, + 0x50, 0xec, 0xa, 0x7, 0x8c, 0x3e, 0x81, 0x13, 0xc4, 0xfb, 0xaf, 0x54, + 0xe6, 0x27, 0x9c, 0x3c, 0xfd, 0xb2, 0xa2, 0xdb, 0x98, 0xc8, 0x4f, 0xb2, + 0x6, 0x7b, 0x57, 0xf7, 0xd8, 0xaa, 0x41, 0x7e, 0x37, 0xa1, 0x8, 0xc7, + 0x75, 0xad, 0xa0, 0x61, 0x8b, 0x2, 0x6e, 0x98, 0x9f, 0x8b, 0xc6, 0x11, + 0xe4, 0x20, 0xe1, 0xb0, 0x53, 0x3c, 0x78, 0x99, 0x6a, 0x8a, 0x15, 0x4, + 0x7c, 0xa9, 0xe5, 0x5f, 0x19, 0x30, 0xdc, 0xe, 0xe8, 0xae, 0x2, 0x59, + 0x1, 0xf2, 0x3d, 0xbc, 0x7a, 0x2c, 0xe9, 0xd0, 0xe8, 0xa2, 0x65, 0x13, + 0x83, 0x5c, 0x60, 0x80, 0xf, 0xfb, 0x80, 0xe3, 0xef, 0xf8, 0xd3, 0x40, + 0x6b, 0xf9, 0x3, 0x16, 0x1, 0x3e, 0x90, 0xeb, 0x8f, 0xba, 0x75, 0x9b, + 0x60, 0x38, 0x68, 0xbc, 0x20, 0xfa, 0x80, 0xcc, 0x6d, 0xed, 0x9f, 0x3d, + 0xee, 0x9d, 0x3f, 0xd8, 0x38, 0x3e, 0x69, 0x46, 0xbc, 0x77, 0xa7, 0xd1, + 0x7, 0x7b, 0x50, 0x3b, 0xc, 0x0, 0xe7, 0x4, 0x70, 0x2d, 0xa7, 0xbe, + 0x72, 0x53, 0x3f, 0xc4, 0x17, 0xae, 0x7d, 0x13, 0xb5, 0x2c, 0x72, 0xcb, + 0x11, 0x2c, 0xfc, 0x1, 0xd7, 0xd5, 0xc4, 0x18, 0x3b, 0x80, 0xe0, 0x7b, + 0xcb, 0xd0, 0x3, 0x6b, 0x48, 0x66, 0x78, 0xaa, 0xb0, 0x4, 0xf3, 0xfd, + 0x78, 0xf7, 0x7c, 0x1, 0x3a, 0x33, 0x46, 0xaf, 0xde, 0x7f, 0xf, 0x45, + 0x6d, 0x55, 0xb3, 0x7f, 0x7b, 0xb4, 0xc, 0x9c, 0x88, 0x3b, 0xb5, 0x0, + 0xba, 0x40, 0x2b, 0x9e, 0x1e, 0xd2, 0x78, 0x1, 0xe, 0xca, 0xd3, 0xef, + 0x52, 0xaa, 0x5e, 0x2, 0x1d, 0xe8, 0x91, 0xbd, 0x82, 0x5f, 0xe, 0x84, + 0x87, 0x3f, 0xa9, 0x36, 0x17, 0xfb, 0x72, 0xfe, 0xf9, 0x3e, 0x60, 0xf9, + 0x9a, 0xf9, 0x1a, 0x57, 0x8a, 0xe7, 0x57, 0x84, 0x48, 0x5c, 0x77, 0x88, + 0xc, 0x10, 0x60, 0x1c, 0xc1, 0x42, 0xfe, 0xfb, 0xe0, 0xaa, 0x3f, 0xe0, + 0x3, 0xc, 0xb7, 0xae, 0x5a, 0xc0, 0x96, 0xa9, 0xb, 0xb, 0x2c, 0x2, + 0x2c, 0x2, 0x2c, 0x2, 0x2c, 0x2, 0x7c, 0xd3, 0x67, 0xff, 0xb6, 0x17, + 0xbe, 0x52, 0x43, 0xc4, 0x2f, 0xd9, 0x27, 0x2e, 0x86, 0xb1, 0x97, 0x57, + 0xe6, 0xed, 0x81, 0x96, 0xe2, 0x6e, 0x87, 0x56, 0xf6, 0xc6, 0x40, 0xcd, + 0xe6, 0x72, 0x92, 0x25, 0xc, 0x3, 0xdb, 0xf5, 0xce, 0x79, 0x7f, 0x17, + 0x28, 0x78, 0x5, 0x9, 0x9d, 0x76, 0xe2, 0x9f, 0x3c, 0xd, 0x27, 0x7d, + 0x1c, 0x45, 0x82, 0x41, 0x4d, 0xe9, 0x30, 0xfb, 0xfd, 0x81, 0x63, 0xb0, + 0x69, 0x23, 0xb4, 0x14, 0xfd, 0xb9, 0x4, 0xa0, 0x8e, 0xce, 0x2c, 0xe0, + 0x1a, 0xf2, 0x89, 0xb8, 0xd1, 0xe6, 0xc8, 0xa2, 0xb1, 0x65, 0xd7, 0x71, + 0xbc, 0x6d, 0x45, 0x77, 0xef, 0xe1, 0x45, 0x81, 0x82, 0x27, 0x50, 0x54, + 0x7b, 0x87, 0x13, 0x41, 0x51, 0x75, 0xa4, 0x26, 0x4f, 0xfc, 0x37, 0x49, + 0xd6, 0x5b, 0xa8, 0xa8, 0x8b, 0xdd, 0x78, 0xe0, 0xa2, 0xe5, 0x4e, 0x50, + 0xc7, 0xe, 0xb6, 0xe1, 0xdf, 0x54, 0xd4, 0x14, 0x35, 0xdf, 0x5f, 0x1c, + 0x4f, 0xa0, 0xbc, 0x2d, 0xfd, 0x18, 0x21, 0x1b, 0xdf, 0x9b, 0x24, 0x64, + 0x99, 0x72, 0xe3, 0x48, 0x6e, 0x2f, 0xbb, 0xdc, 0xb9, 0xc0, 0x5d, 0x71, + 0x3c, 0x19, 0x63, 0xb5, 0x16, 0x50, 0x17, 0x9d, 0xa1, 0x5, 0xf0, 0xa, + 0x6a, 0x39, 0xed, 0x41, 0xf5, 0xdf, 0x44, 0xb4, 0x80, 0x26, 0xd6, 0x58, + 0xdf, 0xa1, 0xd3, 0x5f, 0xd, 0x1, 0x9c, 0x73, 0x85, 0x9d, 0x3e, 0xa3, + 0x6a, 0x30, 0x35, 0xd6, 0x2c, 0x6d, 0xb6, 0x3, 0x7a, 0x7b, 0x8, 0xbc, + 0x83, 0x93, 0xbe, 0xcf, 0x14, 0x9e, 0xcb, 0x5, 0xb3, 0x4d, 0x3e, 0xbe, + 0xf1, 0xd8, 0x60, 0xb9, 0xc4, 0x16, 0x1, 0x16, 0x1, 0xfa, 0x20, 0xec, + 0xcf, 0x25, 0x80, 0x13, 0xb6, 0xe8, 0xd4, 0x92, 0xab, 0x88, 0x33, 0xb, + 0xa6, 0x7f, 0x47, 0xb, 0x2, 0x94, 0xf9, 0xe6, 0x79, 0xfb, 0xff, 0xb3, + 0x71, 0x2a, 0x4, 0xa5, 0x61, 0xe5, 0x5, 0x36, 0x22, 0x18, 0x5c, 0x1e, + 0xb, 0x71, 0x80, 0x63, 0xfb, 0xeb, 0xd7, 0x83, 0x67, 0x6d, 0xc7, 0xf4, + 0xaa, 0x58, 0x2, 0x22, 0x82, 0x83, 0xee, 0x84, 0xb4, 0xac, 0xa, 0x36, + 0x5e, 0x2f, 0xec, 0x2e, 0xd5, 0xb6, 0x3f, 0x10, 0x80, 0x88, 0x15, 0x77, + 0xe7, 0xc3, 0x87, 0x11, 0xaa, 0xee, 0x0, 0x83, 0x49, 0x49, 0x24, 0x3, + 0xa0, 0x8a, 0x50, 0x59, 0x14, 0xc6, 0xaa, 0x80, 0xff, 0xd1, 0x39, 0x8a, + 0xd2, 0xab, 0xf0, 0x26, 0x88, 0x3c, 0xc9, 0x12, 0xe, 0xe2, 0x10, 0x5d, + 0xfc, 0xdb, 0x3e, 0x34, 0xff, 0x3, 0x66, 0xdd, 0xc9, 0xb6, 0x2b, 0x1c, + 0x85, 0xce, 0xdb, 0xdb, 0x8, 0x49, 0x10, 0xf7, 0x81, 0x5, 0x5, 0xf8, + 0x23, 0xc9, 0x90, 0xb5, 0x7f, 0x4f, 0x8d, 0x4b, 0xc5, 0xef, 0x8f, 0xdb, + 0x1, 0xcd, 0xa6, 0x67, 0x9d, 0xd4, 0x36, 0xfc, 0xb2, 0x59, 0x73, 0x1b, + 0xb4, 0x4c, 0x87, 0x1a, 0xef, 0x9a, 0x58, 0xb3, 0x95, 0x33, 0x4e, 0x4f, + 0xa1, 0xdd, 0x4f, 0x84, 0x38, 0x5b, 0x5e, 0x9f, 0x23, 0x21, 0x6, 0xb5, + 0xb2, 0x2e, 0x2c, 0xce, 0xd9, 0xcd, 0x24, 0x57, 0xf9, 0xfb, 0x60, 0x30, + 0xa4, 0x79, 0x18, 0xa6, 0xca, 0x5d, 0xcd, 0x17, 0xc8, 0xf3, 0x5b, 0x63, + 0xb7, 0xe7, 0x1b, 0xe4, 0x3e, 0xc7, 0x3b, 0x38, 0x60, 0x6a, 0x40, 0xbe, + 0xfc, 0x1, 0xaa, 0xd4, 0xe, 0xc6, 0x4b, 0x77, 0x57, 0x1a, 0x5e, 0xd5, + 0xda, 0x5e, 0x37, 0xff, 0x27, 0x0, 0x1d, 0x1d, 0x22, 0x4c, 0x19, 0x11, + 0x7f, 0x8d, 0xc8, 0x33, 0x5d, 0x5b, 0xd1, 0x7b, 0x7e, 0x76, 0x6c, 0x73, + 0xcb, 0xcd, 0x83, 0x96, 0xc0, 0x47, 0xe5, 0x51, 0xa9, 0xc9, 0xf3, 0xdd, + 0xdb, 0xb9, 0x11, 0xa8, 0x9d, 0x67, 0x78, 0x7e, 0x80, 0xa1, 0xdb, 0x6e, + 0x1b, 0xdc, 0xae, 0xb1, 0x74, 0xe7, 0x76, 0xa1, 0xea, 0xd4, 0xf3, 0xc, + 0x3, 0x60, 0xa0, 0x2f, 0x77, 0x6d, 0x77, 0x71, 0x59, 0xd1, 0x9a, 0x66, + 0x8d, 0x6c, 0xf2, 0xb0, 0xaf, 0xde, 0xed, 0xb9, 0x3f, 0xfb, 0x5d, 0x62, + 0x26, 0x55, 0x7, 0xf3, 0x46, 0xdb, 0xed, 0x4, 0xe8, 0x7d, 0xcc, 0x89, + 0xd6, 0xe6, 0x75, 0x7, 0xc0, 0x58, 0x19, 0xb0, 0xcb, 0x53, 0x5e, 0x47, + 0xb4, 0xe7, 0x5d, 0x12, 0xf, 0x38, 0x44, 0x90, 0x66, 0xa2, 0xc8, 0xaf, + 0xef, 0x6c, 0xe8, 0xbf, 0x98, 0xd6, 0xe, 0x78, 0xc4, 0x66, 0x9b, 0xc9, + 0x50, 0x7c, 0x64, 0x6f, 0x70, 0x26, 0x2d, 0xf9, 0x8, 0x1, 0x66, 0xe2, + 0x80, 0xe5, 0xf, 0xd0, 0x25, 0xa3, 0x3, 0x6f, 0xe1, 0x41, 0xf0, 0xd6, + 0x7c, 0xef, 0x26, 0x88, 0x1f, 0xd2, 0x31, 0x5b, 0xd, 0x9c, 0x75, 0xfc, + 0x5, 0x25, 0xe6, 0x76, 0xfd, 0x5, 0x51, 0x19, 0x11, 0x84, 0xf8, 0x33, + 0x9d, 0xe1, 0xf2, 0x9, 0x58, 0x40, 0x98, 0xda, 0x22, 0xb0, 0x50, 0xc4, + 0xcb, 0x37, 0xb6, 0x35, 0x86, 0x65, 0x51, 0x75, 0xa8, 0xb7, 0x65, 0x7a, + 0x3a, 0x9c, 0x3d, 0xa9, 0xdb, 0xe9, 0x96, 0xcf, 0xa4, 0xb5, 0x5d, 0xe5, + 0x93, 0x69, 0xd1, 0xb1, 0x8c, 0x3c, 0x6e, 0x93, 0xab, 0x4e, 0xdd, 0xcc, + 0x3c, 0xc4, 0xef, 0xb7, 0xb6, 0xb, 0x21, 0xf5, 0x33, 0xa0, 0x7e, 0xa6, + 0x41, 0x99, 0xb0, 0x60, 0x47, 0xa8, 0xdc, 0xbf, 0x31, 0xa2, 0x9d, 0x27, + 0x30, 0xb6, 0x40, 0xdf, 0x99, 0x53, 0xe6, 0xc5, 0x1, 0x4a, 0x69, 0xb3, + 0xc1, 0x86, 0xda, 0xf0, 0xf7, 0xf, 0xd5, 0xeb, 0xdf, 0xa8, 0x64, 0x7b, + 0x73, 0xf0, 0xf6, 0xee, 0xd3, 0x96, 0xf0, 0xf1, 0x64, 0xf1, 0xfb, 0x97, + 0x80, 0xac, 0xae, 0x3f, 0x58, 0x15, 0x2b, 0x1e, 0xa4, 0xc3, 0xf6, 0xf5, + 0xa6, 0x8e, 0x41, 0xca, 0xc4, 0xdf, 0xb, 0x9a, 0xdb, 0x49, 0xd4, 0x34, + 0x91, 0xd7, 0x67, 0x87, 0x98, 0xc4, 0xda, 0x72, 0xbe, 0x69, 0x95, 0x8c, + 0x4, 0x9f, 0xb6, 0x3, 0x5e, 0x23, 0xb0, 0xc2, 0x90, 0xa2, 0x6d, 0xbb, + 0xe0, 0xc4, 0xab, 0x82, 0xe2, 0x3a, 0x7c, 0xfd, 0x51, 0x38, 0xbc, 0x8, + 0xb0, 0x8, 0xb0, 0x8, 0xf0, 0xa7, 0x9, 0x80, 0x4f, 0x23, 0x40, 0xe7, + 0x0, 0x11, 0xc4, 0x83, 0x63, 0x1b, 0x1c, 0x40, 0x3d, 0x22, 0x44, 0x9a, + 0x3, 0x44, 0x10, 0x33, 0xc5, 0x9b, 0x1d, 0x40, 0xb0, 0xcc, 0xf6, 0xd0, + 0xdd, 0xcb, 0xe, 0xf8, 0x39, 0x61, 0xa2, 0xc9, 0xf0, 0xaa, 0x68, 0x67, + 0xb1, 0x79, 0x9d, 0xfb, 0x6f, 0x8e, 0x10, 0xd1, 0x22, 0x8b, 0x7b, 0xb7, + 0x8f, 0x5f, 0xf6, 0xee, 0xbf, 0x59, 0x8, 0xb6, 0xee, 0x4e, 0x5f, 0xd9, + 0xcd, 0xe6, 0x6c, 0x4b, 0xc0, 0x11, 0xfa, 0x1d, 0xda, 0xa8, 0x97, 0xe3, + 0xd1, 0x76, 0x2b, 0x1, 0x40, 0xe9, 0xa3, 0xeb, 0xdd, 0xb6, 0xe1, 0x6a, + 0x7, 0x96, 0x6a, 0x34, 0x84, 0x46, 0xf3, 0x80, 0x60, 0x2, 0xcc, 0xc3, + 0x4, 0xa0, 0x88, 0xef, 0xef, 0xdf, 0x4e, 0x19, 0x4, 0x9f, 0x4b, 0xb, + 0x3c, 0x61, 0x7, 0x4c, 0x65, 0x7b, 0x3c, 0x1, 0x86, 0xa6, 0xa, 0xa2, + 0x7b, 0x82, 0x0, 0x53, 0x71, 0xc0, 0x72, 0x89, 0x2d, 0x7f, 0xc0, 0x22, + 0x80, 0x62, 0x9a, 0xc5, 0x2, 0x44, 0x7a, 0x27, 0x94, 0xdc, 0x19, 0x20, + 0xf2, 0x3a, 0x78, 0xd9, 0xc6, 0xfb, 0xbd, 0xfd, 0x5, 0x63, 0xfd, 0x3, + 0xe2, 0x7a, 0x67, 0x7a, 0x3a, 0x63, 0xab, 0x9, 0x5, 0xaf, 0xf3, 0xb4, + 0x4d, 0x46, 0xf8, 0x24, 0xa7, 0x66, 0x44, 0x6b, 0x5b, 0x24, 0x7e, 0xe6, + 0x17, 0x88, 0xf8, 0x81, 0x58, 0x5b, 0xa9, 0x17, 0x21, 0xba, 0x3f, 0xfe, + 0xfe, 0x8a, 0x16, 0x2f, 0xf7, 0x92, 0x46, 0xfa, 0x7, 0xb4, 0x19, 0xba, + 0x3f, 0xd9, 0xd8, 0x40, 0x83, 0xe9, 0x86, 0xbd, 0x5a, 0xc5, 0x67, 0xd4, + 0xcf, 0xcc, 0xb4, 0xb, 0x0, 0x94, 0xbf, 0xdf, 0xbe, 0x3d, 0xae, 0xd6, + 0x96, 0x7b, 0xd0, 0x36, 0x9e, 0xc0, 0xe, 0xe8, 0x1e, 0x1f, 0x62, 0xf7, + 0x58, 0xfc, 0xfe, 0x8, 0x16, 0xf0, 0x78, 0xa2, 0xaf, 0x7b, 0x0, 0xae, + 0x84, 0x70, 0xaa, 0xe6, 0xf6, 0xf6, 0x12, 0x2b, 0xe3, 0x2b, 0xae, 0x2f, + 0xea, 0x33, 0x6, 0xdb, 0x22, 0x20, 0xa, 0x91, 0xf0, 0x81, 0xbf, 0xf0, + 0xf1, 0x2, 0x70, 0xc6, 0x97, 0xd0, 0x98, 0x5b, 0xa6, 0x38, 0x25, 0x34, + 0x3e, 0xfe, 0xf5, 0x13, 0x43, 0xbf, 0x7f, 0xbd, 0x3f, 0xe0, 0x1f, 0x5f, + 0x4e, 0x4b, 0x19, 0x56, 0xcb, 0xb5, 0x20, 0x0, 0x0, 0x0, 0x0, 0x49, + 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82}; +const unsigned short sGlyphWidths[256] = { + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 4, 3, 5, 7, 7, 12, + 9, 2, 4, 4, 5, 8, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 4, 4, 8, 8, 8, 7, 13, 9, 9, 9, 9, 9, 8, 10, 9, 3, 6, 9, + 7, 11, 9, 10, 9, 10, 9, 9, 7, 9, 9, 13, 7, 9, 7, 4, 4, 4, 5, + 7, 4, 7, 7, 7, 7, 7, 3, 7, 7, 3, 3, 7, 3, 11, 7, 7, 7, 7, + 4, 7, 4, 7, 5, 9, 7, 7, 7, 4, 3, 4, 8, 10, 7, 10, 3, 7, 4, + 13, 7, 7, 4, 14, 9, 4, 13, 10, 7, 10, 10, 3, 3, 4, 4, 5, 7, 13, + 4, 13, 7, 4, 12, 10, 7, 9, 4, 3, 7, 7, 7, 7, 3, 7, 4, 10, 4, + 7, 8, 4, 10, 7, 5, 7, 4, 4, 4, 7, 7, 4, 4, 4, 5, 7, 11, 11, + 11, 8, 9, 9, 9, 9, 9, 9, 13, 9, 9, 9, 9, 9, 3, 3, 3, 3, 9, + 9, 10, 10, 10, 10, 10, 8, 10, 9, 9, 9, 9, 9, 9, 9, 7, 7, 7, 7, + 7, 7, 12, 7, 7, 7, 7, 7, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7}; +} // namespace normal_font + +const FontBitmapInfo sDefaultCompositorFont = { + mozilla::Nothing(), + mozilla::Some(&normal_font::sGlyphWidths[0]), + 256, + 256, + 16, + 16, + 0, + normal_font::sFontPNG, + sizeof(normal_font::sFontPNG)}; + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/FrameUniformityData.cpp b/gfx/layers/composite/FrameUniformityData.cpp new file mode 100644 index 0000000000..397ec0e1dc --- /dev/null +++ b/gfx/layers/composite/FrameUniformityData.cpp @@ -0,0 +1,145 @@ +/* -*- 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 "FrameUniformityData.h" + +#include <map> + +#include "Units.h" +#include "gfxPoint.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/APZTestDataBinding.h" +#include "mozilla/dom/ToJSValue.h" +#include "nsTArray.h" + +namespace mozilla { +namespace layers { + +using namespace gfx; + +Point LayerTransforms::GetAverage() { + MOZ_ASSERT(!mTransforms.IsEmpty()); + + Point current = mTransforms[0]; + Point average; + size_t length = mTransforms.Length(); + + for (size_t i = 1; i < length; i++) { + Point nextTransform = mTransforms[i]; + Point movement = nextTransform - current; + average += Point(std::fabs(movement.x), std::fabs(movement.y)); + current = nextTransform; + } + + average = average / (float)length; + return average; +} + +Point LayerTransforms::GetStdDev() { + Point average = GetAverage(); + Point stdDev; + Point current = mTransforms[0]; + + for (size_t i = 1; i < mTransforms.Length(); i++) { + Point next = mTransforms[i]; + Point move = next - current; + move.x = fabs(move.x); + move.y = fabs(move.y); + + Point diff = move - average; + diff.x = diff.x * diff.x; + diff.y = diff.y * diff.y; + stdDev += diff; + + current = next; + } + + stdDev = stdDev / mTransforms.Length(); + stdDev.x = sqrt(stdDev.x); + stdDev.y = sqrt(stdDev.y); + return stdDev; +} + +bool LayerTransforms::Sanitize() { + // Remove leading and trailing zeros to isolate the composites that actually + // changed the transform + for (size_t i = 1; i < mTransforms.Length(); i++) { + if (mTransforms[i] != mTransforms[i - 1]) { + mTransforms.RemoveElementsAt(0, i - 1); + break; + } + } + for (size_t i = mTransforms.Length() - 1; i > 0; i--) { + if (mTransforms[i - 1] != mTransforms[i]) { + mTransforms.SetLength(i + 1); + break; + } + } + return !mTransforms.IsEmpty(); +} + +LayerTransformRecorder::~LayerTransformRecorder() { Reset(); } + +void LayerTransformRecorder::RecordTransform(Layer* aLayer, + const Point& aTransform) { + LayerTransforms* layerTransforms = GetLayerTransforms((uintptr_t)aLayer); + layerTransforms->mTransforms.AppendElement(aTransform); +} + +void LayerTransformRecorder::EndTest(FrameUniformityData* aOutData) { + for (const auto& [layer, transforms] : mFrameTransforms) { + (void)transforms; // suppress unused variable warning + + float uniformity = CalculateFrameUniformity(layer); + + std::pair<uintptr_t, float> result(layer, uniformity); + aOutData->mUniformities.insert(result); + } + + Reset(); +} + +LayerTransforms* LayerTransformRecorder::GetLayerTransforms(uintptr_t aLayer) { + auto [iter, inserted] = + mFrameTransforms.insert(FrameTransformMap::value_type{aLayer, nullptr}); + if (inserted) { + iter->second = MakeUnique<LayerTransforms>(); + } + return iter->second.get(); +} + +void LayerTransformRecorder::Reset() { mFrameTransforms.clear(); } + +float LayerTransformRecorder::CalculateFrameUniformity(uintptr_t aLayer) { + LayerTransforms* layerTransform = GetLayerTransforms(aLayer); + float yUniformity = -1; + if (layerTransform->Sanitize()) { + Point stdDev = layerTransform->GetStdDev(); + yUniformity = stdDev.y; + } + return yUniformity; +} + +bool FrameUniformityData::ToJS(JS::MutableHandleValue aOutValue, + JSContext* aContext) { + dom::FrameUniformityResults results; + dom::Sequence<dom::FrameUniformity>& layers = + results.mLayerUniformities.Construct(); + + for (const auto& [layerAddr, uniformity] : mUniformities) { + // FIXME: Make this infallible after bug 968520 is done. + MOZ_ALWAYS_TRUE(layers.AppendElement(fallible)); + dom::FrameUniformity& entry = layers.LastElement(); + + entry.mLayerAddress.Construct() = layerAddr; + entry.mFrameUniformity.Construct() = uniformity; + } + + return dom::ToJSValue(aContext, results, aOutValue); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/FrameUniformityData.h b/gfx/layers/composite/FrameUniformityData.h new file mode 100644 index 0000000000..8cb639e60c --- /dev/null +++ b/gfx/layers/composite/FrameUniformityData.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_layers_FrameUniformityData_h_ +#define mozilla_layers_FrameUniformityData_h_ + +#include "ipc/IPCMessageUtils.h" +#include "js/TypeDecls.h" +#include "ipc/IPCMessageUtilsSpecializations.h" +#include "mozilla/RefPtr.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/gfx/Point.h" +#include "nsTArray.h" + +namespace mozilla { +namespace layers { +class Layer; + +class FrameUniformityData { + friend struct IPC::ParamTraits<FrameUniformityData>; + + public: + bool ToJS(JS::MutableHandleValue aOutValue, JSContext* aContext); + // Contains the calculated frame uniformities + std::map<uintptr_t, float> mUniformities; +}; + +struct LayerTransforms { + LayerTransforms() = default; + + gfx::Point GetAverage(); + gfx::Point GetStdDev(); + bool Sanitize(); + + // 60 fps * 5 seconds worth of data + AutoTArray<gfx::Point, 300> mTransforms; +}; + +class LayerTransformRecorder { + public: + LayerTransformRecorder() = default; + ~LayerTransformRecorder(); + + void RecordTransform(Layer* aLayer, const gfx::Point& aTransform); + void Reset(); + void EndTest(FrameUniformityData* aOutData); + + private: + float CalculateFrameUniformity(uintptr_t aLayer); + LayerTransforms* GetLayerTransforms(uintptr_t aLayer); + using FrameTransformMap = + std::map<uintptr_t, mozilla::UniquePtr<LayerTransforms>>; + FrameTransformMap mFrameTransforms; +}; + +} // namespace layers +} // namespace mozilla + +namespace IPC { +template <> +struct ParamTraits<mozilla::layers::FrameUniformityData> { + typedef mozilla::layers::FrameUniformityData paramType; + + static void Write(Message* aMsg, const paramType& aParam) { + WriteParam(aMsg, aParam.mUniformities); + } + + static bool Read(const Message* aMsg, PickleIterator* aIter, + paramType* aResult) { + return ParamTraitsStd<std::map<uintptr_t, float>>::Read( + aMsg, aIter, &aResult->mUniformities); + } +}; + +} // namespace IPC + +#endif // mozilla_layers_FrameUniformityData_h_ diff --git a/gfx/layers/composite/GPUVideoTextureHost.cpp b/gfx/layers/composite/GPUVideoTextureHost.cpp new file mode 100644 index 0000000000..ed6be1972d --- /dev/null +++ b/gfx/layers/composite/GPUVideoTextureHost.cpp @@ -0,0 +1,295 @@ +/* -*- 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 "GPUVideoTextureHost.h" + +#include "ImageContainer.h" +#include "mozilla/RemoteDecoderManagerParent.h" +#include "mozilla/layers/ImageBridgeParent.h" +#include "mozilla/layers/VideoBridgeParent.h" +#include "mozilla/webrender/RenderTextureHostWrapper.h" +#include "mozilla/webrender/RenderThread.h" + +namespace mozilla { +namespace layers { + +GPUVideoTextureHost::GPUVideoTextureHost( + TextureFlags aFlags, const SurfaceDescriptorGPUVideo& aDescriptor) + : TextureHost(aFlags), mDescriptor(aDescriptor) { + MOZ_COUNT_CTOR(GPUVideoTextureHost); +} + +GPUVideoTextureHost::~GPUVideoTextureHost() { + MOZ_COUNT_DTOR(GPUVideoTextureHost); +} + +GPUVideoTextureHost* GPUVideoTextureHost::CreateFromDescriptor( + TextureFlags aFlags, const SurfaceDescriptorGPUVideo& aDescriptor) { + return new GPUVideoTextureHost(aFlags, aDescriptor); +} + +TextureHost* GPUVideoTextureHost::EnsureWrappedTextureHost() { + if (mWrappedTextureHost) { + return mWrappedTextureHost; + } + + const auto& sd = + static_cast<const SurfaceDescriptorRemoteDecoder&>(mDescriptor); + VideoBridgeParent* parent = VideoBridgeParent::GetSingleton(sd.source()); + if (!parent) { + // The VideoBridge went away. This can happen if the RDD process + // crashes. + return nullptr; + } + mWrappedTextureHost = parent->LookupTexture(sd.handle()); + + if (!mWrappedTextureHost) { + // The TextureHost hasn't been registered yet. This is due to a race + // between the ImageBridge (content) and the VideoBridge (RDD) and the + // ImageBridge won. See bug + // https://bugzilla.mozilla.org/show_bug.cgi?id=1630733#c14 for more + // details. + return nullptr; + } + + if (mWrappedTextureHost->AsBufferTextureHost()) { + // TODO(miko): This code path is taken when WebRenderTextureHost wraps + // GPUVideoTextureHost, which wraps BufferTextureHost. + // Because this creates additional copies of the texture data, we should not + // do this. + mWrappedTextureHost->AsBufferTextureHost()->DisableExternalTextures(); + } + + if (mExternalImageId.isSome()) { + // External image id is allocated by mWrappedTextureHost. + mWrappedTextureHost->EnsureRenderTexture(Nothing()); + MOZ_ASSERT(mWrappedTextureHost->mExternalImageId.isSome()); + auto wrappedId = mWrappedTextureHost->mExternalImageId.ref(); + + RefPtr<wr::RenderTextureHost> texture = + new wr::RenderTextureHostWrapper(wrappedId); + wr::RenderThread::Get()->RegisterExternalImage( + wr::AsUint64(mExternalImageId.ref()), texture.forget()); + } + + if (mPendingSourceProvider) { + RefPtr<TextureSourceProvider> provider = mPendingSourceProvider.forget(); + mWrappedTextureHost->SetTextureSourceProvider(provider); + } + if (mPendingUpdatedInternal) { + mWrappedTextureHost->UpdatedInternal(mPendingIntRegion.ptrOr(nullptr)); + mPendingIntRegion.reset(); + mPendingUpdatedInternal = false; + } + if (mPendingPrepareTextureSource) { + mWrappedTextureHost->PrepareTextureSource(*mPendingPrepareTextureSource); + mPendingPrepareTextureSource.reset(); + } + + return mWrappedTextureHost; +} + +bool GPUVideoTextureHost::IsValid() { return !!EnsureWrappedTextureHost(); } + +bool GPUVideoTextureHost::Lock() { + if (!EnsureWrappedTextureHost()) { + return false; + } + return EnsureWrappedTextureHost()->Lock(); +} + +void GPUVideoTextureHost::Unlock() { + if (!EnsureWrappedTextureHost()) { + return; + } + EnsureWrappedTextureHost()->Unlock(); +} + +void GPUVideoTextureHost::PrepareTextureSource( + CompositableTextureSourceRef& aTexture) { + if (!EnsureWrappedTextureHost()) { + mPendingPrepareTextureSource = Some(aTexture); + return; + } + EnsureWrappedTextureHost()->PrepareTextureSource(aTexture); +} + +bool GPUVideoTextureHost::BindTextureSource( + CompositableTextureSourceRef& aTexture) { + MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet"); + if (!EnsureWrappedTextureHost()) { + return false; + } + return EnsureWrappedTextureHost()->BindTextureSource(aTexture); +} + +bool GPUVideoTextureHost::AcquireTextureSource( + CompositableTextureSourceRef& aTexture) { + MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet"); + if (!EnsureWrappedTextureHost()) { + return false; + } + return EnsureWrappedTextureHost()->AcquireTextureSource(aTexture); +} + +void GPUVideoTextureHost::SetTextureSourceProvider( + TextureSourceProvider* aProvider) { + if (!EnsureWrappedTextureHost()) { + mPendingSourceProvider = aProvider; + return; + } + EnsureWrappedTextureHost()->SetTextureSourceProvider(aProvider); +} + +gfx::YUVColorSpace GPUVideoTextureHost::GetYUVColorSpace() const { + MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet"); + if (!mWrappedTextureHost) { + return gfx::YUVColorSpace::UNKNOWN; + } + return mWrappedTextureHost->GetYUVColorSpace(); +} + +gfx::ColorDepth GPUVideoTextureHost::GetColorDepth() const { + MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet"); + if (!mWrappedTextureHost) { + return TextureHost::GetColorDepth(); + } + return mWrappedTextureHost->GetColorDepth(); +} + +gfx::ColorRange GPUVideoTextureHost::GetColorRange() const { + MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet"); + if (!mWrappedTextureHost) { + return TextureHost::GetColorRange(); + } + return mWrappedTextureHost->GetColorRange(); +} + +gfx::IntSize GPUVideoTextureHost::GetSize() const { + MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet"); + if (!mWrappedTextureHost) { + return gfx::IntSize(); + } + return mWrappedTextureHost->GetSize(); +} + +gfx::SurfaceFormat GPUVideoTextureHost::GetFormat() const { + MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet"); + if (!mWrappedTextureHost) { + return gfx::SurfaceFormat::UNKNOWN; + } + return mWrappedTextureHost->GetFormat(); +} + +bool GPUVideoTextureHost::HasIntermediateBuffer() const { + MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet"); + if (!mWrappedTextureHost) { + return false; + } + return mWrappedTextureHost->HasIntermediateBuffer(); +} + +void GPUVideoTextureHost::UpdatedInternal(const nsIntRegion* Region) { + if (!EnsureWrappedTextureHost()) { + mPendingUpdatedInternal = true; + if (Region) { + mPendingIntRegion = Some(*Region); + } else { + mPendingIntRegion.reset(); + } + return; + } + EnsureWrappedTextureHost()->UpdatedInternal(Region); +} + +void GPUVideoTextureHost::CreateRenderTexture( + const wr::ExternalImageId& aExternalImageId) { + MOZ_ASSERT(mExternalImageId.isSome()); + + // When mWrappedTextureHost already exist, call CreateRenderTexture() here. + // In other cases, EnsureWrappedTextureHost() handles CreateRenderTexture(). + + if (mWrappedTextureHost) { + // External image id is allocated by mWrappedTextureHost. + mWrappedTextureHost->EnsureRenderTexture(Nothing()); + MOZ_ASSERT(mWrappedTextureHost->mExternalImageId.isSome()); + auto wrappedId = mWrappedTextureHost->mExternalImageId.ref(); + + RefPtr<wr::RenderTextureHost> texture = + new wr::RenderTextureHostWrapper(wrappedId); + wr::RenderThread::Get()->RegisterExternalImage( + wr::AsUint64(mExternalImageId.ref()), texture.forget()); + return; + } + + EnsureWrappedTextureHost(); +} + +void GPUVideoTextureHost::MaybeDestroyRenderTexture() { + if (mExternalImageId.isNothing() || !mWrappedTextureHost) { + // RenderTextureHost was not created + return; + } + // When GPUVideoTextureHost created RenderTextureHost, delete it here. + TextureHost::DestroyRenderTexture(mExternalImageId.ref()); +} + +uint32_t GPUVideoTextureHost::NumSubTextures() { + if (!EnsureWrappedTextureHost()) { + return 0; + } + return EnsureWrappedTextureHost()->NumSubTextures(); +} + +void GPUVideoTextureHost::PushResourceUpdates( + wr::TransactionBuilder& aResources, ResourceUpdateOp aOp, + const Range<wr::ImageKey>& aImageKeys, const wr::ExternalImageId& aExtID) { + MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet"); + if (!EnsureWrappedTextureHost()) { + return; + } + EnsureWrappedTextureHost()->PushResourceUpdates(aResources, aOp, aImageKeys, + aExtID); +} + +void GPUVideoTextureHost::PushDisplayItems( + wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, wr::ImageRendering aFilter, + const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) { + MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet"); + MOZ_ASSERT(aImageKeys.length() > 0); + if (!EnsureWrappedTextureHost()) { + return; + } + + EnsureWrappedTextureHost()->PushDisplayItems(aBuilder, aBounds, aClip, + aFilter, aImageKeys, aFlags); +} + +bool GPUVideoTextureHost::SupportsExternalCompositing() { + if (!EnsureWrappedTextureHost()) { + return false; + } + return EnsureWrappedTextureHost()->SupportsExternalCompositing(); +} + +void GPUVideoTextureHost::UnbindTextureSource() { + if (EnsureWrappedTextureHost()) { + EnsureWrappedTextureHost()->UnbindTextureSource(); + } + // Handle read unlock + TextureHost::UnbindTextureSource(); +} + +void GPUVideoTextureHost::NotifyNotUsed() { + if (EnsureWrappedTextureHost()) { + EnsureWrappedTextureHost()->NotifyNotUsed(); + } + TextureHost::NotifyNotUsed(); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/GPUVideoTextureHost.h b/gfx/layers/composite/GPUVideoTextureHost.h new file mode 100644 index 0000000000..1346d61ccd --- /dev/null +++ b/gfx/layers/composite/GPUVideoTextureHost.h @@ -0,0 +1,98 @@ +/* -*- 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_GPUVIDEOTEXTUREHOST_H +#define MOZILLA_GFX_GPUVIDEOTEXTUREHOST_H + +#include "mozilla/layers/TextureHost.h" + +namespace mozilla { +namespace layers { + +class GPUVideoTextureHost : public TextureHost { + public: + static GPUVideoTextureHost* CreateFromDescriptor( + TextureFlags aFlags, const SurfaceDescriptorGPUVideo& aDescriptor); + + virtual ~GPUVideoTextureHost(); + + void DeallocateDeviceData() override {} + + virtual void SetTextureSourceProvider( + TextureSourceProvider* aProvider) override; + + bool Lock() override; + + void Unlock() override; + + gfx::SurfaceFormat GetFormat() const override; + + void PrepareTextureSource(CompositableTextureSourceRef& aTexture) override; + + bool BindTextureSource(CompositableTextureSourceRef& aTexture) override; + bool AcquireTextureSource(CompositableTextureSourceRef& aTexture) override; + + already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override { + return nullptr; // XXX - implement this (for MOZ_DUMP_PAINTING) + } + + gfx::YUVColorSpace GetYUVColorSpace() const override; + gfx::ColorDepth GetColorDepth() const override; + gfx::ColorRange GetColorRange() const override; + + gfx::IntSize GetSize() const override; + + bool IsValid() override; + +#ifdef MOZ_LAYERS_HAVE_LOG + const char* Name() override { return "GPUVideoTextureHost"; } +#endif + + bool HasIntermediateBuffer() const override; + + void CreateRenderTexture( + const wr::ExternalImageId& aExternalImageId) override; + + void MaybeDestroyRenderTexture() override; + + uint32_t NumSubTextures() override; + + void PushResourceUpdates(wr::TransactionBuilder& aResources, + ResourceUpdateOp aOp, + const Range<wr::ImageKey>& aImageKeys, + const wr::ExternalImageId& aExtID) override; + + void PushDisplayItems(wr::DisplayListBuilder& aBuilder, + const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, wr::ImageRendering aFilter, + const Range<wr::ImageKey>& aImageKeys, + PushDisplayItemFlagSet aFlags) override; + + bool SupportsExternalCompositing() override; + + void UnbindTextureSource() override; + void NotifyNotUsed() override; + + protected: + GPUVideoTextureHost(TextureFlags aFlags, + const SurfaceDescriptorGPUVideo& aDescriptor); + + TextureHost* EnsureWrappedTextureHost(); + + void UpdatedInternal(const nsIntRegion* Region) override; + + RefPtr<TextureHost> mWrappedTextureHost; + RefPtr<TextureSourceProvider> mPendingSourceProvider; + bool mPendingUpdatedInternal = false; + Maybe<nsIntRegion> mPendingIntRegion; + Maybe<CompositableTextureSourceRef> mPendingPrepareTextureSource; + SurfaceDescriptorGPUVideo mDescriptor; +}; + +} // namespace layers +} // namespace mozilla + +#endif // MOZILLA_GFX_GPUVIDEOTEXTUREHOST_H diff --git a/gfx/layers/composite/ImageComposite.cpp b/gfx/layers/composite/ImageComposite.cpp new file mode 100644 index 0000000000..20e4ee2b5c --- /dev/null +++ b/gfx/layers/composite/ImageComposite.cpp @@ -0,0 +1,385 @@ +/* -*- 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 "ImageComposite.h" + +#include <inttypes.h> + +#include "GeckoProfiler.h" +#include "gfxPlatform.h" + +namespace mozilla { + +using namespace gfx; + +namespace layers { + +/* static */ const float ImageComposite::BIAS_TIME_MS = 1.0f; + +ImageComposite::ImageComposite() = default; + +ImageComposite::~ImageComposite() = default; + +TimeStamp ImageComposite::GetBiasedTime(const TimeStamp& aInput) const { + switch (mBias) { + case ImageComposite::BIAS_NEGATIVE: + return aInput - TimeDuration::FromMilliseconds(BIAS_TIME_MS); + case ImageComposite::BIAS_POSITIVE: + return aInput + TimeDuration::FromMilliseconds(BIAS_TIME_MS); + default: + return aInput; + } +} + +void ImageComposite::UpdateBias(size_t aImageIndex, bool aFrameChanged) { + MOZ_ASSERT(aImageIndex < ImagesCount()); + + TimeStamp compositionTime = GetCompositionTime(); + TimeStamp compositedImageTime = mImages[aImageIndex].mTimeStamp; + TimeStamp nextImageTime = aImageIndex + 1 < ImagesCount() + ? mImages[aImageIndex + 1].mTimeStamp + : TimeStamp(); + +#if MOZ_GECKO_PROFILER + if (profiler_can_accept_markers() && compositedImageTime && nextImageTime) { + TimeDuration offsetCurrent = compositedImageTime - compositionTime; + TimeDuration offsetNext = nextImageTime - compositionTime; + nsPrintfCString str("current %.2lfms, next %.2lfms", + offsetCurrent.ToMilliseconds(), + offsetNext.ToMilliseconds()); + PROFILER_MARKER_TEXT("Video frame offsets", GRAPHICS, {}, str); + } +#endif + + if (compositedImageTime.IsNull()) { + mBias = ImageComposite::BIAS_NONE; + return; + } + TimeDuration threshold = TimeDuration::FromMilliseconds(1.5); + if (compositionTime - compositedImageTime < threshold && + compositionTime - compositedImageTime > -threshold) { + // The chosen frame's time is very close to the composition time (probably + // just before the current composition time, but due to previously set + // negative bias, it could be just after the current composition time too). + // If the inter-frame time is almost exactly equal to (a multiple of) + // the inter-composition time, then we're in a dangerous situation because + // jitter might cause frames to fall one side or the other of the + // composition times, causing many frames to be skipped or duplicated. + // Try to prevent that by adding a negative bias to the frame times during + // the next composite; that should ensure the next frame's time is treated + // as falling just before a composite time. + mBias = ImageComposite::BIAS_NEGATIVE; + return; + } + if (!nextImageTime.IsNull() && nextImageTime - compositionTime < threshold && + nextImageTime - compositionTime > -threshold) { + // The next frame's time is very close to our composition time (probably + // just after the current composition time, but due to previously set + // positive bias, it could be just before the current composition time too). + // We're in a dangerous situation because jitter might cause frames to + // fall one side or the other of the composition times, causing many frames + // to be skipped or duplicated. + // Specifically, the next composite is at risk of picking the "next + 1" + // frame rather than the "next" frame, which would cause the "next" frame to + // be skipped. Try to prevent that by adding a positive bias to the frame + // times during the next composite; if the inter-frame time is almost + // exactly equal to the inter-composition time, that should ensure that the + // next + 1 frame falls just *after* the next composition time, and the next + // composite should then pick the next frame rather than the next + 1 frame. + mBias = ImageComposite::BIAS_POSITIVE; + return; + } + if (aFrameChanged) { + // The current and next video frames are a sufficient distance from the + // composition time and we can reliably pick the right frame without bias. + // Reset the bias. + // We only do this when the frame changed. Otherwise, when playing a 30fps + // video on a 60fps display, we'd keep resetting the bias during the "middle + // frames". + mBias = ImageComposite::BIAS_NONE; + } +} + +int ImageComposite::ChooseImageIndex() { + // ChooseImageIndex is called for all images in the layer when it is visible. + // Change to this behaviour would break dropped frames counting calculation: + // We rely on this assumption to determine if during successive runs an + // image is returned that isn't the one following immediately the previous one + if (mImages.IsEmpty()) { + return -1; + } + + TimeStamp compositionTime = GetCompositionTime(); + auto compositionOpportunityId = GetCompositionOpportunityId(); + if (compositionTime && + compositionOpportunityId != mLastChooseImageIndexComposition) { + // We are inside a composition, in the first call to ChooseImageIndex during + // this composition. + // Find the newest frame whose biased timestamp is at or before + // `compositionTime`. + uint32_t imageIndex = 0; + while (imageIndex + 1 < mImages.Length() && + mImages[imageIndex + 1].mTextureHost->IsValid() && + GetBiasedTime(mImages[imageIndex + 1].mTimeStamp) <= + compositionTime) { + ++imageIndex; + } + + if (!mImages[imageIndex].mTextureHost->IsValid()) { + // Still not ready to be shown. + return -1; + } + + bool wasVisibleAtPreviousComposition = + compositionOpportunityId == mLastChooseImageIndexComposition.Next(); + + bool frameChanged = + UpdateCompositedFrame(imageIndex, wasVisibleAtPreviousComposition); + UpdateBias(imageIndex, frameChanged); + + mLastChooseImageIndexComposition = compositionOpportunityId; + + return imageIndex; + } + + // We've been called before during this composition, or we're not in a + // composition. Just return the last image we picked (if it's one of the + // current images). + for (uint32_t i = 0; i < mImages.Length(); ++i) { + if (mImages[i].mFrameID == mLastFrameID && + mImages[i].mProducerID == mLastProducerID) { + return i; + } + } + + return 0; +} + +const ImageComposite::TimedImage* ImageComposite::ChooseImage() { + int index = ChooseImageIndex(); + return index >= 0 ? &mImages[index] : nullptr; +} + +void ImageComposite::RemoveImagesWithTextureHost(TextureHost* aTexture) { + for (int32_t i = mImages.Length() - 1; i >= 0; --i) { + if (mImages[i].mTextureHost == aTexture) { + aTexture->UnbindTextureSource(); + mImages.RemoveElementAt(i); + } + } +} + +void ImageComposite::ClearImages() { mImages.Clear(); } + +void ImageComposite::SetImages(nsTArray<TimedImage>&& aNewImages) { + if (!aNewImages.IsEmpty()) { + DetectTimeStampJitter(&aNewImages[0]); + + // Frames older than the first frame in aNewImages that we haven't shown yet + // will never be shown. + CountSkippedFrames(&aNewImages[0]); + +#if MOZ_GECKO_PROFILER + if (profiler_can_accept_markers()) { + int len = aNewImages.Length(); + const auto& first = aNewImages[0]; + const auto& last = aNewImages.LastElement(); + nsPrintfCString str("%d %s, frameID %" PRId32 " (prod %" PRId32 + ") to frameID %" PRId32 " (prod %" PRId32 ")", + len, len == 1 ? "image" : "images", first.mFrameID, + first.mProducerID, last.mFrameID, last.mProducerID); + PROFILER_MARKER_TEXT("ImageComposite::SetImages", GRAPHICS, {}, str); + } +#endif + } + mImages = std::move(aNewImages); +} + +// Returns whether the frame changed. +bool ImageComposite::UpdateCompositedFrame( + int aImageIndex, bool aWasVisibleAtPreviousComposition) { + MOZ_RELEASE_ASSERT(aImageIndex >= 0); + MOZ_RELEASE_ASSERT(aImageIndex < static_cast<int>(mImages.Length())); + const TimedImage& image = mImages[aImageIndex]; + + auto compositionOpportunityId = GetCompositionOpportunityId(); + TimeStamp compositionTime = GetCompositionTime(); + MOZ_RELEASE_ASSERT(compositionTime, + "Should only be called during a composition"); + +#if MOZ_GECKO_PROFILER + nsCString descr; + if (profiler_can_accept_markers()) { + nsCString relativeTimeString; + if (image.mTimeStamp) { + relativeTimeString.AppendPrintf( + " [relative timestamp %.1lfms]", + (image.mTimeStamp - compositionTime).ToMilliseconds()); + } + int remainingImages = mImages.Length() - 1 - aImageIndex; + static const char* kBiasStrings[] = {"NONE", "NEGATIVE", "POSITIVE"}; + descr.AppendPrintf( + "frameID %" PRId32 " (producerID %" PRId32 ") [composite %" PRIu64 + "] [bias %s] [%d remaining %s]%s", + image.mFrameID, image.mProducerID, compositionOpportunityId.mId, + kBiasStrings[mBias], remainingImages, + remainingImages == 1 ? "image" : "images", relativeTimeString.get()); + if (mLastProducerID != image.mProducerID) { + descr.AppendPrintf(", previous producerID: %" PRId32, mLastProducerID); + } else if (mLastFrameID != image.mFrameID) { + descr.AppendPrintf(", previous frameID: %" PRId32, mLastFrameID); + } else { + descr.AppendLiteral(", no change"); + } + } + PROFILER_MARKER_TEXT("UpdateCompositedFrame", GRAPHICS, {}, descr); +#endif + + if (mLastFrameID == image.mFrameID && mLastProducerID == image.mProducerID) { + // The frame didn't change. + return false; + } + + CountSkippedFrames(&image); + + int32_t dropped = mSkippedFramesSinceLastComposite; + mSkippedFramesSinceLastComposite = 0; + + if (!aWasVisibleAtPreviousComposition) { + // This video was not part of the on-screen scene during the previous + // composition opportunity, for example it may have been scrolled off-screen + // or in a background tab, or compositing might have been paused. + // Ignore any skipped frames and don't count them as dropped. + dropped = 0; + } + + if (dropped > 0) { + mDroppedFrames += dropped; +#if MOZ_GECKO_PROFILER + if (profiler_can_accept_markers()) { + const char* frameOrFrames = dropped == 1 ? "frame" : "frames"; + nsPrintfCString text("%" PRId32 " %s dropped: %" PRId32 " -> %" PRId32 + " (producer %" PRId32 ")", + dropped, frameOrFrames, mLastFrameID, image.mFrameID, + mLastProducerID); + PROFILER_MARKER_TEXT("Video frames dropped", GRAPHICS, {}, text); + } +#endif + } + + mLastFrameID = image.mFrameID; + mLastProducerID = image.mProducerID; + mLastFrameUpdateComposition = compositionOpportunityId; + + return true; +} + +void ImageComposite::OnFinishRendering(int aImageIndex, + const TimedImage* aImage, + base::ProcessId aProcessId, + const CompositableHandle& aHandle) { + if (mLastFrameUpdateComposition != GetCompositionOpportunityId()) { + // The frame did not change in this composition. + return; + } + + if (aHandle) { + ImageCompositeNotificationInfo info; + info.mImageBridgeProcessId = aProcessId; + info.mNotification = ImageCompositeNotification( + aHandle, aImage->mTimeStamp, GetCompositionTime(), mLastFrameID, + mLastProducerID); + AppendImageCompositeNotification(info); + } +} + +const ImageComposite::TimedImage* ImageComposite::GetImage( + size_t aIndex) const { + if (aIndex >= mImages.Length()) { + return nullptr; + } + return &mImages[aIndex]; +} + +void ImageComposite::CountSkippedFrames(const TimedImage* aImage) { + if (aImage->mProducerID != mLastProducerID) { + // Switched producers. + return; + } + + if (mImages.IsEmpty() || aImage->mFrameID <= mLastFrameID + 1) { + // No frames were skipped. + return; + } + + uint32_t targetFrameRate = gfxPlatform::TargetFrameRate(); + if (targetFrameRate == 0) { + // Can't know whether we could have reasonably displayed all video frames. + return; + } + + double targetFrameDurationMS = 1000.0 / targetFrameRate; + + // Count how many images in mImages were skipped between mLastFrameID and + // aImage.mFrameID. Only count frames for which we can estimate a duration by + // looking at the next frame's timestamp, and only if the video frame rate is + // no faster than the target frame rate. + int32_t skipped = 0; + for (size_t i = 0; i + 1 < mImages.Length(); i++) { + const auto& img = mImages[i]; + if (img.mProducerID != aImage->mProducerID || + img.mFrameID <= mLastFrameID || img.mFrameID >= aImage->mFrameID) { + continue; + } + + // We skipped img! Estimate img's time duration. + const auto& next = mImages[i + 1]; + if (next.mProducerID != aImage->mProducerID) { + continue; + } + + MOZ_ASSERT(next.mFrameID > img.mFrameID); + TimeDuration duration = next.mTimeStamp - img.mTimeStamp; + if (floor(duration.ToMilliseconds()) >= floor(targetFrameDurationMS)) { + // Count the frame. + skipped++; + } + } + + mSkippedFramesSinceLastComposite += skipped; +} + +void ImageComposite::DetectTimeStampJitter(const TimedImage* aNewImage) { +#if MOZ_GECKO_PROFILER + if (!profiler_can_accept_markers() || aNewImage->mTimeStamp.IsNull()) { + return; + } + + // Find aNewImage in mImages and compute its timestamp delta, if found. + // Ideally, a given video frame should never change its timestamp (jitter + // should be zero). However, we re-adjust video frame timestamps based on the + // audio clock. If the audio clock drifts compared to the system clock, or if + // there are bugs or inaccuracies in the computation of these timestamps, + // jitter will be non-zero. + Maybe<TimeDuration> jitter; + for (const auto& img : mImages) { + if (img.mProducerID == aNewImage->mProducerID && + img.mFrameID == aNewImage->mFrameID) { + if (!img.mTimeStamp.IsNull()) { + jitter = Some(aNewImage->mTimeStamp - img.mTimeStamp); + } + break; + } + } + if (jitter) { + nsPrintfCString text("%.2lfms", jitter->ToMilliseconds()); + PROFILER_MARKER_TEXT("VideoFrameTimeStampJitter", GRAPHICS, {}, text); + } +#endif +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ImageComposite.h b/gfx/layers/composite/ImageComposite.h new file mode 100644 index 0000000000..05e812c8b3 --- /dev/null +++ b/gfx/layers/composite/ImageComposite.h @@ -0,0 +1,139 @@ +/* -*- 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_IMAGECOMPOSITE_H +#define MOZILLA_GFX_IMAGECOMPOSITE_H + +#include "CompositableHost.h" // for CompositableTextureHostRef +#include "mozilla/gfx/2D.h" +#include "mozilla/TimeStamp.h" // for TimeStamp +#include "nsTArray.h" + +namespace mozilla { +namespace layers { + +/** + * Implements Image selection logic. + */ +class ImageComposite { + public: + static const float BIAS_TIME_MS; + + explicit ImageComposite(); + virtual ~ImageComposite(); + + int32_t GetFrameID() { + const TimedImage* img = ChooseImage(); + return img ? img->mFrameID : -1; + } + + int32_t GetProducerID() { + const TimedImage* img = ChooseImage(); + return img ? img->mProducerID : -1; + } + + int32_t GetLastFrameID() const { return mLastFrameID; } + int32_t GetLastProducerID() const { return mLastProducerID; } + uint32_t GetDroppedFramesAndReset() { + uint32_t dropped = mDroppedFrames; + mDroppedFrames = 0; + return dropped; + } + + enum Bias { + // Don't apply bias to frame times + BIAS_NONE, + // Apply a negative bias to frame times to keep them before the vsync time + BIAS_NEGATIVE, + // Apply a positive bias to frame times to keep them after the vsync time + BIAS_POSITIVE, + }; + + protected: + virtual TimeStamp GetCompositionTime() const = 0; + virtual CompositionOpportunityId GetCompositionOpportunityId() const = 0; + virtual void AppendImageCompositeNotification( + const ImageCompositeNotificationInfo& aInfo) const = 0; + + struct TimedImage { + CompositableTextureHostRef mTextureHost; + TimeStamp mTimeStamp; + gfx::IntRect mPictureRect; + int32_t mFrameID; + int32_t mProducerID; + }; + + /** + * ChooseImage is guaranteed to return the same TimedImage every time it's + * called during the same composition, up to the end of Composite() --- + * it depends only on mImages, mCompositor->GetCompositionTime(), and mBias. + * mBias is updated at the end of Composite(). + */ + const TimedImage* ChooseImage(); + int ChooseImageIndex(); + const TimedImage* GetImage(size_t aIndex) const; + size_t ImagesCount() const { return mImages.Length(); } + const nsTArray<TimedImage>& Images() const { return mImages; } + + void RemoveImagesWithTextureHost(TextureHost* aTexture); + void ClearImages(); + void SetImages(nsTArray<TimedImage>&& aNewImages); + + protected: + // Send ImageComposite notifications and update the ChooseImage bias. + void OnFinishRendering(int aImageIndex, const TimedImage* aImage, + base::ProcessId aProcessId, + const CompositableHandle& aHandle); + + int32_t mLastFrameID = -1; + int32_t mLastProducerID = -1; + + private: + nsTArray<TimedImage> mImages; + TimeStamp GetBiasedTime(const TimeStamp& aInput) const; + + // Called when we know that frames older than aImage will never get another + // chance to be displayed. + // Counts frames in mImages that were skipped, and adds the skipped count to + // mSkippedFramesSinceLastComposite. + void CountSkippedFrames(const TimedImage* aImage); + + // Update mLastFrameID and mLastProducerID, and report dropped frames. + // Returns whether the frame changed. + bool UpdateCompositedFrame(int aImageIndex, + bool aWasVisibleAtPreviousComposition); + + void UpdateBias(size_t aImageIndex, bool aFrameUpdated); + + // Emit a profiler marker about video frame timestamp jitter. + void DetectTimeStampJitter(const TimedImage* aNewImage); + + /** + * Bias to apply to the next frame. + */ + Bias mBias = BIAS_NONE; + + // Video frames that were in mImages but that will never reach the screen. + // This count is reset in UpdateCompositedFrame. + int32_t mSkippedFramesSinceLastComposite = 0; + + // The number of dropped frames since the last call to + // GetDroppedFramesAndReset(). Not all skipped frames are considered "dropped" + // - for example, videos that are scrolled out of view or videos in background + // tabs are expected to skip frames, and those skipped frames are not counted + // as dropped frames. + uint32_t mDroppedFrames = 0; + + // The composition opportunity IDs of the last calls to ChooseImageIndex and + // UpdateCompositedFrame, respectively. + CompositionOpportunityId mLastChooseImageIndexComposition; + CompositionOpportunityId mLastFrameUpdateComposition; +}; + +} // namespace layers +} // namespace mozilla + +#endif // MOZILLA_GFX_IMAGECOMPOSITE_H diff --git a/gfx/layers/composite/ImageHost.cpp b/gfx/layers/composite/ImageHost.cpp new file mode 100644 index 0000000000..3c23dc432b --- /dev/null +++ b/gfx/layers/composite/ImageHost.cpp @@ -0,0 +1,454 @@ +/* -*- 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 "ImageHost.h" + +#include <utility> + +#include "composite/CompositableHost.h" // for CompositableHost, etc +#include "ipc/IPCMessageUtils.h" // for null_t +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/Effects.h" // for TexturedEffect, Effect, etc +#include "mozilla/layers/LayerManagerComposite.h" // for TexturedEffect, Effect, etc +#include "nsAString.h" +#include "nsDebug.h" // for NS_WARNING, NS_ASSERTION +#include "nsPrintfCString.h" // for nsPrintfCString +#include "nsString.h" // for nsAutoCString + +namespace mozilla { + +using namespace gfx; + +namespace layers { + +class ISurfaceAllocator; + +ImageHost::ImageHost(const TextureInfo& aTextureInfo) + : CompositableHost(aTextureInfo), ImageComposite(), mLocked(false) {} + +ImageHost::~ImageHost() = default; + +void ImageHost::UseTextureHost(const nsTArray<TimedTexture>& aTextures) { + MOZ_ASSERT(!mLocked); + + CompositableHost::UseTextureHost(aTextures); + MOZ_ASSERT(aTextures.Length() >= 1); + + nsTArray<TimedImage> newImages; + + for (uint32_t i = 0; i < aTextures.Length(); ++i) { + const TimedTexture& t = aTextures[i]; + MOZ_ASSERT(t.mTexture); + if (i + 1 < aTextures.Length() && t.mProducerID == mLastProducerID && + t.mFrameID < mLastFrameID) { + // Ignore frames before a frame that we already composited. We don't + // ever want to display these frames. This could be important if + // the frame producer adjusts timestamps (e.g. to track the audio clock) + // and the new frame times are earlier. + continue; + } + TimedImage& img = *newImages.AppendElement(); + img.mTextureHost = t.mTexture; + img.mTimeStamp = t.mTimeStamp; + img.mPictureRect = t.mPictureRect; + img.mFrameID = t.mFrameID; + img.mProducerID = t.mProducerID; + img.mTextureHost->SetCropRect(img.mPictureRect); + img.mTextureHost->Updated(); + } + + SetImages(std::move(newImages)); + + // If we only have one image we can upload it right away, otherwise we'll + // upload on-demand during composition after we have picked the proper + // timestamp. + if (ImagesCount() == 1) { + SetCurrentTextureHost(GetImage(0)->mTextureHost); + } + + HostLayerManager* lm = GetLayerManager(); + + // Video producers generally send replacement images with the same frameID but + // slightly different timestamps in order to sync with the audio clock. This + // means that any CompositeUntil() call we made in Composite() may no longer + // guarantee that we'll composite until the next frame is ready. Fix that + // here. + if (lm && mLastFrameID >= 0) { + for (const auto& img : Images()) { + bool frameComesAfter = + img.mFrameID > mLastFrameID || img.mProducerID != mLastProducerID; + if (frameComesAfter && !img.mTimeStamp.IsNull()) { + lm->CompositeUntil(img.mTimeStamp + + TimeDuration::FromMilliseconds(BIAS_TIME_MS)); + break; + } + } + } +} + +void ImageHost::SetCurrentTextureHost(TextureHost* aTexture) { + if (aTexture == mCurrentTextureHost.get()) { + return; + } + + bool swapTextureSources = !!mCurrentTextureHost && !!mCurrentTextureSource && + mCurrentTextureHost->IsValid() && + mCurrentTextureHost->HasIntermediateBuffer(); + + if (swapTextureSources) { + auto dataSource = mCurrentTextureSource->AsDataTextureSource(); + if (dataSource) { + // The current textureHost has an internal buffer in the form of the + // DataTextureSource. Removing the ownership of the texture source + // will enable the next texture host we bind to the texture source to + // acquire it instead of creating a new one. This is desirable in + // ImageHost because the current texture won't be used again with the + // same content. It wouldn't be desirable with ContentHost for instance, + // because the latter reuses the texture's valid regions. + dataSource->SetOwner(nullptr); + } + + RefPtr<TextureSource> tmp = mExtraTextureSource; + mExtraTextureSource = mCurrentTextureSource.get(); + mCurrentTextureSource = tmp; + } else { + mExtraTextureSource = nullptr; + } + + mCurrentTextureHost = aTexture; + mCurrentTextureHost->PrepareTextureSource(mCurrentTextureSource); +} + +void ImageHost::CleanupResources() { + mExtraTextureSource = nullptr; + mCurrentTextureSource = nullptr; + mCurrentTextureHost = nullptr; +} + +void ImageHost::RemoveTextureHost(TextureHost* aTexture) { + MOZ_ASSERT(!mLocked); + + CompositableHost::RemoveTextureHost(aTexture); + RemoveImagesWithTextureHost(aTexture); +} + +TimeStamp ImageHost::GetCompositionTime() const { + TimeStamp time; + if (HostLayerManager* lm = GetLayerManager()) { + time = lm->GetCompositionTime(); + } + return time; +} + +CompositionOpportunityId ImageHost::GetCompositionOpportunityId() const { + CompositionOpportunityId id; + if (HostLayerManager* lm = GetLayerManager()) { + id = lm->GetCompositionOpportunityId(); + } + return id; +} + +void ImageHost::AppendImageCompositeNotification( + const ImageCompositeNotificationInfo& aInfo) const { + if (HostLayerManager* lm = GetLayerManager()) { + lm->AppendImageCompositeNotification(aInfo); + } +} + +TextureHost* ImageHost::GetAsTextureHost(IntRect* aPictureRect) { + const TimedImage* img = ChooseImage(); + if (!img) { + return nullptr; + } + SetCurrentTextureHost(img->mTextureHost); + if (aPictureRect) { + *aPictureRect = img->mPictureRect; + } + return img->mTextureHost; +} + +void ImageHost::Attach(Layer* aLayer, TextureSourceProvider* aProvider, + AttachFlags aFlags) { + CompositableHost::Attach(aLayer, aProvider, aFlags); + for (const auto& img : Images()) { + img.mTextureHost->SetTextureSourceProvider(aProvider); + img.mTextureHost->Updated(); + } +} + +void ImageHost::Composite(Compositor* aCompositor, LayerComposite* aLayer, + EffectChain& aEffectChain, float aOpacity, + const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, + const nsIntRegion* aVisibleRegion, + const Maybe<gfx::Polygon>& aGeometry) { + RenderInfo info; + if (!PrepareToRender(aCompositor, &info)) { + return; + } + + const TimedImage* img = info.img; + + { + AutoLockCompositableHost autoLock(this); + if (autoLock.Failed()) { + NS_WARNING("failed to lock front buffer"); + return; + } + + if (!mCurrentTextureHost->BindTextureSource(mCurrentTextureSource)) { + return; + } + + if (!mCurrentTextureSource) { + // BindTextureSource above should have returned false! + MOZ_ASSERT(false); + return; + } + + bool isAlphaPremultiplied = + !(mCurrentTextureHost->GetFlags() & TextureFlags::NON_PREMULTIPLIED); + RefPtr<TexturedEffect> effect = + CreateTexturedEffect(mCurrentTextureHost, mCurrentTextureSource.get(), + aSamplingFilter, isAlphaPremultiplied); + if (!effect) { + return; + } + + if (!aCompositor->SupportsEffect(effect->mType)) { + return; + } + + DiagnosticFlags diagnosticFlags = DiagnosticFlags::IMAGE; + if (effect->mType == EffectTypes::NV12) { + diagnosticFlags |= DiagnosticFlags::NV12; + } else if (effect->mType == EffectTypes::YCBCR) { + diagnosticFlags |= DiagnosticFlags::YCBCR; + } + + aEffectChain.mPrimaryEffect = effect; + gfx::Rect pictureRect(0, 0, img->mPictureRect.Width(), + img->mPictureRect.Height()); + BigImageIterator* it = mCurrentTextureSource->AsBigImageIterator(); + if (it) { + // This iteration does not work if we have multiple texture sources here + // (e.g. 3 YCbCr textures). There's nothing preventing the different + // planes from having different resolutions or tile sizes. For example, a + // YCbCr frame could have Cb and Cr planes that are half the resolution of + // the Y plane, in such a way that the Y plane overflows the maximum + // texture size and the Cb and Cr planes do not. Then the Y plane would be + // split into multiple tiles and the Cb and Cr planes would just be one + // tile each. + // To handle the general case correctly, we'd have to create a grid of + // intersected tiles over all planes, and then draw each grid tile using + // the corresponding source tiles from all planes, with appropriate + // per-plane per-tile texture coords. + // DrawQuad currently assumes that all planes use the same texture coords. + MOZ_ASSERT( + it->GetTileCount() == 1 || !mCurrentTextureSource->GetNextSibling(), + "Can't handle multi-plane BigImages"); + + it->BeginBigImageIteration(); + do { + IntRect tileRect = it->GetTileRect(); + gfx::Rect rect(tileRect.X(), tileRect.Y(), tileRect.Width(), + tileRect.Height()); + rect = rect.Intersect(pictureRect); + effect->mTextureCoords = + Rect(Float(rect.X() - tileRect.X()) / tileRect.Width(), + Float(rect.Y() - tileRect.Y()) / tileRect.Height(), + Float(rect.Width()) / tileRect.Width(), + Float(rect.Height()) / tileRect.Height()); + if (img->mTextureHost->GetFlags() & TextureFlags::ORIGIN_BOTTOM_LEFT) { + effect->mTextureCoords.SetRectY(effect->mTextureCoords.YMost(), + -effect->mTextureCoords.Height()); + } + aCompositor->DrawGeometry(rect, aClipRect, aEffectChain, aOpacity, + aTransform, aGeometry); + aCompositor->DrawDiagnostics( + diagnosticFlags | DiagnosticFlags::BIGIMAGE, rect, aClipRect, + aTransform, mFlashCounter); + } while (it->NextTile()); + it->EndBigImageIteration(); + // layer border + aCompositor->DrawDiagnostics(diagnosticFlags, pictureRect, aClipRect, + aTransform, mFlashCounter); + } else { + IntSize textureSize = mCurrentTextureSource->GetSize(); + effect->mTextureCoords = + Rect(Float(img->mPictureRect.X()) / textureSize.width, + Float(img->mPictureRect.Y()) / textureSize.height, + Float(img->mPictureRect.Width()) / textureSize.width, + Float(img->mPictureRect.Height()) / textureSize.height); + + if (img->mTextureHost->GetFlags() & TextureFlags::ORIGIN_BOTTOM_LEFT) { + effect->mTextureCoords.SetRectY(effect->mTextureCoords.YMost(), + -effect->mTextureCoords.Height()); + } + + aCompositor->DrawGeometry(pictureRect, aClipRect, aEffectChain, aOpacity, + aTransform, aGeometry); + aCompositor->DrawDiagnostics(diagnosticFlags, pictureRect, aClipRect, + aTransform, mFlashCounter); + } + } + + FinishRendering(info); +} + +bool ImageHost::PrepareToRender(TextureSourceProvider* aProvider, + RenderInfo* aOutInfo) { + HostLayerManager* lm = GetLayerManager(); + if (!lm) { + return false; + } + + int imageIndex = ChooseImageIndex(); + if (imageIndex < 0) { + return false; + } + + if (uint32_t(imageIndex) + 1 < ImagesCount()) { + lm->CompositeUntil(GetImage(imageIndex + 1)->mTimeStamp + + TimeDuration::FromMilliseconds(BIAS_TIME_MS)); + } + + const TimedImage* img = GetImage(imageIndex); + img->mTextureHost->SetTextureSourceProvider(aProvider); + SetCurrentTextureHost(img->mTextureHost); + + aOutInfo->imageIndex = imageIndex; + aOutInfo->img = img; + aOutInfo->host = mCurrentTextureHost; + return true; +} + +RefPtr<TextureSource> ImageHost::AcquireTextureSource(const RenderInfo& aInfo) { + MOZ_ASSERT(aInfo.host == mCurrentTextureHost); + if (!aInfo.host->AcquireTextureSource(mCurrentTextureSource)) { + return nullptr; + } + return mCurrentTextureSource.get(); +} + +void ImageHost::FinishRendering(const RenderInfo& aInfo) { + OnFinishRendering(aInfo.imageIndex, aInfo.img, mAsyncRef.mProcessId, + mAsyncRef.mHandle); +} + +void ImageHost::SetTextureSourceProvider(TextureSourceProvider* aProvider) { + if (mTextureSourceProvider != aProvider) { + for (const auto& img : Images()) { + img.mTextureHost->SetTextureSourceProvider(aProvider); + } + } + CompositableHost::SetTextureSourceProvider(aProvider); +} + +void ImageHost::PrintInfo(std::stringstream& aStream, const char* aPrefix) { + aStream << aPrefix; + aStream << nsPrintfCString("ImageHost (0x%p)", this).get(); + + nsAutoCString pfx(aPrefix); + pfx += " "; + for (const auto& img : Images()) { + aStream << "\n"; + img.mTextureHost->PrintInfo(aStream, pfx.get()); + aStream << " [picture-rect=" << img.mPictureRect << "]"; + } +} + +void ImageHost::Dump(std::stringstream& aStream, const char* aPrefix, + bool aDumpHtml) { + for (const auto& img : Images()) { + aStream << aPrefix; + aStream << (aDumpHtml ? "<ul><li>TextureHost: " : "TextureHost: "); + DumpTextureHost(aStream, img.mTextureHost); + aStream << (aDumpHtml ? " </li></ul> " : " "); + } +} + +already_AddRefed<gfx::DataSourceSurface> ImageHost::GetAsSurface() { + const TimedImage* img = ChooseImage(); + if (img) { + return img->mTextureHost->GetAsSurface(); + } + return nullptr; +} + +bool ImageHost::Lock() { + MOZ_ASSERT(!mLocked); + const TimedImage* img = ChooseImage(); + if (!img) { + return false; + } + + SetCurrentTextureHost(img->mTextureHost); + + if (!mCurrentTextureHost->Lock()) { + return false; + } + mLocked = true; + return true; +} + +void ImageHost::Unlock() { + MOZ_ASSERT(mLocked); + + if (mCurrentTextureHost) { + mCurrentTextureHost->Unlock(); + } + mLocked = false; +} + +IntSize ImageHost::GetImageSize() { + const TimedImage* img = ChooseImage(); + if (img) { + return IntSize(img->mPictureRect.Width(), img->mPictureRect.Height()); + } + return IntSize(); +} + +bool ImageHost::IsOpaque() { + const TimedImage* img = ChooseImage(); + if (!img) { + return false; + } + + if (img->mPictureRect.Width() == 0 || img->mPictureRect.Height() == 0 || + !img->mTextureHost) { + return false; + } + + gfx::SurfaceFormat format = img->mTextureHost->GetFormat(); + if (gfx::IsOpaque(format)) { + return true; + } + return false; +} + +already_AddRefed<TexturedEffect> ImageHost::GenEffect( + const gfx::SamplingFilter aSamplingFilter) { + const TimedImage* img = ChooseImage(); + if (!img) { + return nullptr; + } + SetCurrentTextureHost(img->mTextureHost); + if (!mCurrentTextureHost->BindTextureSource(mCurrentTextureSource)) { + return nullptr; + } + bool isAlphaPremultiplied = true; + if (mCurrentTextureHost->GetFlags() & TextureFlags::NON_PREMULTIPLIED) { + isAlphaPremultiplied = false; + } + + return CreateTexturedEffect(mCurrentTextureHost, mCurrentTextureSource, + aSamplingFilter, isAlphaPremultiplied); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ImageHost.h b/gfx/layers/composite/ImageHost.h new file mode 100644 index 0000000000..5d712d5bdd --- /dev/null +++ b/gfx/layers/composite/ImageHost.h @@ -0,0 +1,138 @@ +/* -*- 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_IMAGEHOST_H +#define MOZILLA_GFX_IMAGEHOST_H + +#include <stdio.h> // for FILE +#include "CompositableHost.h" // for CompositableHost +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Polygon.h" // for Polygon +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for SamplingFilter +#include "mozilla/layers/CompositorTypes.h" // for TextureInfo, etc +#include "mozilla/layers/ImageComposite.h" // for ImageComposite +#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "mozilla/layers/TextureHost.h" // for TextureHost, etc +#include "mozilla/mozalloc.h" // for operator delete +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nsRegionFwd.h" // for nsIntRegion +#include "nscore.h" // for nsACString + +namespace mozilla { +namespace layers { + +class Compositor; +struct EffectChain; +class HostLayerManager; + +/** + * ImageHost. Works with ImageClientSingle and ImageClientBuffered + */ +class ImageHost : public CompositableHost, public ImageComposite { + public: + explicit ImageHost(const TextureInfo& aTextureInfo); + virtual ~ImageHost(); + + CompositableType GetType() override { return mTextureInfo.mCompositableType; } + ImageHost* AsImageHost() override { return this; } + + void Composite(Compositor* aCompositor, LayerComposite* aLayer, + EffectChain& aEffectChain, float aOpacity, + const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, + const nsIntRegion* aVisibleRegion = nullptr, + const Maybe<gfx::Polygon>& aGeometry = Nothing()) override; + + void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override; + + void RemoveTextureHost(TextureHost* aTexture) override; + + TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) override; + + void Attach(Layer* aLayer, TextureSourceProvider* aProvider, + AttachFlags aFlags = NO_FLAGS) override; + + void SetTextureSourceProvider(TextureSourceProvider* aProvider) override; + + gfx::IntSize GetImageSize() override; + + void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; + + void Dump(std::stringstream& aStream, const char* aPrefix = "", + bool aDumpHtml = false) override; + + already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override; + + bool Lock() override; + + void Unlock() override; + + already_AddRefed<TexturedEffect> GenEffect( + const gfx::SamplingFilter aSamplingFilter) override; + + void SetCurrentTextureHost(TextureHost* aTexture); + + void CleanupResources() override; + + bool IsOpaque(); + + uint32_t GetDroppedFrames() override { return GetDroppedFramesAndReset(); } + + struct RenderInfo { + int imageIndex; + const TimedImage* img; + RefPtr<TextureHost> host; + + RenderInfo() : imageIndex(-1), img(nullptr) {} + }; + + // Acquire rendering information for the current frame. + bool PrepareToRender(TextureSourceProvider* aProvider, RenderInfo* aOutInfo); + + // Acquire the TextureSource for the currently prepared frame. + RefPtr<TextureSource> AcquireTextureSource(const RenderInfo& aInfo); + + // Send ImageComposite notifications. + void FinishRendering(const RenderInfo& aInfo); + + // This should only be called inside a lock, or during rendering. It is + // infallible to enforce this. + TextureHost* CurrentTextureHost() const { + MOZ_ASSERT(mCurrentTextureHost); + return mCurrentTextureHost; + } + + protected: + // ImageComposite + TimeStamp GetCompositionTime() const override; + CompositionOpportunityId GetCompositionOpportunityId() const override; + void AppendImageCompositeNotification( + const ImageCompositeNotificationInfo& aInfo) const override; + + // Use a simple RefPtr because the same texture is already held by a + // a CompositableTextureHostRef in the array of TimedImage. + // See the comment in CompositableTextureRef for more details. + RefPtr<TextureHost> mCurrentTextureHost; + CompositableTextureSourceRef mCurrentTextureSource; + // When doing texture uploads it's best to alternate between two (or three) + // texture sources so that the texture we upload to isn't being used by + // the GPU to composite the previous frame. + RefPtr<TextureSource> mExtraTextureSource; + + bool mLocked; +}; + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/ImageLayerComposite.cpp b/gfx/layers/composite/ImageLayerComposite.cpp new file mode 100644 index 0000000000..9fab48e280 --- /dev/null +++ b/gfx/layers/composite/ImageLayerComposite.cpp @@ -0,0 +1,209 @@ +/* -*- 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 "ImageLayerComposite.h" +#include "CompositableHost.h" // for CompositableHost +#include "Layers.h" // for WriteSnapshotToDumpFile, etc +#include "gfx2DGlue.h" // for ToFilter +#include "gfxEnv.h" // for gfxEnv +#include "gfxRect.h" // for gfxRect +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for IntSize, Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/Effects.h" // for EffectChain +#include "mozilla/layers/ImageHost.h" // for ImageHost +#include "mozilla/layers/LayerManagerCompositeUtils.h" +#include "mozilla/layers/TextureHost.h" // for TextureHost, etc +#include "mozilla/mozalloc.h" // for operator delete +#include "nsAString.h" +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsDebug.h" // for NS_ASSERTION +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "nsString.h" // for nsAutoCString + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +ImageLayerComposite::ImageLayerComposite(LayerManagerComposite* aManager) + : ImageLayer(aManager, nullptr), + LayerComposite(aManager), + mImageHost(nullptr) { + MOZ_COUNT_CTOR(ImageLayerComposite); + mImplData = static_cast<LayerComposite*>(this); +} + +ImageLayerComposite::~ImageLayerComposite() { + MOZ_COUNT_DTOR(ImageLayerComposite); + MOZ_ASSERT(mDestroyed); + + CleanupResources(); +} + +bool ImageLayerComposite::SetCompositableHost(CompositableHost* aHost) { + switch (aHost->GetType()) { + case CompositableType::IMAGE: { + ImageHost* newImageHost = static_cast<ImageHost*>(aHost); + if (mImageHost && newImageHost != mImageHost) { + mImageHost->Detach(this); + } + mImageHost = newImageHost; + return true; + } + default: + return false; + } +} + +void ImageLayerComposite::Disconnect() { Destroy(); } + +Layer* ImageLayerComposite::GetLayer() { return this; } + +void ImageLayerComposite::SetLayerManager(HostLayerManager* aManager) { + LayerComposite::SetLayerManager(aManager); + mManager = aManager; + if (mImageHost) { + mImageHost->SetTextureSourceProvider(mCompositor); + if (aManager && mImageHost->GetAsyncRef()) { + mImageHost->SetCompositorBridgeID(aManager->GetCompositorBridgeID()); + } + } +} + +void ImageLayerComposite::RenderLayer(const IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + if (!mImageHost || !mImageHost->IsAttached()) { + return; + } + +#ifdef MOZ_DUMP_PAINTING + if (gfxEnv::DumpCompositorTextures()) { + RefPtr<gfx::DataSourceSurface> surf = mImageHost->GetAsSurface(); + if (surf) { + WriteSnapshotToDumpFile(this, surf); + } + } +#endif + + mCompositor->MakeCurrent(); + + RenderWithAllMasks(this, mCompositor, aClipRect, + [&](EffectChain& effectChain, const IntRect& clipRect) { + mImageHost->SetTextureSourceProvider(mCompositor); + mImageHost->Composite(mCompositor, this, effectChain, + GetEffectiveOpacity(), + GetEffectiveTransformForBuffer(), + GetSamplingFilter(), clipRect); + }); + mImageHost->BumpFlashCounter(); +} + +void ImageLayerComposite::ComputeEffectiveTransforms( + const gfx::Matrix4x4& aTransformToSurface) { + gfx::Matrix4x4 local = GetLocalTransform(); + + // Snap image edges to pixel boundaries + gfxRect sourceRect(0, 0, 0, 0); + if (mImageHost && mImageHost->IsAttached()) { + IntSize size = mImageHost->GetImageSize(); + sourceRect.SizeTo(size.width, size.height); + } + // Snap our local transform first, and snap the inherited transform as well. + // This makes our snapping equivalent to what would happen if our content + // was drawn into a PaintedLayer (gfxContext would snap using the local + // transform, then we'd snap again when compositing the PaintedLayer). + mEffectiveTransform = SnapTransform(local, sourceRect, nullptr) * + SnapTransformTranslation(aTransformToSurface, nullptr); + + if (mScaleMode != ScaleMode::SCALE_NONE && !sourceRect.IsZeroArea()) { + NS_ASSERTION(mScaleMode == ScaleMode::STRETCH, + "No other scalemodes than stretch and none supported yet."); + local.PreScale(mScaleToSize.width / sourceRect.Width(), + mScaleToSize.height / sourceRect.Height(), 1.0); + + mEffectiveTransformForBuffer = + SnapTransform(local, sourceRect, nullptr) * + SnapTransformTranslation(aTransformToSurface, nullptr); + } else { + mEffectiveTransformForBuffer = mEffectiveTransform; + } + + ComputeEffectiveTransformForMaskLayers(aTransformToSurface); +} + +bool ImageLayerComposite::IsOpaque() { + if (!mImageHost || !mImageHost->IsAttached()) { + return false; + } + + // TODO: Handle ScaleMode::NONE where the image + // still covers the whole Layer. + if (mScaleMode == ScaleMode::STRETCH) { + if ((GetContentFlags() & CONTENT_OPAQUE) && !mImageHost->IsOpaque()) { + NS_WARNING("Must have an opaque ImageHost if we reported CONTENT_OPAQUE"); + } + return mImageHost->IsOpaque(); + } + return false; +} + +nsIntRegion ImageLayerComposite::GetFullyRenderedRegion() { + if (!mImageHost || !mImageHost->IsAttached()) { + return GetShadowVisibleRegion().ToUnknownRegion(); + } + + if (mScaleMode == ScaleMode::STRETCH) { + nsIntRegion shadowVisibleRegion; + shadowVisibleRegion.And(GetShadowVisibleRegion().ToUnknownRegion(), + nsIntRegion(gfx::IntRect(0, 0, mScaleToSize.width, + mScaleToSize.height))); + return shadowVisibleRegion; + } + + return GetShadowVisibleRegion().ToUnknownRegion(); +} + +CompositableHost* ImageLayerComposite::GetCompositableHost() { + if (mImageHost && mImageHost->IsAttached()) { + return mImageHost.get(); + } + + return nullptr; +} + +void ImageLayerComposite::CleanupResources() { + if (mImageHost) { + mImageHost->CleanupResources(); + mImageHost->Detach(this); + } + mImageHost = nullptr; +} + +gfx::SamplingFilter ImageLayerComposite::GetSamplingFilter() { + return mSamplingFilter; +} + +void ImageLayerComposite::GenEffectChain(EffectChain& aEffect) { + aEffect.mLayerRef = this; + aEffect.mPrimaryEffect = mImageHost->GenEffect(GetSamplingFilter()); +} + +void ImageLayerComposite::PrintInfo(std::stringstream& aStream, + const char* aPrefix) { + ImageLayer::PrintInfo(aStream, aPrefix); + if (mImageHost && mImageHost->IsAttached()) { + aStream << "\n"; + nsAutoCString pfx(aPrefix); + pfx += " "; + mImageHost->PrintInfo(aStream, pfx.get()); + } +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/ImageLayerComposite.h b/gfx/layers/composite/ImageLayerComposite.h new file mode 100644 index 0000000000..f0725c2852 --- /dev/null +++ b/gfx/layers/composite/ImageLayerComposite.h @@ -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/. */ + +#ifndef GFX_ImageLayerComposite_H +#define GFX_ImageLayerComposite_H + +#include "GLTextureImage.h" // for TextureImage +#include "ImageLayers.h" // for ImageLayer +#include "mozilla/Attributes.h" // for override +#include "mozilla/gfx/Rect.h" +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/layers/LayerManagerComposite.h" // for LayerComposite, etc +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "nsISupportsImpl.h" // for TextureImage::AddRef, etc +#include "nscore.h" // for nsACString +#include "CompositableHost.h" // for CompositableHost + +namespace mozilla { +namespace layers { + +class ImageHost; +class Layer; + +class ImageLayerComposite : public ImageLayer, public LayerComposite { + typedef gl::TextureImage TextureImage; + + public: + explicit ImageLayerComposite(LayerManagerComposite* aManager); + + protected: + virtual ~ImageLayerComposite(); + + public: + void Disconnect() override; + + bool SetCompositableHost(CompositableHost* aHost) override; + + Layer* GetLayer() override; + + void SetLayerManager(HostLayerManager* aManager) override; + + void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) override; + + void ComputeEffectiveTransforms( + const mozilla::gfx::Matrix4x4& aTransformToSurface) override; + + void CleanupResources() override; + + CompositableHost* GetCompositableHost() override; + + void GenEffectChain(EffectChain& aEffect) override; + + HostLayer* AsHostLayer() override { return this; } + + const char* Name() const override { return "ImageLayerComposite"; } + + bool IsOpaque() override; + + nsIntRegion GetFullyRenderedRegion() override; + + protected: + void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; + + private: + gfx::SamplingFilter GetSamplingFilter(); + + private: + RefPtr<ImageHost> mImageHost; +}; + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_ImageLayerComposite_H */ diff --git a/gfx/layers/composite/LayerManagerComposite.cpp b/gfx/layers/composite/LayerManagerComposite.cpp new file mode 100644 index 0000000000..8ad4e0310d --- /dev/null +++ b/gfx/layers/composite/LayerManagerComposite.cpp @@ -0,0 +1,1780 @@ +/* -*- 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 "LayerManagerComposite.h" +#include <stddef.h> // for size_t +#include <stdint.h> // for uint16_t, uint32_t +#include "CanvasLayerComposite.h" // for CanvasLayerComposite +#include "ColorLayerComposite.h" // for ColorLayerComposite +#include "CompositableHost.h" // for CompositableHost +#include "ContainerLayerComposite.h" // for ContainerLayerComposite, etc +#include "Diagnostics.h" +#include "FPSCounter.h" // for FPSState, FPSCounter +#include "FrameMetrics.h" // for FrameMetrics +#include "GeckoProfiler.h" // for profiler_* +#include "ImageLayerComposite.h" // for ImageLayerComposite +#include "Layers.h" // for Layer, ContainerLayer, etc +#include "LayerScope.h" // for LayerScope Tool +#include "LayerTreeInvalidation.h" +#include "protobuf/LayerScopePacket.pb.h" // for protobuf (LayerScope) +#include "PaintedLayerComposite.h" // for PaintedLayerComposite +#include "TiledContentHost.h" +#include "Units.h" // for ScreenIntRect +#include "UnitTransforms.h" // for ViewAs +#include "apz/src/AsyncPanZoomController.h" // for AsyncPanZoomController +#include "gfxEnv.h" // for gfxEnv + +#ifdef XP_MACOSX +# include "gfxPlatformMac.h" +#endif +#include "gfxRect.h" // for gfxRect +#include "gfxUtils.h" // for frame color util +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/RefPtr.h" // for RefPtr, already_AddRefed +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/gfx/2D.h" // for DrawTarget +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for IntSize, Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for Color, SurfaceFormat +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorOGL.h" +#include "mozilla/layers/CompositorTypes.h" +#include "mozilla/layers/Effects.h" // for Effect, EffectChain, etc +#include "mozilla/layers/LayerMetricsWrapper.h" // for LayerMetricsWrapper +#include "mozilla/layers/LayersTypes.h" // for etc +#include "mozilla/layers/NativeLayer.h" +#include "mozilla/layers/UiCompositorControllerParent.h" +#include "mozilla/widget/CompositorWidget.h" // for WidgetRenderingContext +#include "ipc/CompositorBench.h" // for CompositorBench +#include "ipc/SurfaceDescriptor.h" +#include "mozilla/mozalloc.h" // for operator new, etc +#include "nsAppRunner.h" +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsDebug.h" // for NS_WARNING, etc +#include "nsISupportsImpl.h" // for Layer::AddRef, etc +#include "nsPoint.h" // for nsIntPoint +#include "nsRect.h" // for mozilla::gfx::IntRect +#include "nsRegion.h" // for nsIntRegion, etc +#if defined(MOZ_WIDGET_ANDROID) +# include <android/log.h> +# include <android/native_window.h> +# include "mozilla/jni/Utils.h" +# include "mozilla/widget/AndroidCompositorWidget.h" +# include "GLConsts.h" +# include "GLContextEGL.h" +# include "GLContextProvider.h" +# include "mozilla/Unused.h" +# include "ScopedGLHelpers.h" +#endif +#include "GeckoProfiler.h" +#include "TextRenderer.h" // for TextRenderer +#include "mozilla/layers/CompositorBridgeParent.h" +#include "TreeTraversal.h" // for ForEachNode +#include "CompositionRecorder.h" + +#ifdef USE_SKIA +# include "PaintCounter.h" // For PaintCounter +#endif + +class gfxContext; + +namespace mozilla { +namespace layers { + +class ImageLayer; + +using namespace mozilla::gfx; +using namespace mozilla::gl; + +static LayerComposite* ToLayerComposite(Layer* aLayer) { + return static_cast<LayerComposite*>(aLayer->ImplData()); +} + +static void ClearSubtree(Layer* aLayer) { + ForEachNode<ForwardIterator>(aLayer, [](Layer* layer) { + ToLayerComposite(layer)->CleanupResources(); + }); +} + +void LayerManagerComposite::ClearCachedResources(Layer* aSubtree) { + MOZ_ASSERT(!aSubtree || aSubtree->Manager() == this); + Layer* subtree = aSubtree ? aSubtree : mRoot.get(); + if (!subtree) { + return; + } + + ClearSubtree(subtree); + // FIXME [bjacob] + // XXX the old LayerManagerOGL code had a mMaybeInvalidTree that it set to + // true here. Do we need that? +} + +HostLayerManager::HostLayerManager() + : mDebugOverlayWantsNextFrame(false), + mWarningLevel(0.0f), + mCompositorBridgeID(0), + mLastPaintTime(TimeDuration::Forever()), + mRenderStartTime(TimeStamp::Now()) {} + +HostLayerManager::~HostLayerManager() = default; + +void HostLayerManager::RecordPaintTimes(const PaintTiming& aTiming) { + mDiagnostics->RecordPaintTimes(aTiming); +} + +void HostLayerManager::RecordUpdateTime(float aValue) { + mDiagnostics->RecordUpdateTime(aValue); +} + +void HostLayerManager::WriteCollectedFrames() { + if (mCompositionRecorder) { + mCompositionRecorder->WriteCollectedFrames(); + mCompositionRecorder = nullptr; + } +} + +Maybe<CollectedFrames> HostLayerManager::GetCollectedFrames() { + Maybe<CollectedFrames> maybeFrames; + + if (mCompositionRecorder) { + maybeFrames.emplace(mCompositionRecorder->GetCollectedFrames()); + mCompositionRecorder = nullptr; + } + + return maybeFrames; +} + +/** + * LayerManagerComposite + */ +LayerManagerComposite::LayerManagerComposite(Compositor* aCompositor) + : mUnusedApzTransformWarning(false), + mDisabledApzWarning(false), + mCompositor(aCompositor), + mInTransaction(false), + mIsCompositorReady(false) +#if defined(MOZ_WIDGET_ANDROID) + , + mScreenPixelsTarget(nullptr) +#endif // defined(MOZ_WIDGET_ANDROID) +{ + mTextRenderer = new TextRenderer(); + mDiagnostics = MakeUnique<Diagnostics>(); + MOZ_ASSERT(aCompositor); + mNativeLayerRoot = aCompositor->GetWidget()->GetNativeLayerRoot(); + if (mNativeLayerRoot) { + mSurfacePoolHandle = aCompositor->GetSurfacePoolHandle(); + MOZ_RELEASE_ASSERT(mSurfacePoolHandle); + } + +#ifdef USE_SKIA + mPaintCounter = nullptr; +#endif +} + +LayerManagerComposite::~LayerManagerComposite() { Destroy(); } + +void LayerManagerComposite::Destroy() { + if (!mDestroyed) { + mCompositor->GetWidget()->CleanupWindowEffects(); + if (mRoot) { + RootLayer()->Destroy(); + } + mCompositor->CancelFrame(); + mRoot = nullptr; + mClonedLayerTreeProperties = nullptr; + mProfilerScreenshotGrabber.Destroy(); + + if (mNativeLayerRoot) { + if (mGPUStatsLayer) { + mNativeLayerRoot->RemoveLayer(mGPUStatsLayer); + mGPUStatsLayer = nullptr; + } + if (mUnusedTransformWarningLayer) { + mNativeLayerRoot->RemoveLayer(mUnusedTransformWarningLayer); + mUnusedTransformWarningLayer = nullptr; + } + if (mDisabledApzWarningLayer) { + mNativeLayerRoot->RemoveLayer(mDisabledApzWarningLayer); + mDisabledApzWarningLayer = nullptr; + } + for (const auto& nativeLayer : mNativeLayers) { + mNativeLayerRoot->RemoveLayer(nativeLayer); + } + mNativeLayers.clear(); + mNativeLayerRoot = nullptr; + } + mDestroyed = true; + +#ifdef USE_SKIA + mPaintCounter = nullptr; +#endif + } +} + +void LayerManagerComposite::UpdateRenderBounds(const IntRect& aRect) { + mRenderBounds = aRect; +} + +bool LayerManagerComposite::AreComponentAlphaLayersEnabled() { + return mCompositor->GetBackendType() != LayersBackend::LAYERS_BASIC && + mCompositor->SupportsEffect(EffectTypes::COMPONENT_ALPHA) && + LayerManager::AreComponentAlphaLayersEnabled(); +} + +bool LayerManagerComposite::BeginTransaction(const nsCString& aURL) { + mInTransaction = true; + + if (!mCompositor->Ready()) { + return false; + } + + mIsCompositorReady = true; + return true; +} + +void LayerManagerComposite::BeginTransactionWithDrawTarget( + DrawTarget* aTarget, const IntRect& aRect) { + mInTransaction = true; + + if (!mCompositor->Ready()) { + return; + } + +#ifdef MOZ_LAYERS_HAVE_LOG + MOZ_LAYERS_LOG(("[----- BeginTransaction")); + Log(); +#endif + + if (mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return; + } + + mIsCompositorReady = true; + mTarget = aTarget; + mTargetBounds = aRect; +} + +template <typename Units> +static IntRectTyped<Units> TransformRect(const IntRectTyped<Units>& aRect, + const Matrix& aTransform, + bool aRoundIn = false) { + if (aRect.IsEmpty()) { + return IntRectTyped<Units>(); + } + + Rect rect(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height()); + rect = aTransform.TransformBounds(rect); + if (aRoundIn) { + MOZ_ASSERT(aTransform.PreservesAxisAlignedRectangles()); + rect.RoundIn(); + } else { + rect.RoundOut(); + } + + IntRect intRect; + if (!rect.ToIntRect(&intRect)) { + intRect = IntRect::MaxIntRect(); + } + + return ViewAs<Units>(intRect); +} + +template <typename Units> +static IntRectTyped<Units> TransformRect(const IntRectTyped<Units>& aRect, + const Matrix4x4& aTransform, + bool aRoundIn = false) { + if (aRect.IsEmpty()) { + return IntRectTyped<Units>(); + } + + Rect rect(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height()); + rect = aTransform.TransformAndClipBounds(rect, Rect::MaxIntRect()); + if (aRoundIn) { + rect.RoundIn(); + } else { + rect.RoundOut(); + } + + IntRect intRect; + if (!rect.ToIntRect(&intRect)) { + intRect = IntRect::MaxIntRect(); + } + + return ViewAs<Units>(intRect); +} + +template <typename Units, typename MatrixType> +static IntRectTyped<Units> TransformRectRoundIn( + const IntRectTyped<Units>& aRect, const MatrixType& aTransform) { + return TransformRect(aRect, aTransform, true); +} + +template <typename Units, typename MatrixType> +static void AddTransformedRegion(IntRegionTyped<Units>& aDest, + const IntRegionTyped<Units>& aSource, + const MatrixType& aTransform) { + for (auto iter = aSource.RectIter(); !iter.Done(); iter.Next()) { + aDest.Or(aDest, TransformRect(iter.Get(), aTransform)); + } + aDest.SimplifyOutward(20); +} + +template <typename Units, typename MatrixType> +static void AddTransformedRegionRoundIn(IntRegionTyped<Units>& aDest, + const IntRegionTyped<Units>& aSource, + const MatrixType& aTransform) { + for (auto iter = aSource.RectIter(); !iter.Done(); iter.Next()) { + aDest.Or(aDest, TransformRectRoundIn(iter.Get(), aTransform)); + } +} + +void LayerManagerComposite::PostProcessLayers(nsIntRegion& aOpaqueRegion) { + LayerIntRegion visible; + LayerComposite* rootComposite = + static_cast<LayerComposite*>(mRoot->AsHostLayer()); + PostProcessLayers( + mRoot, aOpaqueRegion, visible, + ViewAs<RenderTargetPixel>( + rootComposite->GetShadowClipRect(), + PixelCastJustification::RenderTargetIsParentLayerForRoot), + Nothing(), true); +} + +// We want to skip directly through ContainerLayers that don't have an +// intermediate surface. We compute occlusions for leaves and intermediate +// surfaces against the layer that they actually composite into so that we can +// use the final (snapped) effective transform. +static bool ShouldProcessLayer(Layer* aLayer) { + if (!aLayer->AsContainerLayer()) { + return true; + } + + return aLayer->AsContainerLayer()->UseIntermediateSurface(); +} + +void LayerManagerComposite::PostProcessLayers( + Layer* aLayer, nsIntRegion& aOpaqueRegion, LayerIntRegion& aVisibleRegion, + const Maybe<RenderTargetIntRect>& aRenderTargetClip, + const Maybe<ParentLayerIntRect>& aClipFromAncestors, + bool aCanContributeOpaque) { + // Compute a clip that's the combination of our layer clip with the clip + // from our ancestors. + LayerComposite* composite = + static_cast<LayerComposite*>(aLayer->AsHostLayer()); + Maybe<ParentLayerIntRect> layerClip = composite->GetShadowClipRect(); + MOZ_ASSERT(!layerClip || !aLayer->Combines3DTransformWithAncestors(), + "The layer with a clip should not participate " + "a 3D rendering context"); + Maybe<ParentLayerIntRect> outsideClip = + IntersectMaybeRects(layerClip, aClipFromAncestors); + + Maybe<LayerIntRect> insideClip; + if (aLayer->Extend3DContext()) { + // If we're preserve-3d just pass the clip rect down directly, and we'll do + // the conversion at the preserve-3d leaf Layer. + if (outsideClip) { + insideClip = Some(ViewAs<LayerPixel>( + *outsideClip, PixelCastJustification::MovingDownToChildren)); + } + } else if (outsideClip) { + // Convert the combined clip into our pre-transform coordinate space, so + // that it can later be intersected with our visible region. + // If our transform is a perspective, there's no meaningful insideClip rect + // we can compute (it would need to be a cone). + Matrix4x4 localTransform = aLayer->ComputeTransformToPreserve3DRoot(); + if (!localTransform.HasPerspectiveComponent() && localTransform.Invert()) { + LayerRect insideClipFloat = + UntransformBy(ViewAs<ParentLayerToLayerMatrix4x4>(localTransform), + ParentLayerRect(*outsideClip), LayerRect::MaxIntRect()) + .valueOr(LayerRect()); + insideClipFloat.RoundOut(); + LayerIntRect insideClipInt; + if (insideClipFloat.ToIntRect(&insideClipInt)) { + insideClip = Some(insideClipInt); + } + } + } + + Maybe<ParentLayerIntRect> ancestorClipForChildren; + if (insideClip) { + ancestorClipForChildren = Some(ViewAs<ParentLayerPixel>( + *insideClip, PixelCastJustification::MovingDownToChildren)); + } + + nsIntRegion dummy; + nsIntRegion& opaqueRegion = aOpaqueRegion; + if (aLayer->Extend3DContext() || aLayer->Combines3DTransformWithAncestors()) { + opaqueRegion = dummy; + } + + if (!ShouldProcessLayer(aLayer)) { + MOZ_ASSERT(aLayer->AsContainerLayer() && + !aLayer->AsContainerLayer()->UseIntermediateSurface()); + // For layers participating 3D rendering context, their visible + // region should be empty (invisible), so we pass through them + // without doing anything. + for (Layer* child = aLayer->GetLastChild(); child; + child = child->GetPrevSibling()) { + LayerComposite* childComposite = + static_cast<LayerComposite*>(child->AsHostLayer()); + Maybe<RenderTargetIntRect> renderTargetClip = aRenderTargetClip; + if (childComposite->GetShadowClipRect()) { + RenderTargetIntRect clip = TransformBy( + ViewAs<ParentLayerToRenderTargetMatrix4x4>( + aLayer->GetEffectiveTransform(), + PixelCastJustification::RenderTargetIsParentLayerForRoot), + *childComposite->GetShadowClipRect()); + renderTargetClip = IntersectMaybeRects(renderTargetClip, Some(clip)); + } + + PostProcessLayers( + child, opaqueRegion, aVisibleRegion, renderTargetClip, + ancestorClipForChildren, + aCanContributeOpaque & + !(aLayer->GetContentFlags() & Layer::CONTENT_BACKFACE_HIDDEN)); + } + return; + } + + nsIntRegion localOpaque; + // Treat layers on the path to the root of the 3D rendering context as + // a giant layer if it is a leaf. + Matrix4x4 transform = aLayer->GetEffectiveTransform(); + Matrix transform2d; + bool canTransformOpaqueRegion = false; + // If aLayer has a simple transform (only an integer translation) then we + // can easily convert aOpaqueRegion into pre-transform coordinates and include + // that region. + if (aCanContributeOpaque && + !(aLayer->GetContentFlags() & Layer::CONTENT_BACKFACE_HIDDEN) && + transform.Is2D(&transform2d) && + transform2d.PreservesAxisAlignedRectangles()) { + Matrix inverse = transform2d; + inverse.Invert(); + AddTransformedRegionRoundIn(localOpaque, opaqueRegion, inverse); + canTransformOpaqueRegion = true; + } + + // Save the value of localOpaque, which currently stores the region obscured + // by siblings (and uncles and such), before our descendants contribute to it. + nsIntRegion obscured = localOpaque; + + // Recurse on our descendants, in front-to-back order. In this process: + // - Occlusions are computed for them, and they contribute to localOpaque. + // - They recalculate their visible regions, taking ancestorClipForChildren + // into account, and accumulate them into descendantsVisibleRegion. + LayerIntRegion descendantsVisibleRegion; + + bool hasPreserve3DChild = false; + for (Layer* child = aLayer->GetLastChild(); child; + child = child->GetPrevSibling()) { + MOZ_ASSERT(aLayer->AsContainerLayer()->UseIntermediateSurface()); + LayerComposite* childComposite = + static_cast<LayerComposite*>(child->AsHostLayer()); + PostProcessLayers( + child, localOpaque, descendantsVisibleRegion, + ViewAs<RenderTargetPixel>( + childComposite->GetShadowClipRect(), + PixelCastJustification::RenderTargetIsParentLayerForRoot), + ancestorClipForChildren, true); + if (child->Extend3DContext()) { + hasPreserve3DChild = true; + } + } + + // Recalculate our visible region. + LayerIntRegion visible = composite->GetShadowVisibleRegion(); + + // If we have descendants, throw away the visible region stored on this + // layer, and use the region accumulated by our descendants instead. + if (aLayer->GetFirstChild() && !hasPreserve3DChild) { + visible = descendantsVisibleRegion; + } + + // Subtract any areas that we know to be opaque. + if (!obscured.IsEmpty()) { + visible.SubOut(LayerIntRegion::FromUnknownRegion(obscured)); + } + + // Clip the visible region using the combined clip. + if (insideClip) { + visible.AndWith(*insideClip); + } + composite->SetShadowVisibleRegion(visible); + + // Transform the newly calculated visible region into our parent's space, + // apply our clip to it (if any), and accumulate it into |aVisibleRegion| + // for the caller to use. + ParentLayerIntRegion visibleParentSpace = + TransformBy(ViewAs<LayerToParentLayerMatrix4x4>(transform), visible); + aVisibleRegion.OrWith(ViewAs<LayerPixel>( + visibleParentSpace, PixelCastJustification::MovingDownToChildren)); + + // If we have a simple transform, then we can add our opaque area into + // aOpaqueRegion. + if (canTransformOpaqueRegion && !aLayer->HasMaskLayers() && + aLayer->IsOpaqueForVisibility()) { + if (aLayer->IsOpaque()) { + localOpaque.OrWith(composite->GetFullyRenderedRegion()); + } + nsIntRegion parentSpaceOpaque; + AddTransformedRegionRoundIn(parentSpaceOpaque, localOpaque, transform2d); + if (aRenderTargetClip) { + parentSpaceOpaque.AndWith(aRenderTargetClip->ToUnknownRect()); + } + opaqueRegion.OrWith(parentSpaceOpaque); + } +} + +void LayerManagerComposite::EndTransaction(const TimeStamp& aTimeStamp, + EndTransactionFlags aFlags) { + NS_ASSERTION(mInTransaction, "Didn't call BeginTransaction?"); + NS_ASSERTION(!(aFlags & END_NO_COMPOSITE), + "Shouldn't get END_NO_COMPOSITE here"); + mInTransaction = false; + mRenderStartTime = TimeStamp::Now(); + + // Ensure we read unlock textures, even if we end up + // not compositing this frame. + TextureSourceProvider::AutoReadUnlockTextures unlock(mCompositor); + + if (!mIsCompositorReady) { + return; + } + mIsCompositorReady = false; + +#ifdef MOZ_LAYERS_HAVE_LOG + MOZ_LAYERS_LOG((" ----- (beginning paint)")); + Log(); +#endif + + if (mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return; + } + + // Set composition timestamp here because we need it in + // ComputeEffectiveTransforms (so the correct video frame size is picked) and + // also to compute invalid regions properly. + SetCompositionTime(aTimeStamp); + + if (mRoot && !(aFlags & END_NO_IMMEDIATE_REDRAW)) { + MOZ_ASSERT(!aTimeStamp.IsNull()); + UpdateAndRender(); + mCompositor->FlushPendingNotifyNotUsed(); + } + + mTarget = nullptr; + +#ifdef MOZ_LAYERS_HAVE_LOG + Log(); + MOZ_LAYERS_LOG(("]----- EndTransaction")); +#endif +} + +void LayerManagerComposite::SetRoot(Layer* aLayer) { mRoot = aLayer; } + +void LayerManagerComposite::UpdateAndRender() { + mCompositionOpportunityId = mCompositionOpportunityId.Next(); + + if (gfxEnv::SkipComposition()) { + mInvalidRegion.SetEmpty(); + return; + } + + // The results of our drawing always go directly into a pixel buffer, + // so we don't need to pass any global transform here. + mRoot->ComputeEffectiveTransforms(gfx::Matrix4x4()); + + nsIntRegion opaque; + PostProcessLayers(opaque); + + if (mClonedLayerTreeProperties) { + // We need to compute layer tree differences even if we're not going to + // immediately use the resulting damage area, since ComputeDifferences + // is also responsible for invalidates intermediate surfaces in + // ContainerLayers. + + nsIntRegion changed; + const bool overflowed = !mClonedLayerTreeProperties->ComputeDifferences( + mRoot, changed, nullptr); + + if (overflowed) { + changed = mRenderBounds; + } + + mInvalidRegion.Or(mInvalidRegion, changed); + } + + nsIntRegion invalid; + if (mTarget) { + // Since we're composing to an external target, we're not going to use + // the damage region from layers changes - we want to composite + // everything in the target bounds. The layers damage region has been + // stored in mInvalidRegion and will be picked up by the next window + // composite. + invalid = mTargetBounds; + } else { + if (!mClonedLayerTreeProperties) { + // If we didn't have a previous layer tree, invalidate the entire render + // area. + mInvalidRegion = mRenderBounds; + } + + invalid = mInvalidRegion; + } + + if (invalid.IsEmpty()) { + // Composition requested, but nothing has changed. Don't do any work. + mClonedLayerTreeProperties = LayerProperties::CloneFrom(GetRoot()); + mProfilerScreenshotGrabber.NotifyEmptyFrame(); + + // Discard the current payloads. These payloads did not require a composite + // (they caused no changes to anything visible), so we don't want to measure + // their latency. + mPayload.Clear(); + + return; + } + + // We don't want our debug overlay to cause more frames to happen + // so we will invalidate after we've decided if something changed. + // Only invalidate if we're not using native layers. When using native layers, + // UpdateDebugOverlayNativeLayers will repaint the appropriate layer areas. + if (!mNativeLayerRoot) { + InvalidateDebugOverlay(invalid, mRenderBounds); + } + + bool rendered = Render(invalid, opaque); +#if defined(MOZ_WIDGET_ANDROID) + RenderToPresentationSurface(); +#endif + + if (!mTarget && rendered) { + mInvalidRegion.SetEmpty(); + } + + // Update cached layer tree information. + mClonedLayerTreeProperties = LayerProperties::CloneFrom(GetRoot()); +} + +already_AddRefed<DrawTarget> LayerManagerComposite::CreateOptimalMaskDrawTarget( + const IntSize& aSize) { + MOZ_CRASH("Should only be called on the drawing side"); + return nullptr; +} + +LayerComposite* LayerManagerComposite::RootLayer() const { + if (mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + + return ToLayerComposite(mRoot); +} + +void LayerManagerComposite::InvalidateDebugOverlay(nsIntRegion& aInvalidRegion, + const IntRect& aBounds) { + bool drawFps = StaticPrefs::layers_acceleration_draw_fps(); + bool drawFrameColorBars = StaticPrefs::gfx_draw_color_bars(); + + if (drawFps) { + aInvalidRegion.Or(aInvalidRegion, nsIntRect(0, 0, 650, 400)); + } + if (drawFrameColorBars) { + aInvalidRegion.Or(aInvalidRegion, nsIntRect(0, 0, 10, aBounds.Height())); + } + +#ifdef USE_SKIA + bool drawPaintTimes = StaticPrefs::gfx_content_always_paint(); + if (drawPaintTimes) { + aInvalidRegion.Or(aInvalidRegion, nsIntRect(PaintCounter::GetPaintRect())); + } +#endif +} + +#ifdef USE_SKIA +void LayerManagerComposite::DrawPaintTimes(Compositor* aCompositor) { + if (!mPaintCounter) { + mPaintCounter = new PaintCounter(); + } + + TimeDuration compositeTime = TimeStamp::Now() - mRenderStartTime; + mPaintCounter->Draw(aCompositor, mLastPaintTime, compositeTime); +} +#endif + +static Rect RectWithEdges(int32_t aTop, int32_t aRight, int32_t aBottom, + int32_t aLeft) { + return Rect(aLeft, aTop, aRight - aLeft, aBottom - aTop); +} + +void LayerManagerComposite::DrawBorder(const IntRect& aOuter, + int32_t aBorderWidth, + const DeviceColor& aColor, + const Matrix4x4& aTransform) { + EffectChain effects; + effects.mPrimaryEffect = new EffectSolidColor(aColor); + + IntRect inner(aOuter); + inner.Deflate(aBorderWidth); + // Top and bottom border sides + mCompositor->DrawQuad( + RectWithEdges(aOuter.Y(), aOuter.XMost(), inner.Y(), aOuter.X()), aOuter, + effects, 1, aTransform); + mCompositor->DrawQuad( + RectWithEdges(inner.YMost(), aOuter.XMost(), aOuter.YMost(), aOuter.X()), + aOuter, effects, 1, aTransform); + // Left and right border sides + mCompositor->DrawQuad( + RectWithEdges(inner.Y(), inner.X(), inner.YMost(), aOuter.X()), aOuter, + effects, 1, aTransform); + mCompositor->DrawQuad( + RectWithEdges(inner.Y(), aOuter.XMost(), inner.YMost(), inner.XMost()), + aOuter, effects, 1, aTransform); +} + +void LayerManagerComposite::DrawTranslationWarningOverlay( + const IntRect& aBounds) { + // Black blorder + IntRect blackBorderBounds(aBounds); + blackBorderBounds.Deflate(4); + DrawBorder(blackBorderBounds, 6, DeviceColor(0, 0, 0, 1), Matrix4x4()); + + // Warning border, yellow to red + IntRect warnBorder(aBounds); + warnBorder.Deflate(5); + DrawBorder(warnBorder, 4, DeviceColor(1, 1.f - mWarningLevel, 0, 1), + Matrix4x4()); +} + +static uint16_t sFrameCount = 0; +void LayerManagerComposite::RenderDebugOverlay(const IntRect& aBounds) { + bool drawFps = StaticPrefs::layers_acceleration_draw_fps(); + bool drawFrameColorBars = StaticPrefs::gfx_draw_color_bars(); + + // Don't draw diagnostic overlays if we want to snapshot the output. + if (mTarget) { + return; + } + + if (drawFps) { +#ifdef ANDROID + // Draw a translation delay warning overlay + if (!mWarnTime.IsNull() && (TimeStamp::Now() - mWarnTime).ToMilliseconds() < + kVisualWarningDuration) { + DrawTranslationWarningOverlay(aBounds); + SetDebugOverlayWantsNextFrame(true); + } +#endif + + GPUStats stats; + stats.mScreenPixels = mRenderBounds.Width() * mRenderBounds.Height(); + mCompositor->GetFrameStats(&stats); + + std::string text = mDiagnostics->GetFrameOverlayString(stats); + mTextRenderer->RenderText(mCompositor, text, IntPoint(2, 5), Matrix4x4(), + 24, 600, TextRenderer::FontType::FixedWidth); + + float alpha = 1; + if (mUnusedApzTransformWarning) { + // If we have an unused APZ transform on this composite, draw a 20x20 red + // box in the top-right corner + EffectChain effects; + effects.mPrimaryEffect = + new EffectSolidColor(gfx::DeviceColor(1, 0, 0, 1)); + mCompositor->DrawQuad(gfx::Rect(aBounds.Width() - 20, 0, 20, 20), aBounds, + effects, alpha, gfx::Matrix4x4()); + + mUnusedApzTransformWarning = false; + SetDebugOverlayWantsNextFrame(true); + } + if (mDisabledApzWarning) { + // If we have a disabled APZ on this composite, draw a 20x20 yellow box + // in the top-right corner, to the left of the unused-apz-transform + // warning box + EffectChain effects; + effects.mPrimaryEffect = + new EffectSolidColor(gfx::DeviceColor(1, 1, 0, 1)); + mCompositor->DrawQuad(gfx::Rect(aBounds.Width() - 40, 0, 20, 20), aBounds, + effects, alpha, gfx::Matrix4x4()); + + mDisabledApzWarning = false; + SetDebugOverlayWantsNextFrame(true); + } + } + + if (drawFrameColorBars) { + gfx::IntRect sideRect(0, 0, 10, aBounds.Height()); + + EffectChain effects; + effects.mPrimaryEffect = + new EffectSolidColor(gfxUtils::GetColorForFrameNumber(sFrameCount)); + mCompositor->DrawQuad(Rect(sideRect), sideRect, effects, 1.0, + gfx::Matrix4x4()); + + // We intentionally overflow at 2^16. + sFrameCount++; + } + +#ifdef USE_SKIA + bool drawPaintTimes = StaticPrefs::gfx_content_always_paint(); + if (drawPaintTimes) { + DrawPaintTimes(mCompositor); + } +#endif +} + +void LayerManagerComposite::UpdateDebugOverlayNativeLayers() { + // Remove all debug layers first because PlaceNativeLayers might have changed + // the z-order. By removing and re-adding, we keep the debug overlay layers + // on top. + if (mGPUStatsLayer) { + mNativeLayerRoot->RemoveLayer(mGPUStatsLayer); + } + if (mUnusedTransformWarningLayer) { + mNativeLayerRoot->RemoveLayer(mUnusedTransformWarningLayer); + } + if (mDisabledApzWarningLayer) { + mNativeLayerRoot->RemoveLayer(mDisabledApzWarningLayer); + } + + bool drawFps = StaticPrefs::layers_acceleration_draw_fps(); + + if (drawFps) { + GPUStats stats; + stats.mScreenPixels = mRenderBounds.Area(); + mCompositor->GetFrameStats(&stats); + + std::string text = mDiagnostics->GetFrameOverlayString(stats); + IntSize size = mTextRenderer->ComputeSurfaceSize( + text, 600, TextRenderer::FontType::FixedWidth); + + if (!mGPUStatsLayer || mGPUStatsLayer->GetSize() != size) { + mGPUStatsLayer = + mNativeLayerRoot->CreateLayer(size, false, mSurfacePoolHandle); + } + + mGPUStatsLayer->SetPosition(IntPoint(2, 5)); + IntRect bounds({}, size); + RefPtr<DrawTarget> dt = mGPUStatsLayer->NextSurfaceAsDrawTarget( + bounds, bounds, BackendType::SKIA); + mTextRenderer->RenderTextToDrawTarget(dt, text, 600, + TextRenderer::FontType::FixedWidth); + mGPUStatsLayer->NotifySurfaceReady(); + mNativeLayerRoot->AppendLayer(mGPUStatsLayer); + + IntSize square(20, 20); + // The two warning layers are created on demand and their content is only + // drawn once. After that, they only get moved (if the window size changes) + // and conditionally shown. + // The drawing would be unnecessary if we had native "color layers". + if (mUnusedApzTransformWarning) { + // If we have an unused APZ transform on this composite, draw a 20x20 red + // box in the top-right corner. + if (!mUnusedTransformWarningLayer) { + mUnusedTransformWarningLayer = + mNativeLayerRoot->CreateLayer(square, true, mSurfacePoolHandle); + RefPtr<DrawTarget> dt = + mUnusedTransformWarningLayer->NextSurfaceAsDrawTarget( + IntRect({}, square), IntRect({}, square), BackendType::SKIA); + dt->FillRect(Rect(0, 0, 20, 20), ColorPattern(DeviceColor(1, 0, 0, 1))); + mUnusedTransformWarningLayer->NotifySurfaceReady(); + } + mUnusedTransformWarningLayer->SetPosition( + IntPoint(mRenderBounds.XMost() - 20, mRenderBounds.Y())); + mNativeLayerRoot->AppendLayer(mUnusedTransformWarningLayer); + + mUnusedApzTransformWarning = false; + SetDebugOverlayWantsNextFrame(true); + } + + if (mDisabledApzWarning) { + // If we have a disabled APZ on this composite, draw a 20x20 yellow box + // in the top-right corner, to the left of the unused-apz-transform + // warning box. + if (!mDisabledApzWarningLayer) { + mDisabledApzWarningLayer = + mNativeLayerRoot->CreateLayer(square, true, mSurfacePoolHandle); + RefPtr<DrawTarget> dt = + mDisabledApzWarningLayer->NextSurfaceAsDrawTarget( + IntRect({}, square), IntRect({}, square), BackendType::SKIA); + dt->FillRect(Rect(0, 0, 20, 20), ColorPattern(DeviceColor(1, 1, 0, 1))); + mDisabledApzWarningLayer->NotifySurfaceReady(); + } + mDisabledApzWarningLayer->SetPosition( + IntPoint(mRenderBounds.XMost() - 40, mRenderBounds.Y())); + mNativeLayerRoot->AppendLayer(mDisabledApzWarningLayer); + + mDisabledApzWarning = false; + SetDebugOverlayWantsNextFrame(true); + } + } else { + mGPUStatsLayer = nullptr; + mUnusedTransformWarningLayer = nullptr; + mDisabledApzWarningLayer = nullptr; + } +} + +RefPtr<CompositingRenderTarget> +LayerManagerComposite::PushGroupForLayerEffects() { + // This is currently true, so just making sure that any new use of this + // method is flagged for investigation + MOZ_ASSERT(StaticPrefs::layers_effect_invert() || + StaticPrefs::layers_effect_grayscale() || + StaticPrefs::layers_effect_contrast() != 0.0); + + RefPtr<CompositingRenderTarget> previousTarget = + mCompositor->GetCurrentRenderTarget(); + // make our render target the same size as the destination target + // so that we don't have to change size if the drawing area changes. + IntRect rect(previousTarget->GetOrigin(), previousTarget->GetSize()); + // XXX: I'm not sure if this is true or not... + MOZ_ASSERT(rect.IsEqualXY(0, 0)); + if (!mTwoPassTmpTarget || + mTwoPassTmpTarget->GetSize() != previousTarget->GetSize() || + mTwoPassTmpTarget->GetOrigin() != previousTarget->GetOrigin()) { + mTwoPassTmpTarget = mCompositor->CreateRenderTarget(rect, INIT_MODE_NONE); + } + MOZ_ASSERT(mTwoPassTmpTarget); + mCompositor->SetRenderTarget(mTwoPassTmpTarget); + return previousTarget; +} + +void LayerManagerComposite::PopGroupForLayerEffects( + RefPtr<CompositingRenderTarget> aPreviousTarget, IntRect aClipRect, + bool aGrayscaleEffect, bool aInvertEffect, float aContrastEffect) { + MOZ_ASSERT(mTwoPassTmpTarget); + + // This is currently true, so just making sure that any new use of this + // method is flagged for investigation + MOZ_ASSERT(aInvertEffect || aGrayscaleEffect || aContrastEffect != 0.0); + + mCompositor->SetRenderTarget(aPreviousTarget); + + EffectChain effectChain(RootLayer()); + Matrix5x4 effectMatrix; + if (aGrayscaleEffect) { + // R' = G' = B' = luminance + // R' = 0.2126*R + 0.7152*G + 0.0722*B + // G' = 0.2126*R + 0.7152*G + 0.0722*B + // B' = 0.2126*R + 0.7152*G + 0.0722*B + Matrix5x4 grayscaleMatrix(0.2126f, 0.2126f, 0.2126f, 0, 0.7152f, 0.7152f, + 0.7152f, 0, 0.0722f, 0.0722f, 0.0722f, 0, 0, 0, 0, + 1, 0, 0, 0, 0); + effectMatrix = grayscaleMatrix; + } + + if (aInvertEffect) { + // R' = 1 - R + // G' = 1 - G + // B' = 1 - B + Matrix5x4 colorInvertMatrix(-1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, + 1, 1, 1, 1, 0); + effectMatrix = effectMatrix * colorInvertMatrix; + } + + if (aContrastEffect != 0.0) { + // Multiplying with: + // R' = (1 + c) * (R - 0.5) + 0.5 + // G' = (1 + c) * (G - 0.5) + 0.5 + // B' = (1 + c) * (B - 0.5) + 0.5 + float cP1 = aContrastEffect + 1; + float hc = 0.5 * aContrastEffect; + Matrix5x4 contrastMatrix(cP1, 0, 0, 0, 0, cP1, 0, 0, 0, 0, cP1, 0, 0, 0, 0, + 1, -hc, -hc, -hc, 0); + effectMatrix = effectMatrix * contrastMatrix; + } + + effectChain.mPrimaryEffect = new EffectRenderTarget(mTwoPassTmpTarget); + effectChain.mSecondaryEffects[EffectTypes::COLOR_MATRIX] = + new EffectColorMatrix(effectMatrix); + + mCompositor->DrawQuad(Rect(Point(0, 0), Size(mTwoPassTmpTarget->GetSize())), + aClipRect, effectChain, 1., Matrix4x4()); +} + +void LayerManagerComposite::PlaceNativeLayers( + const IntRegion& aRegion, bool aOpaque, + std::deque<RefPtr<NativeLayer>>* aLayersToRecycle, + IntRegion* aWindowInvalidRegion) { + IntSize tileSize(StaticPrefs::layers_compositing_tiles_width(), + StaticPrefs::layers_compositing_tiles_height()); + IntRect regionBounds = aRegion.GetBounds(); + for (int32_t y = 0; y < regionBounds.YMost(); y += tileSize.height) { + for (int32_t x = 0; x < regionBounds.XMost(); x += tileSize.width) { + IntRegion tileRegion; + tileRegion.And(aRegion, IntRect(IntPoint(x, y), tileSize)); + for (auto iter = tileRegion.RectIter(); !iter.Done(); iter.Next()) { + PlaceNativeLayer(iter.Get(), aOpaque, aLayersToRecycle, + aWindowInvalidRegion); + } + } + } +} + +void LayerManagerComposite::PlaceNativeLayer( + const IntRect& aRect, bool aOpaque, + std::deque<RefPtr<NativeLayer>>* aLayersToRecycle, + IntRegion* aWindowInvalidRegion) { + RefPtr<NativeLayer> layer; + if (aLayersToRecycle->empty() || + aLayersToRecycle->front()->GetSize() != aRect.Size() || + aLayersToRecycle->front()->IsOpaque() != aOpaque) { + layer = mNativeLayerRoot->CreateLayer(aRect.Size(), aOpaque, + mSurfacePoolHandle); + mNativeLayerRoot->AppendLayer(layer); + aWindowInvalidRegion->OrWith(aRect); + } else { + layer = aLayersToRecycle->front(); + aLayersToRecycle->pop_front(); + IntRect oldRect = layer->GetRect(); + if (!aRect.IsEqualInterior(oldRect)) { + aWindowInvalidRegion->OrWith(oldRect); + aWindowInvalidRegion->OrWith(aRect); + } + } + layer->SetPosition(aRect.TopLeft()); + mNativeLayers.push_back(layer); +} + +// Used to clear the 'mLayerComposited' flag at the beginning of each Render(). +static void ClearLayerFlags(Layer* aLayer) { + ForEachNode<ForwardIterator>(aLayer, [](Layer* layer) { + if (layer->AsHostLayer()) { + static_cast<LayerComposite*>(layer->AsHostLayer()) + ->SetLayerComposited(false); + } + }); +} + +bool LayerManagerComposite::Render(const nsIntRegion& aInvalidRegion, + const nsIntRegion& aOpaqueRegion) { + AUTO_PROFILER_LABEL("LayerManagerComposite::Render", GRAPHICS); + + if (mDestroyed || !mCompositor || mCompositor->IsDestroyed()) { + NS_WARNING("Call on destroyed layer manager"); + return false; + } + + mCompositor->RequestAllowFrameRecording(!!mCompositionRecorder); + + ClearLayerFlags(mRoot); + + // At this time, it doesn't really matter if these preferences change + // during the execution of the function; we should be safe in all + // permutations. However, may as well just get the values onces and + // then use them, just in case the consistency becomes important in + // the future. + bool invertVal = StaticPrefs::layers_effect_invert(); + bool grayscaleVal = StaticPrefs::layers_effect_grayscale(); + float contrastVal = StaticPrefs::layers_effect_contrast(); + bool haveLayerEffects = (invertVal || grayscaleVal || contrastVal != 0.0); + + // Set LayerScope begin/end frame + LayerScopeAutoFrame frame(PR_Now()); + + // If you're looking for the code to dump the layer tree, it was moved + // to CompositorBridgeParent::CompositeToTarget(). + + // Dump to LayerScope Viewer + if (LayerScope::CheckSendable()) { + // Create a LayersPacket, dump Layers into it and transfer the + // packet('s ownership) to LayerScope. + auto packet = MakeUnique<layerscope::Packet>(); + layerscope::LayersPacket* layersPacket = packet->mutable_layers(); + this->Dump(layersPacket); + LayerScope::SendLayerDump(std::move(packet)); + } + + mozilla::widget::WidgetRenderingContext widgetContext; +#if defined(XP_MACOSX) + if (CompositorOGL* compositorOGL = mCompositor->AsCompositorOGL()) { + widgetContext.mGL = compositorOGL->gl(); + } +#endif + + { + AUTO_PROFILER_LABEL("LayerManagerComposite::Render:Prerender", GRAPHICS); + + if (!mCompositor->GetWidget()->PreRender(&widgetContext)) { + return false; + } + } + + CompositorBench(mCompositor, mRenderBounds); + + MOZ_ASSERT(mRoot->GetOpacity() == 1); +#if defined(MOZ_WIDGET_ANDROID) + LayerMetricsWrapper wrapper = GetRootContentLayer(); + if (wrapper) { + mCompositor->SetClearColor(wrapper.Metadata().GetBackgroundColor()); + } else { + mCompositor->SetClearColorToDefault(); + } +#endif + + Maybe<IntRect> rootLayerClip = mRoot->GetClipRect().map( + [](const ParentLayerIntRect& r) { return r.ToUnknownRect(); }); + Maybe<IntRect> maybeBounds; + bool usingNativeLayers = false; + if (mTarget) { + maybeBounds = mCompositor->BeginFrameForTarget( + aInvalidRegion, rootLayerClip, mRenderBounds, aOpaqueRegion, mTarget, + mTargetBounds); + } else if (mNativeLayerRoot) { + mSurfacePoolHandle->OnBeginFrame(); + if (aInvalidRegion.Intersects(mRenderBounds)) { + mCompositor->BeginFrameForNativeLayers(); + maybeBounds = Some(mRenderBounds); + usingNativeLayers = true; + } + } else { + maybeBounds = mCompositor->BeginFrameForWindow( + aInvalidRegion, rootLayerClip, mRenderBounds, aOpaqueRegion); + } + + if (!maybeBounds) { + mProfilerScreenshotGrabber.NotifyEmptyFrame(); + mCompositor->GetWidget()->PostRender(&widgetContext); + + // Discard the current payloads. These payloads did not require a composite + // (they caused no changes to anything visible), so we don't want to measure + // their latency. + mPayload.Clear(); + + return true; + } + + IntRect bounds = *maybeBounds; + IntRect clipRect = rootLayerClip.valueOr(bounds); + + // Prepare our layers. + { + Diagnostics::Record record(mRenderStartTime); + RootLayer()->Prepare(RenderTargetIntRect::FromUnknownRect(clipRect)); + if (record.Recording()) { + mDiagnostics->RecordPrepareTime(record.Duration()); + } + } + + auto RenderOnce = [&](const IntRect& aClipRect) { + RefPtr<CompositingRenderTarget> previousTarget; + if (haveLayerEffects) { + previousTarget = PushGroupForLayerEffects(); + } else { + mTwoPassTmpTarget = nullptr; + } + + // Execute draw commands. + RootLayer()->RenderLayer(aClipRect, Nothing()); + + if (mTwoPassTmpTarget) { + MOZ_ASSERT(haveLayerEffects); + PopGroupForLayerEffects(previousTarget, aClipRect, grayscaleVal, + invertVal, contrastVal); + } + if (!mRegionToClear.IsEmpty()) { + for (auto iter = mRegionToClear.RectIter(); !iter.Done(); iter.Next()) { + mCompositor->ClearRect(Rect(iter.Get())); + } + } + mCompositor->NormalDrawingDone(); + }; + + { + Diagnostics::Record record; + + if (usingNativeLayers) { + // Update the placement of our native layers, so that transparent and + // opaque parts of the window are covered by different layers and we can + // update those parts separately. + IntRegion opaqueRegion; + opaqueRegion.And(aOpaqueRegion, mRenderBounds); + + // Limit the complexity of these regions. Usually, opaqueRegion should be + // only one or two rects, so this SimplifyInward call will not change the + // region if everything looks as expected. + opaqueRegion.SimplifyInward(4); + + IntRegion transparentRegion; + transparentRegion.Sub(mRenderBounds, opaqueRegion); + std::deque<RefPtr<NativeLayer>> layersToRecycle = + std::move(mNativeLayers); + IntRegion invalidRegion = aInvalidRegion; + PlaceNativeLayers(opaqueRegion, true, &layersToRecycle, &invalidRegion); + PlaceNativeLayers(transparentRegion, false, &layersToRecycle, + &invalidRegion); + for (const auto& unusedLayer : layersToRecycle) { + mNativeLayerRoot->RemoveLayer(unusedLayer); + } + + for (const auto& nativeLayer : mNativeLayers) { + Maybe<IntRect> maybeLayerRect = + mCompositor->BeginRenderingToNativeLayer( + invalidRegion, rootLayerClip, aOpaqueRegion, nativeLayer); + if (!maybeLayerRect) { + continue; + } + + if (rootLayerClip) { + RenderOnce(rootLayerClip->Intersect(*maybeLayerRect)); + } else { + RenderOnce(*maybeLayerRect); + } + mCompositor->EndRenderingToNativeLayer(); + } + } else { + RenderOnce(clipRect); + } + + if (record.Recording()) { + mDiagnostics->RecordCompositeTime(record.Duration()); + } + } + + RootLayer()->Cleanup(); + + WindowLMC window(mCompositor); + mProfilerScreenshotGrabber.MaybeGrabScreenshot(window, bounds.Size()); + + if (mCompositionRecorder) { + bool hasContentPaint = std::any_of( + mPayload.begin(), mPayload.end(), [](CompositionPayload& payload) { + return payload.mType == CompositionPayloadType::eContentPaint; + }); + + if (hasContentPaint) { + if (RefPtr<RecordedFrame> frame = + mCompositor->RecordFrame(TimeStamp::Now())) { + mCompositionRecorder->RecordFrame(frame); + } + } + } + + if (usingNativeLayers) { + UpdateDebugOverlayNativeLayers(); + } else { +#if defined(MOZ_WIDGET_ANDROID) + HandlePixelsTarget(); +#endif // defined(MOZ_WIDGET_ANDROID) + + // Debugging + RenderDebugOverlay(bounds); + } + + { + AUTO_PROFILER_LABEL("LayerManagerComposite::Render:EndFrame", GRAPHICS); + + mCompositor->EndFrame(); + + if (usingNativeLayers) { + mNativeLayerRoot->CommitToScreen(); + } + } + + mCompositor->GetWidget()->PostRender(&widgetContext); + + mProfilerScreenshotGrabber.MaybeProcessQueue(); + + RecordFrame(); + + PayloadPresented(TimeStamp::Now()); + + // Our payload has now been presented. + mPayload.Clear(); + + if (usingNativeLayers) { + mSurfacePoolHandle->OnEndFrame(); + } + + mCompositor->WaitForGPU(); + + return true; +} + +#if defined(MOZ_WIDGET_ANDROID) +class ScopedCompostitorSurfaceSize { + public: + ScopedCompostitorSurfaceSize(CompositorOGL* aCompositor, + const gfx::IntSize& aSize) + : mCompositor(aCompositor), + mOriginalSize(mCompositor->GetDestinationSurfaceSize()) { + mCompositor->SetDestinationSurfaceSize(aSize); + } + ~ScopedCompostitorSurfaceSize() { + mCompositor->SetDestinationSurfaceSize(mOriginalSize); + } + + private: + CompositorOGL* const mCompositor; + const gfx::IntSize mOriginalSize; +}; + +class ScopedContextSurfaceOverride { + public: + ScopedContextSurfaceOverride(GLContextEGL* aContext, void* aSurface) + : mContext(aContext) { + MOZ_ASSERT(aSurface); + mContext->SetEGLSurfaceOverride(aSurface); + mContext->MakeCurrent(true); + } + ~ScopedContextSurfaceOverride() { + mContext->SetEGLSurfaceOverride(EGL_NO_SURFACE); + mContext->MakeCurrent(true); + } + + private: + GLContextEGL* const mContext; +}; + +void LayerManagerComposite::RenderToPresentationSurface() { + if (!mCompositor) { + return; + } + + widget::CompositorWidget* const widget = mCompositor->GetWidget(); + + if (!widget) { + return; + } + + ANativeWindow* window = widget->AsAndroid()->GetPresentationANativeWindow(); + + if (!window) { + return; + } + + CompositorOGL* compositor = mCompositor->AsCompositorOGL(); + GLContext* gl = compositor->gl(); + GLContextEGL* egl = GLContextEGL::Cast(gl); + + if (!egl) { + return; + } + + EGLSurface surface = widget->AsAndroid()->GetPresentationEGLSurface(); + + if (!surface) { + // create surface; + surface = egl->CreateCompatibleSurface(window); + if (!surface) { + return; + } + + widget->AsAndroid()->SetPresentationEGLSurface(surface); + } + + const IntSize windowSize(ANativeWindow_getWidth(window), + ANativeWindow_getHeight(window)); + + if ((windowSize.width <= 0) || (windowSize.height <= 0)) { + return; + } + + ScreenRotation rotation = compositor->GetScreenRotation(); + + const int actualWidth = windowSize.width; + const int actualHeight = windowSize.height; + + const gfx::IntSize originalSize = compositor->GetDestinationSurfaceSize(); + const nsIntRect originalRect = + nsIntRect(0, 0, originalSize.width, originalSize.height); + + int pageWidth = originalSize.width; + int pageHeight = originalSize.height; + if (rotation == ROTATION_90 || rotation == ROTATION_270) { + pageWidth = originalSize.height; + pageHeight = originalSize.width; + } + + float scale = 1.0; + + if ((pageWidth > actualWidth) || (pageHeight > actualHeight)) { + const float scaleWidth = (float)actualWidth / (float)pageWidth; + const float scaleHeight = (float)actualHeight / (float)pageHeight; + scale = scaleWidth <= scaleHeight ? scaleWidth : scaleHeight; + } + + const gfx::IntSize actualSize(actualWidth, actualHeight); + ScopedCompostitorSurfaceSize overrideSurfaceSize(compositor, actualSize); + + const ScreenPoint offset((actualWidth - (int)(scale * pageWidth)) / 2, 0); + ScopedContextSurfaceOverride overrideSurface(egl, surface); + + Matrix viewMatrix = ComputeTransformForRotation(originalRect, rotation); + viewMatrix.Invert(); // unrotate + viewMatrix.PostScale(scale, scale); + viewMatrix.PostTranslate(offset.x, offset.y); + Matrix4x4 matrix = Matrix4x4::From2D(viewMatrix); + + mRoot->ComputeEffectiveTransforms(matrix); + nsIntRegion opaque; + PostProcessLayers(opaque); + + nsIntRegion invalid; + IntRect bounds = IntRect::Truncate(0, 0, scale * pageWidth, actualHeight); + MOZ_ASSERT(mRoot->GetOpacity() == 1); + Unused << mCompositor->BeginFrameForWindow(invalid, Nothing(), bounds, + nsIntRegion()); + + // The Java side of Fennec sets a scissor rect that accounts for + // chrome such as the URL bar. Override that so that the entire frame buffer + // is cleared. + ScopedScissorRect scissorRect(egl, 0, 0, actualWidth, actualHeight); + egl->fClearColor(0.0, 0.0, 0.0, 0.0); + egl->fClear(LOCAL_GL_COLOR_BUFFER_BIT); + + const IntRect clipRect = IntRect::Truncate(0, 0, actualWidth, actualHeight); + + RootLayer()->Prepare(RenderTargetIntRect::FromUnknownRect(clipRect)); + RootLayer()->RenderLayer(clipRect, Nothing()); + + mCompositor->EndFrame(); +} + +// Used by robocop tests to get a snapshot of the frame buffer. +void LayerManagerComposite::HandlePixelsTarget() { + if (!mScreenPixelsTarget) { + return; + } + + int32_t bufferWidth = mRenderBounds.width; + int32_t bufferHeight = mRenderBounds.height; + ipc::Shmem mem; + if (!mScreenPixelsTarget->AllocPixelBuffer( + bufferWidth * bufferHeight * sizeof(uint32_t), &mem)) { + // Failed to alloc shmem, Just bail out. + return; + } + CompositorOGL* compositor = mCompositor->AsCompositorOGL(); + GLContext* gl = compositor->gl(); + MOZ_ASSERT(gl); + gl->fReadPixels(0, 0, bufferWidth, bufferHeight, LOCAL_GL_RGBA, + LOCAL_GL_UNSIGNED_BYTE, mem.get<uint8_t>()); + Unused << mScreenPixelsTarget->SendScreenPixels( + std::move(mem), ScreenIntSize(bufferWidth, bufferHeight), true); + mScreenPixelsTarget = nullptr; +} +#endif + +already_AddRefed<PaintedLayer> LayerManagerComposite::CreatePaintedLayer() { + if (mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + return RefPtr<PaintedLayer>(new PaintedLayerComposite(this)).forget(); +} + +already_AddRefed<ContainerLayer> LayerManagerComposite::CreateContainerLayer() { + if (mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + return RefPtr<ContainerLayer>(new ContainerLayerComposite(this)).forget(); +} + +already_AddRefed<ImageLayer> LayerManagerComposite::CreateImageLayer() { + if (mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + return RefPtr<ImageLayer>(new ImageLayerComposite(this)).forget(); +} + +already_AddRefed<ColorLayer> LayerManagerComposite::CreateColorLayer() { + if (LayerManagerComposite::mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + return RefPtr<ColorLayer>(new ColorLayerComposite(this)).forget(); +} + +already_AddRefed<CanvasLayer> LayerManagerComposite::CreateCanvasLayer() { + if (LayerManagerComposite::mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + return RefPtr<CanvasLayer>(new CanvasLayerComposite(this)).forget(); +} + +already_AddRefed<RefLayer> LayerManagerComposite::CreateRefLayer() { + if (LayerManagerComposite::mDestroyed) { + NS_WARNING("Call on destroyed layer manager"); + return nullptr; + } + return RefPtr<RefLayer>(new RefLayerComposite(this)).forget(); +} + +LayerManagerComposite::AutoAddMaskEffect::AutoAddMaskEffect( + Layer* aMaskLayer, EffectChain& aEffects) + : mCompositable(nullptr), mFailed(false) { + if (!aMaskLayer) { + return; + } + + mCompositable = ToLayerComposite(aMaskLayer)->GetCompositableHost(); + if (!mCompositable) { + NS_WARNING("Mask layer with no compositable host"); + mFailed = true; + return; + } + + if (!mCompositable->AddMaskEffect(aEffects, + aMaskLayer->GetEffectiveTransform())) { + mCompositable = nullptr; + mFailed = true; + } +} + +LayerManagerComposite::AutoAddMaskEffect::~AutoAddMaskEffect() { + if (!mCompositable) { + return; + } + + mCompositable->RemoveMaskEffect(); +} + +bool LayerManagerComposite::IsCompositingToScreen() const { return !mTarget; } + +LayerComposite::LayerComposite(LayerManagerComposite* aManager) + : HostLayer(aManager), + mCompositeManager(aManager), + mCompositor(aManager->GetCompositor()), + mDestroyed(false), + mLayerComposited(false) {} + +LayerComposite::~LayerComposite() = default; + +void LayerComposite::Destroy() { + if (!mDestroyed) { + mDestroyed = true; + CleanupResources(); + } +} + +void LayerComposite::AddBlendModeEffect(EffectChain& aEffectChain) { + gfx::CompositionOp blendMode = GetLayer()->GetEffectiveMixBlendMode(); + if (blendMode == gfx::CompositionOp::OP_OVER) { + return; + } + + aEffectChain.mSecondaryEffects[EffectTypes::BLEND_MODE] = + new EffectBlendMode(blendMode); +} + +bool LayerManagerComposite::CanUseCanvasLayerForSize(const IntSize& aSize) { + return mCompositor->CanUseCanvasLayerForSize( + gfx::IntSize(aSize.width, aSize.height)); +} + +void LayerManagerComposite::NotifyShadowTreeTransaction() { + if (StaticPrefs::layers_acceleration_draw_fps()) { + mDiagnostics->AddTxnFrame(); + } +} + +void LayerComposite::SetLayerManager(HostLayerManager* aManager) { + HostLayer::SetLayerManager(aManager); + mCompositeManager = static_cast<LayerManagerComposite*>(aManager); + mCompositor = mCompositeManager->GetCompositor(); +} + +bool LayerManagerComposite::AsyncPanZoomEnabled() const { + if (CompositorBridgeParent* bridge = + mCompositor->GetCompositorBridgeParent()) { + return bridge->GetOptions().UseAPZ(); + } + return false; +} + +bool LayerManagerComposite::AlwaysScheduleComposite() const { + return !!(mCompositor->GetDiagnosticTypes() & DiagnosticTypes::FLASH_BORDERS); +} + +nsIntRegion LayerComposite::GetFullyRenderedRegion() { + if (TiledContentHost* tiled = + GetCompositableHost() ? GetCompositableHost()->AsTiledContentHost() + : nullptr) { + nsIntRegion shadowVisibleRegion = + GetShadowVisibleRegion().ToUnknownRegion(); + // Discard the region which hasn't been drawn yet when doing + // progressive drawing. Note that if the shadow visible region + // shrunk the tiled valig region may not have discarded this yet. + shadowVisibleRegion.And(shadowVisibleRegion, tiled->GetValidRegion()); + return shadowVisibleRegion; + } else { + return GetShadowVisibleRegion().ToUnknownRegion(); + } +} + +Matrix4x4 HostLayer::GetShadowTransform() { + Matrix4x4 transform = mShadowTransform; + Layer* layer = GetLayer(); + + transform.PostScale(layer->GetPostXScale(), layer->GetPostYScale(), 1.0f); + if (const ContainerLayer* c = layer->AsContainerLayer()) { + transform.PreScale(c->GetPreXScale(), c->GetPreYScale(), 1.0f); + } + + return transform; +} + +// Async animations can move child layers without updating our visible region. +// PostProcessLayers will recompute visible regions for layers with an +// intermediate surface, but otherwise we need to do it now. +static void ComputeVisibleRegionForChildren(ContainerLayer* aContainer, + LayerIntRegion& aResult) { + for (Layer* l = aContainer->GetFirstChild(); l; l = l->GetNextSibling()) { + if (l->Extend3DContext()) { + MOZ_ASSERT(l->AsContainerLayer()); + ComputeVisibleRegionForChildren(l->AsContainerLayer(), aResult); + } else { + AddTransformedRegion(aResult, l->GetLocalVisibleRegion(), + l->ComputeTransformToPreserve3DRoot()); + } + } +} + +void HostLayer::RecomputeShadowVisibleRegionFromChildren() { + mShadowVisibleRegion.SetEmpty(); + ContainerLayer* container = GetLayer()->AsContainerLayer(); + MOZ_ASSERT(container); + // Layers that extend a 3d context have a local visible region + // that can only be represented correctly in 3d space. Since + // we can't do that, leave it empty instead to stop anyone + // from trying to use it. + NS_ASSERTION( + !GetLayer()->Extend3DContext(), + "Can't compute visible region for layers that extend a 3d context"); + if (container && !GetLayer()->Extend3DContext()) { + ComputeVisibleRegionForChildren(container, mShadowVisibleRegion); + } +} + +bool LayerComposite::HasStaleCompositor() const { + return mCompositeManager->GetCompositor() != mCompositor; +} + +#ifndef MOZ_HAVE_PLATFORM_SPECIFIC_LAYER_BUFFERS + +/*static*/ +bool LayerManagerComposite::SupportsDirectTexturing() { return false; } + +/*static*/ +void LayerManagerComposite::PlatformSyncBeforeReplyUpdate() {} + +#endif // !defined(MOZ_HAVE_PLATFORM_SPECIFIC_LAYER_BUFFERS) + +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<CompositingRenderTarget> 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<profiler_screenshots::RenderSource> 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<CompositingRenderTarget> previousTarget = + mCompositor->GetCurrentRenderTarget(); + + mCompositor->SetRenderTarget(mRenderSource->RenderTarget()); + bool result = mCompositor->BlitRenderTarget( + static_cast<RenderSourceLMC*>(aSource)->RenderTarget(), + aSourceRect.Size(), aDestRect.Size()); + + // Restore the old render target. + mCompositor->SetRenderTarget(previousTarget); + + return result; + } + + protected: + virtual ~DownscaleTargetLMC() {} + + RefPtr<RenderSourceLMC> 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<RenderSourceLMC*>(aSource)->RenderTarget(), mARB); + } + bool MapAndCopyInto(DataSourceSurface* aSurface, + const IntSize& aReadSize) override { + return mARB->MapAndCopyInto(aSurface, aReadSize); + } + + protected: + virtual ~AsyncReadbackBufferLMC() {} + + RefPtr<mozilla::layers::AsyncReadbackBuffer> mARB; + Compositor* mCompositor; +}; + +already_AddRefed<profiler_screenshots::RenderSource> +WindowLMC::GetWindowContents(const gfx::IntSize& aWindowSize) { + RefPtr<CompositingRenderTarget> rt = mCompositor->GetWindowRenderTarget(); + if (!rt) { + return nullptr; + } + return MakeAndAddRef<RenderSourceLMC>(rt); +} + +already_AddRefed<profiler_screenshots::DownscaleTarget> +WindowLMC::CreateDownscaleTarget(const gfx::IntSize& aSize) { + RefPtr<CompositingRenderTarget> rt = + mCompositor->CreateRenderTarget(IntRect({}, aSize), INIT_MODE_NONE); + return MakeAndAddRef<DownscaleTargetLMC>(rt, mCompositor); +} + +already_AddRefed<profiler_screenshots::AsyncReadbackBuffer> +WindowLMC::CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) { + RefPtr<AsyncReadbackBuffer> carb = + mCompositor->CreateAsyncReadbackBuffer(aSize); + if (!carb) { + return nullptr; + } + return MakeAndAddRef<AsyncReadbackBufferLMC>(carb, mCompositor); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/LayerManagerComposite.h b/gfx/layers/composite/LayerManagerComposite.h new file mode 100644 index 0000000000..18f8f0aea9 --- /dev/null +++ b/gfx/layers/composite/LayerManagerComposite.h @@ -0,0 +1,729 @@ +/* -*- 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_LayerManagerComposite_H +#define GFX_LayerManagerComposite_H + +#include <cstdint> // for uint64_t, int32_t +#include <deque> // for deque +#include <new> // for operator new +#include <type_traits> // for remove_reference<>::type +#include <utility> // for move, forward +#include "CompositableHost.h" // for ImageCompositeNotificationInfo +#include "Units.h" // for LayerIntRegion, ParentLayerIntRect, RenderTargetIntRect +#include "mozilla/AlreadyAddRefed.h" // for already_AddRefed +#include "mozilla/Assertions.h" // for MOZ_CRASH, AssertionConditionType, MOZ_ASSERT, MOZ_AS... +#include "mozilla/Maybe.h" // for Maybe +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/TimeStamp.h" // for TimeStamp, BaseTimeDuration +#include "mozilla/UniquePtr.h" // for UniquePtr +#include "mozilla/gfx/2D.h" // for DrawTarget +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for IntSize +#include "mozilla/gfx/Polygon.h" // for Polygon +#include "mozilla/gfx/Rect.h" // for IntRect +#include "mozilla/gfx/Types.h" // for DeviceColor (ptr only), SurfaceFormat +#include "mozilla/layers/CompositionRecorder.h" // for CompositionRecorder, CollectedFrames (ptr only) +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorTypes.h" // for DiagnosticTypes, TextureFactoryIdentifier +#include "mozilla/layers/LayerManager.h" // for LayerManager::END_DEFAULT, LayerManager::EndTransacti... +#include "mozilla/layers/LayersTypes.h" // for CompositionOpportunityId, LayersBackend, LayersBacken... +#include "mozilla/layers/ScreenshotGrabber.h" // for ScreenshotGrabber +#include "nsDebug.h" // for NS_WARNING +#include "nsIThread.h" // for TimeDuration +#include "nsRegion.h" // for nsIntRegion +#include "nsRegionFwd.h" // for IntRegion +#include "nsStringFwd.h" // for nsCString, nsAString +#include "nsTArray.h" // for nsTArray + +class gfxContext; + +#ifdef XP_WIN +# include <windows.h> +#endif + +namespace mozilla { +namespace layers { + +class CanvasLayer; +class CanvasLayerComposite; +class ColorLayer; +class ColorLayerComposite; +class ContainerLayer; +class ContainerLayerComposite; +class Diagnostics; +struct EffectChain; +class ImageLayer; +class ImageLayerComposite; +class LayerComposite; +class NativeLayer; +class NativeLayerRoot; +class RefLayerComposite; +class PaintTiming; +class PaintedLayer; +class PaintedLayerComposite; +class RefLayer; +class SurfacePoolHandle; +class TextRenderer; +class TextureSourceProvider; +class CompositingRenderTarget; +struct FPSState; +class PaintCounter; +class LayerMLGPU; +class LayerManagerMLGPU; +class UiCompositorControllerParent; +class Layer; +struct LayerProperties; + +static const int kVisualWarningDuration = 150; // ms + +// An implementation of LayerManager that acts as a pair with ClientLayerManager +// and is mirrored across IPDL. This gets managed/updated by +// LayerTransactionParent. +class HostLayerManager : public LayerManager { + public: + HostLayerManager(); + virtual ~HostLayerManager(); + + bool BeginTransactionWithTarget(gfxContext* aTarget, + const nsCString& aURL) override { + MOZ_CRASH("GFX: Use BeginTransactionWithDrawTarget"); + } + + bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) override { + MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)"); + return false; + } + + void EndTransaction(DrawPaintedLayerCallback aCallback, void* aCallbackData, + EndTransactionFlags aFlags = END_DEFAULT) override { + MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)"); + } + + int32_t GetMaxTextureSize() const override { + MOZ_CRASH("GFX: Call on compositor, not LayerManagerComposite"); + } + + void GetBackendName(nsAString& name) override { + MOZ_CRASH("GFX: Shouldn't be called for composited layer manager"); + } + + virtual void ForcePresent() = 0; + virtual void AddInvalidRegion(const nsIntRegion& aRegion) = 0; + + virtual void NotifyShadowTreeTransaction() {} + virtual void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget, + const gfx::IntRect& aRect) = 0; + virtual Compositor* GetCompositor() const = 0; + virtual TextureSourceProvider* GetTextureSourceProvider() const = 0; + virtual void EndTransaction(const TimeStamp& aTimeStamp, + EndTransactionFlags aFlags = END_DEFAULT) = 0; + virtual void UpdateRenderBounds(const gfx::IntRect& aRect) {} + virtual void SetDiagnosticTypes(DiagnosticTypes aDiagnostics) {} + virtual void InvalidateAll() = 0; + + HostLayerManager* AsHostLayerManager() override { return this; } + virtual LayerManagerMLGPU* AsLayerManagerMLGPU() { return nullptr; } + + void ExtractImageCompositeNotifications( + nsTArray<ImageCompositeNotificationInfo>* aNotifications) { + aNotifications->AppendElements(std::move(mImageCompositeNotifications)); + } + + void AppendImageCompositeNotification( + const ImageCompositeNotificationInfo& aNotification) { + // Only send composite notifications when we're drawing to the screen, + // because that's what they mean. + // Also when we're not drawing to the screen, DidComposite will not be + // called to extract and send these notifications, so they might linger + // and contain stale ImageContainerParent pointers. + if (IsCompositingToScreen()) { + mImageCompositeNotifications.AppendElement(aNotification); + } + } + + /** + * LayerManagerComposite provides sophisticated debug overlays + * that can request a next frame. + */ + bool DebugOverlayWantsNextFrame() { return mDebugOverlayWantsNextFrame; } + void SetDebugOverlayWantsNextFrame(bool aVal) { + mDebugOverlayWantsNextFrame = aVal; + } + + /** + * Add an on frame warning. + * @param severity ranges from 0 to 1. It's used to compute the warning color. + */ + void VisualFrameWarning(float severity) { + mozilla::TimeStamp now = TimeStamp::Now(); + if (mWarnTime.IsNull() || severity > mWarningLevel || + mWarnTime + TimeDuration::FromMilliseconds(kVisualWarningDuration) < + now) { + mWarnTime = now; + mWarningLevel = severity; + } + } + + void SetPaintTime(const TimeDuration& aPaintTime) { + mLastPaintTime = aPaintTime; + } + + virtual bool AlwaysScheduleComposite() const { return false; } + virtual bool IsCompositingToScreen() const { return false; } + + void RecordPaintTimes(const PaintTiming& aTiming); + void RecordUpdateTime(float aValue); + + CompositionOpportunityId GetCompositionOpportunityId() const { + return mCompositionOpportunityId; + } + + TimeStamp GetCompositionTime() const { return mCompositionTime; } + void SetCompositionTime(TimeStamp aTimeStamp) { + mCompositionTime = aTimeStamp; + if (!mCompositionTime.IsNull() && !mCompositeUntilTime.IsNull() && + mCompositionTime >= mCompositeUntilTime) { + mCompositeUntilTime = TimeStamp(); + } + } + + void CompositeUntil(TimeStamp aTimeStamp) { + if (mCompositeUntilTime.IsNull() || mCompositeUntilTime < aTimeStamp) { + mCompositeUntilTime = aTimeStamp; + } + } + TimeStamp GetCompositeUntilTime() const { return mCompositeUntilTime; } + + // We maintaining a global mapping from ID to CompositorBridgeParent for + // async compositables. + uint64_t GetCompositorBridgeID() const { return mCompositorBridgeID; } + void SetCompositorBridgeID(uint64_t aID) { + MOZ_ASSERT(mCompositorBridgeID == 0, + "The compositor ID must be set only once."); + mCompositorBridgeID = aID; + } + + void SetCompositionRecorder(UniquePtr<CompositionRecorder> aRecorder) { + mCompositionRecorder = std::move(aRecorder); + } + + /** + * Write the frames collected by the |CompositionRecorder| to disk. + * + * If there is not currently a |CompositionRecorder|, this is a no-op. + */ + void WriteCollectedFrames(); + + Maybe<CollectedFrames> GetCollectedFrames(); + + protected: + bool mDebugOverlayWantsNextFrame; + nsTArray<ImageCompositeNotificationInfo> mImageCompositeNotifications; + // Testing property. If hardware composer is supported, this will return + // true if the last frame was deemed 'too complicated' to be rendered. + float mWarningLevel; + mozilla::TimeStamp mWarnTime; + UniquePtr<Diagnostics> mDiagnostics; + uint64_t mCompositorBridgeID; + + TimeDuration mLastPaintTime; + TimeStamp mRenderStartTime; + UniquePtr<CompositionRecorder> mCompositionRecorder = nullptr; + + // Render time for the current composition. + TimeStamp mCompositionTime; + + // CompositionOpportunityId of the current composition. + CompositionOpportunityId mCompositionOpportunityId; + + // When nonnull, during rendering, some compositable indicated that it will + // change its rendering at this time. In order not to miss it, we composite + // on every vsync until this time occurs (this is the latest such time). + TimeStamp mCompositeUntilTime; +#if defined(MOZ_WIDGET_ANDROID) + public: + // Used by UiCompositorControllerParent to set itself as the target for the + // contents of the frame buffer after a composite. + // Implemented in LayerManagerComposite + virtual void RequestScreenPixels(UiCompositorControllerParent* aController) {} +#endif // defined(MOZ_WIDGET_ANDROID) +}; + +// A layer manager implementation that uses the Compositor API +// to render layers. +class LayerManagerComposite final : public HostLayerManager { + typedef mozilla::gfx::DrawTarget DrawTarget; + typedef mozilla::gfx::IntSize IntSize; + typedef mozilla::gfx::SurfaceFormat SurfaceFormat; + + public: + explicit LayerManagerComposite(Compositor* aCompositor); + virtual ~LayerManagerComposite(); + + void Destroy() override; + + /** + * Sets the clipping region for this layer manager. This is important on + * windows because using OGL we no longer have GDI's native clipping. Therefor + * widget must tell us what part of the screen is being invalidated, + * and we should clip to this. + * + * \param aClippingRegion Region to clip to. Setting an empty region + * will disable clipping. + */ + void SetClippingRegion(const nsIntRegion& aClippingRegion) { + mClippingRegion = aClippingRegion; + } + + /** + * LayerManager implementation. + */ + LayerManagerComposite* AsLayerManagerComposite() override { return this; } + + void UpdateRenderBounds(const gfx::IntRect& aRect) override; + + bool BeginTransaction(const nsCString& aURL) override; + void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget, + const gfx::IntRect& aRect) override; + void EndTransaction(const TimeStamp& aTimeStamp, + EndTransactionFlags aFlags = END_DEFAULT) override; + virtual void EndTransaction( + DrawPaintedLayerCallback aCallback, void* aCallbackData, + EndTransactionFlags aFlags = END_DEFAULT) override { + MOZ_CRASH("GFX: Use EndTransaction(aTimeStamp)"); + } + + void SetRoot(Layer* aLayer) override; + + // XXX[nrc]: never called, we should move this logic to ClientLayerManager + // (bug 946926). + bool CanUseCanvasLayerForSize(const gfx::IntSize& aSize) override; + + void ClearCachedResources(Layer* aSubtree = nullptr) override; + + already_AddRefed<PaintedLayer> CreatePaintedLayer() override; + already_AddRefed<ContainerLayer> CreateContainerLayer() override; + already_AddRefed<ImageLayer> CreateImageLayer() override; + already_AddRefed<ColorLayer> CreateColorLayer() override; + already_AddRefed<CanvasLayer> CreateCanvasLayer() override; + already_AddRefed<RefLayer> CreateRefLayer() override; + + bool AreComponentAlphaLayersEnabled() override; + + already_AddRefed<DrawTarget> CreateOptimalMaskDrawTarget( + const IntSize& aSize) override; + + const char* Name() const override { return ""; } + bool IsCompositingToScreen() const override; + + bool AlwaysScheduleComposite() const override; + + /** + * Post-processes layers before composition. This performs the following: + * + * - Applies occlusion culling. This restricts the shadow visible region of + * layers that are covered with opaque content. |aOpaqueRegion| is the + * region already known to be covered with opaque content, in the + * post-transform coordinate space of aLayer. + * + * - Recomputes visible regions to account for async transforms. + * Each layer accumulates into |aVisibleRegion| its post-transform + * (including async transforms) visible region. + * + * - aRenderTargetClip is the exact clip required for aLayer, in the + * coordinates of the nearest render target (the same as + * GetEffectiveTransform). + * + * - aClipFromAncestors is the approximate combined clip from all + * ancestors, in the coordinate space of our parent, but maybe be an + * overestimate in the presence of complex transforms. + */ + void PostProcessLayers(nsIntRegion& aOpaqueRegion); + void PostProcessLayers(Layer* aLayer, nsIntRegion& aOpaqueRegion, + LayerIntRegion& aVisibleRegion, + const Maybe<RenderTargetIntRect>& aRenderTargetClip, + const Maybe<ParentLayerIntRect>& aClipFromAncestors, + bool aCanContributeOpaque); + + /** + * RAII helper class to add a mask effect with the compositable from + * aMaskLayer to the EffectChain aEffect and notify the compositable when we + * are done. + */ + class AutoAddMaskEffect { + public: + AutoAddMaskEffect(Layer* aMaskLayer, EffectChain& aEffect); + ~AutoAddMaskEffect(); + + bool Failed() const { return mFailed; } + + private: + CompositableHost* mCompositable; + bool mFailed; + }; + + /** + * returns true if PlatformAllocBuffer will return a buffer that supports + * direct texturing + */ + static bool SupportsDirectTexturing(); + + static void PlatformSyncBeforeReplyUpdate(); + + void AddInvalidRegion(const nsIntRegion& aRegion) override { + mInvalidRegion.Or(mInvalidRegion, aRegion); + } + + Compositor* GetCompositor() const override { return mCompositor; } + TextureSourceProvider* GetTextureSourceProvider() const override { + return mCompositor; + } + + void NotifyShadowTreeTransaction() override; + + TextRenderer* GetTextRenderer() { return mTextRenderer; } + + void UnusedApzTransformWarning() { mUnusedApzTransformWarning = true; } + void DisabledApzWarning() { mDisabledApzWarning = true; } + + bool AsyncPanZoomEnabled() const override; + + public: + TextureFactoryIdentifier GetTextureFactoryIdentifier() override { + return mCompositor->GetTextureFactoryIdentifier(); + } + LayersBackend GetBackendType() override { + return mCompositor ? mCompositor->GetBackendType() + : LayersBackend::LAYERS_NONE; + } + void SetDiagnosticTypes(DiagnosticTypes aDiagnostics) override { + mCompositor->SetDiagnosticTypes(aDiagnostics); + } + + void InvalidateAll() override { + AddInvalidRegion(nsIntRegion(mRenderBounds)); + } + + void ForcePresent() override { mCompositor->ForcePresent(); } + + private: + /** Region we're clipping our current drawing to. */ + nsIntRegion mClippingRegion; + gfx::IntRect mRenderBounds; + + /** Current root layer. */ + LayerComposite* RootLayer() const; + + /** + * Update the invalid region and render it. + */ + void UpdateAndRender(); + + /** + * Render the current layer tree to the active target. + * Returns true if the current invalid region can be cleared, false if + * rendering was canceled. + */ + bool Render(const nsIntRegion& aInvalidRegion, + const nsIntRegion& aOpaqueRegion); +#if defined(MOZ_WIDGET_ANDROID) + void RenderToPresentationSurface(); + // Shifts the content down so the toolbar does not cover it. + // Returns the Y shift of the content in screen pixels + ScreenCoord GetContentShiftForToolbar(); + // Renders the static snapshot after the content has been rendered. + void RenderToolbar(); + // Used by robocop tests to get a snapshot of the frame buffer. + void HandlePixelsTarget(); +#endif + + /** + * We need to know our invalid region before we're ready to render. + */ + void InvalidateDebugOverlay(nsIntRegion& aInvalidRegion, + const gfx::IntRect& aBounds); + + /** + * Render debug overlays such as the FPS/FrameCounter above the frame. + */ + void RenderDebugOverlay(const gfx::IntRect& aBounds); + + void DrawBorder(const gfx::IntRect& aOuter, int32_t aBorderWidth, + const gfx::DeviceColor& aColor, + const gfx::Matrix4x4& aTransform); + void DrawTranslationWarningOverlay(const gfx::IntRect& aBounds); + + void UpdateDebugOverlayNativeLayers(); + + RefPtr<CompositingRenderTarget> PushGroupForLayerEffects(); + void PopGroupForLayerEffects(RefPtr<CompositingRenderTarget> aPreviousTarget, + gfx::IntRect aClipRect, bool aGrayscaleEffect, + bool aInvertEffect, float aContrastEffect); + + /** + * Create or recycle native layers to cover aRegion or aRect. + * This method takes existing layers from the front of aLayersToRecycle (or + * creates new layers if no layers are left to recycle) and appends them to + * the end of mNativeLayers. The "take from front, add to back" approach keeps + * the layer to rect assignment stable between frames. + * Updates the rect and opaqueness on the layers. For layers that moved or + * resized, *aWindowInvalidRegion is updated to include the area impacted by + * the move. + * Any layers left in aLayersToRecycle are not needed and can be disposed of. + */ + void PlaceNativeLayers(const gfx::IntRegion& aRegion, bool aOpaque, + std::deque<RefPtr<NativeLayer>>* aLayersToRecycle, + gfx::IntRegion* aWindowInvalidRegion); + void PlaceNativeLayer(const gfx::IntRect& aRect, bool aOpaque, + std::deque<RefPtr<NativeLayer>>* aLayersToRecycle, + gfx::IntRegion* aWindowInvalidRegion); + + bool mUnusedApzTransformWarning; + bool mDisabledApzWarning; + RefPtr<Compositor> mCompositor; + UniquePtr<LayerProperties> mClonedLayerTreeProperties; + + /** + * Context target, nullptr when drawing directly to our swap chain. + */ + RefPtr<gfx::DrawTarget> mTarget; + gfx::IntRect mTargetBounds; + + nsIntRegion mInvalidRegion; + + bool mInTransaction; + bool mIsCompositorReady; + + RefPtr<CompositingRenderTarget> mTwoPassTmpTarget; + ScreenshotGrabber mProfilerScreenshotGrabber; + RefPtr<TextRenderer> mTextRenderer; + RefPtr<NativeLayerRoot> mNativeLayerRoot; + RefPtr<SurfacePoolHandle> mSurfacePoolHandle; + std::deque<RefPtr<NativeLayer>> mNativeLayers; + RefPtr<NativeLayer> mGPUStatsLayer; + RefPtr<NativeLayer> mUnusedTransformWarningLayer; + RefPtr<NativeLayer> mDisabledApzWarningLayer; + +#ifdef USE_SKIA + /** + * Render paint and composite times above the frame. + */ + void DrawPaintTimes(Compositor* aCompositor); + RefPtr<PaintCounter> mPaintCounter; +#endif +#if defined(MOZ_WIDGET_ANDROID) + public: + virtual void RequestScreenPixels( + UiCompositorControllerParent* aController) override { + mScreenPixelsTarget = aController; + } + + private: + UiCompositorControllerParent* mScreenPixelsTarget; +#endif // defined(MOZ_WIDGET_ANDROID) +}; + +/** + * Compositor layers are for use with OMTC on the compositor thread only. There + * must be corresponding Client layers on the content thread. For composite + * layers, the layer manager only maintains the layer tree. + */ +class HostLayer { + public: + explicit HostLayer(HostLayerManager* aManager) + : mCompositorManager(aManager), + mShadowOpacity(1.0), + mShadowTransformSetByAnimation(false), + mShadowOpacitySetByAnimation(false) {} + + virtual void SetLayerManager(HostLayerManager* aManager) { + mCompositorManager = aManager; + } + HostLayerManager* GetLayerManager() const { return mCompositorManager; } + + virtual ~HostLayer() = default; + + virtual LayerComposite* GetFirstChildComposite() { return nullptr; } + + virtual Layer* GetLayer() = 0; + + virtual LayerMLGPU* AsLayerMLGPU() { return nullptr; } + + virtual bool SetCompositableHost(CompositableHost*) { + // We must handle this gracefully, see bug 967824 + NS_WARNING( + "called SetCompositableHost for a layer type not accepting a " + "compositable"); + return false; + } + virtual CompositableHost* GetCompositableHost() = 0; + + /** + * The following methods are + * + * CONSTRUCTION PHASE ONLY + * + * They are analogous to the Layer interface. + */ + void SetShadowVisibleRegion(const LayerIntRegion& aRegion) { + mShadowVisibleRegion = aRegion; + } + void SetShadowVisibleRegion(LayerIntRegion&& aRegion) { + mShadowVisibleRegion = std::move(aRegion); + } + + void SetShadowOpacity(float aOpacity) { mShadowOpacity = aOpacity; } + void SetShadowOpacitySetByAnimation(bool aSetByAnimation) { + mShadowOpacitySetByAnimation = aSetByAnimation; + } + + void SetShadowClipRect(const Maybe<ParentLayerIntRect>& aRect) { + mShadowClipRect = aRect; + } + + void SetShadowBaseTransform(const gfx::Matrix4x4& aMatrix) { + mShadowTransform = aMatrix; + } + void SetShadowTransformSetByAnimation(bool aSetByAnimation) { + mShadowTransformSetByAnimation = aSetByAnimation; + } + + // These getters can be used anytime. + float GetShadowOpacity() { return mShadowOpacity; } + const Maybe<ParentLayerIntRect>& GetShadowClipRect() { + return mShadowClipRect; + } + virtual const LayerIntRegion& GetShadowVisibleRegion() { + return mShadowVisibleRegion; + } + const gfx::Matrix4x4& GetShadowBaseTransform() { return mShadowTransform; } + gfx::Matrix4x4 GetShadowTransform(); + bool GetShadowTransformSetByAnimation() { + return mShadowTransformSetByAnimation; + } + bool GetShadowOpacitySetByAnimation() { return mShadowOpacitySetByAnimation; } + + void RecomputeShadowVisibleRegionFromChildren(); + + protected: + HostLayerManager* mCompositorManager; + + gfx::Matrix4x4 mShadowTransform; + LayerIntRegion mShadowVisibleRegion; + Maybe<ParentLayerIntRect> mShadowClipRect; + float mShadowOpacity; + bool mShadowTransformSetByAnimation; + bool mShadowOpacitySetByAnimation; +}; + +/** + * Composite layers are for use with OMTC on the compositor thread only. There + * must be corresponding Client layers on the content thread. For composite + * layers, the layer manager only maintains the layer tree, all rendering is + * done by a Compositor (see Compositor.h). As such, composite layers are + * platform-independent and can be used on any platform for which there is a + * Compositor implementation. + * + * The composite layer tree reflects exactly the basic layer tree. To + * composite to screen, the layer manager walks the layer tree calling render + * methods which in turn call into their CompositableHosts' Composite methods. + * These call Compositor::DrawQuad to do the rendering. + * + * Mostly, layers are updated during the layers transaction. This is done from + * CompositableClient to CompositableHost without interacting with the layer. + * + * A reference to the Compositor is stored in LayerManagerComposite. + */ +class LayerComposite : public HostLayer { + public: + explicit LayerComposite(LayerManagerComposite* aManager); + + virtual ~LayerComposite(); + + void SetLayerManager(HostLayerManager* aManager) override; + + LayerComposite* GetFirstChildComposite() override { return nullptr; } + + /* Do NOT call this from the generic LayerComposite destructor. Only from the + * concrete class destructor + */ + virtual void Destroy(); + virtual void Cleanup() {} + + /** + * Perform a first pass over the layer tree to render all of the intermediate + * surfaces that we can. This allows us to avoid framebuffer switches in the + * middle of our render which is inefficient especially on mobile GPUs. This + * must be called before RenderLayer. + */ + virtual void Prepare(const RenderTargetIntRect& aClipRect) {} + + // TODO: This should also take RenderTargetIntRect like Prepare. + virtual void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) = 0; + + bool SetCompositableHost(CompositableHost*) override { + // We must handle this gracefully, see bug 967824 + NS_WARNING( + "called SetCompositableHost for a layer type not accepting a " + "compositable"); + return false; + } + + virtual void CleanupResources() = 0; + + virtual void DestroyFrontBuffer() {} + + void AddBlendModeEffect(EffectChain& aEffectChain); + + virtual void GenEffectChain(EffectChain& aEffect) {} + + void SetLayerComposited(bool value) { mLayerComposited = value; } + + void SetClearRect(const gfx::IntRect& aRect) { mClearRect = aRect; } + + bool HasLayerBeenComposited() { return mLayerComposited; } + gfx::IntRect GetClearRect() { return mClearRect; } + + // Returns false if the layer is attached to an older compositor. + bool HasStaleCompositor() const; + + /** + * Return the part of the visible region that has been fully rendered. + * While progressive drawing is in progress this region will be + * a subset of the shadow visible region. + */ + virtual nsIntRegion GetFullyRenderedRegion(); + + protected: + LayerManagerComposite* mCompositeManager; + + RefPtr<Compositor> mCompositor; + bool mDestroyed; + bool mLayerComposited; + gfx::IntRect mClearRect; +}; + +class WindowLMC : public profiler_screenshots::Window { + public: + explicit WindowLMC(Compositor* aCompositor) : mCompositor(aCompositor) {} + + 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: + Compositor* mCompositor; +}; + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_LayerManagerComposite_H */ diff --git a/gfx/layers/composite/LayerManagerCompositeUtils.h b/gfx/layers/composite/LayerManagerCompositeUtils.h new file mode 100644 index 0000000000..d349cf99fc --- /dev/null +++ b/gfx/layers/composite/LayerManagerCompositeUtils.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 GFX_LayerManagerCompositeUtils_H +#define GFX_LayerManagerCompositeUtils_H + +#include <cstddef> // for size_t +#include "Layers.h" // for Layer +#include "Units.h" // for LayerIntRegion +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/gfx/BaseRect.h" // for operator- +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Rect.h" // for IntRect, Rect, RoundedOut, IntRectTyped +#include "mozilla/layers/Compositor.h" // for Compositor, INIT_MODE_CLEAR +#include "mozilla/layers/Effects.h" // for EffectChain, EffectRenderTarget +#include "mozilla/layers/LayerManagerComposite.h" // for LayerManagerComposite::AutoAddMaskEffect, LayerComposite, LayerManagerComposite +#include "mozilla/layers/TextureHost.h" // for CompositingRenderTarget + +namespace mozilla { +namespace layers { + +// Render aLayer using aCompositor and apply all mask layers of aLayer: The +// layer's own mask layer (aLayer->GetMaskLayer()), and any ancestor mask +// layers. +// If more than one mask layer needs to be applied, we use intermediate surfaces +// (CompositingRenderTargets) for rendering, applying one mask layer at a time. +// Callers need to provide a callback function aRenderCallback that does the +// actual rendering of the source. It needs to have the following form: +// void (EffectChain& effectChain, const Rect& clipRect) +// aRenderCallback is called exactly once, inside this function, unless aLayer's +// visible region is completely clipped out (in that case, aRenderCallback won't +// be called at all). +// This function calls aLayer->AsHostLayer()->AddBlendModeEffect for the +// final rendering pass. +// +// (This function should really live in LayerManagerComposite.cpp, but we +// need to use templates for passing lambdas until bug 1164522 is resolved.) +template <typename RenderCallbackType> +void RenderWithAllMasks(Layer* aLayer, Compositor* aCompositor, + const gfx::IntRect& aClipRect, + RenderCallbackType aRenderCallback) { + Layer* firstMask = nullptr; + size_t maskLayerCount = 0; + size_t nextAncestorMaskLayer = 0; + + size_t ancestorMaskLayerCount = aLayer->GetAncestorMaskLayerCount(); + if (Layer* ownMask = aLayer->GetMaskLayer()) { + firstMask = ownMask; + maskLayerCount = ancestorMaskLayerCount + 1; + nextAncestorMaskLayer = 0; + } else if (ancestorMaskLayerCount > 0) { + firstMask = aLayer->GetAncestorMaskLayerAt(0); + maskLayerCount = ancestorMaskLayerCount; + nextAncestorMaskLayer = 1; + } else { + // no mask layers at all + } + + if (maskLayerCount <= 1) { + // This is the common case. Render in one pass and return. + EffectChain effectChain(aLayer); + LayerManagerComposite::AutoAddMaskEffect autoMaskEffect(firstMask, + effectChain); + static_cast<LayerComposite*>(aLayer->AsHostLayer()) + ->AddBlendModeEffect(effectChain); + aRenderCallback(effectChain, aClipRect); + return; + } + + // We have multiple mask layers. + // We split our list of mask layers into three parts: + // (1) The first mask + // (2) The list of intermediate masks (every mask except first and last) + // (3) The final mask. + // Part (2) can be empty. + // For parts (1) and (2) we need to allocate intermediate surfaces to render + // into. The final mask gets rendered into the original render target. + + // Calculate the size of the intermediate surfaces. + gfx::Rect visibleRect( + aLayer->GetLocalVisibleRegion().GetBounds().ToUnknownRect()); + gfx::Matrix4x4 transform = aLayer->GetEffectiveTransform(); + // TODO: Use RenderTargetIntRect and TransformBy here + gfx::IntRect surfaceRect = RoundedOut( + transform.TransformAndClipBounds(visibleRect, gfx::Rect(aClipRect))); + if (surfaceRect.IsEmpty()) { + return; + } + + RefPtr<CompositingRenderTarget> originalTarget = + aCompositor->GetCurrentRenderTarget(); + + RefPtr<CompositingRenderTarget> firstTarget = + aCompositor->CreateRenderTarget(surfaceRect, INIT_MODE_CLEAR); + if (!firstTarget) { + return; + } + + // Render the source while applying the first mask. + aCompositor->SetRenderTarget(firstTarget); + { + EffectChain firstEffectChain(aLayer); + LayerManagerComposite::AutoAddMaskEffect firstMaskEffect(firstMask, + firstEffectChain); + aRenderCallback(firstEffectChain, aClipRect - surfaceRect.TopLeft()); + // firstTarget now contains the transformed source with the first mask and + // opacity already applied. + } + + // Apply the intermediate masks. + gfx::IntRect intermediateClip(surfaceRect - surfaceRect.TopLeft()); + RefPtr<CompositingRenderTarget> previousTarget = firstTarget; + for (size_t i = nextAncestorMaskLayer; i < ancestorMaskLayerCount - 1; i++) { + Layer* intermediateMask = aLayer->GetAncestorMaskLayerAt(i); + RefPtr<CompositingRenderTarget> intermediateTarget = + aCompositor->CreateRenderTarget(surfaceRect, INIT_MODE_CLEAR); + if (!intermediateTarget) { + break; + } + aCompositor->SetRenderTarget(intermediateTarget); + EffectChain intermediateEffectChain(aLayer); + LayerManagerComposite::AutoAddMaskEffect intermediateMaskEffect( + intermediateMask, intermediateEffectChain); + if (intermediateMaskEffect.Failed()) { + continue; + } + intermediateEffectChain.mPrimaryEffect = + new EffectRenderTarget(previousTarget); + aCompositor->DrawQuad(gfx::Rect(surfaceRect), intermediateClip, + intermediateEffectChain, 1.0, gfx::Matrix4x4()); + previousTarget = intermediateTarget; + } + + aCompositor->SetRenderTarget(originalTarget); + + // Apply the final mask, rendering into originalTarget. + EffectChain finalEffectChain(aLayer); + finalEffectChain.mPrimaryEffect = new EffectRenderTarget(previousTarget); + Layer* finalMask = aLayer->GetAncestorMaskLayerAt(ancestorMaskLayerCount - 1); + + // The blend mode needs to be applied in this final step, because this is + // where we're blending with the actual background (which is in + // originalTarget). + static_cast<LayerComposite*>(aLayer->AsHostLayer()) + ->AddBlendModeEffect(finalEffectChain); + LayerManagerComposite::AutoAddMaskEffect autoMaskEffect(finalMask, + finalEffectChain); + if (!autoMaskEffect.Failed()) { + aCompositor->DrawQuad(gfx::Rect(surfaceRect), aClipRect, finalEffectChain, + 1.0, gfx::Matrix4x4()); + } +} + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_LayerManagerCompositeUtils_H */ diff --git a/gfx/layers/composite/PaintCounter.cpp b/gfx/layers/composite/PaintCounter.cpp new file mode 100644 index 0000000000..fbf1552116 --- /dev/null +++ b/gfx/layers/composite/PaintCounter.cpp @@ -0,0 +1,79 @@ +/* -*- 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/gfx/Point.h" // for IntSize, Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for Color, SurfaceFormat +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/CompositorTypes.h" +#include "mozilla/layers/Effects.h" // for Effect, EffectChain, etc +#include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration +#include "mozilla/Sprintf.h" + +#include "mozilla/gfx/HelpersSkia.h" +#include "skia/include/core/SkFont.h" +#include "PaintCounter.h" + +namespace mozilla { +namespace layers { + +using namespace mozilla::gfx; + +// Positioned below the chrome UI +IntRect PaintCounter::mRect = IntRect(0, 175, 300, 60); + +PaintCounter::PaintCounter() { + mFormat = SurfaceFormat::B8G8R8A8; + mSurface = Factory::CreateDataSourceSurface(mRect.Size(), mFormat); + mMap.emplace(mSurface, DataSourceSurface::READ_WRITE); + mStride = mMap->GetStride(); + + mCanvas = SkCanvas::MakeRasterDirect(MakeSkiaImageInfo(mRect.Size(), mFormat), + mMap->GetData(), mStride); + mCanvas->clear(SK_ColorWHITE); +} + +PaintCounter::~PaintCounter() { + mSurface = nullptr; + mTextureSource = nullptr; + mTexturedEffect = nullptr; +} + +void PaintCounter::Draw(Compositor* aCompositor, TimeDuration aPaintTime, + TimeDuration aCompositeTime) { + char buffer[48]; + SprintfLiteral(buffer, "P: %.2f C: %.2f", aPaintTime.ToMilliseconds(), + aCompositeTime.ToMilliseconds()); + + SkPaint paint; + paint.setColor(SkColorSetRGB(0, 255, 0)); + paint.setAntiAlias(true); + + SkFont font(SkTypeface::MakeDefault(), 32); + + mCanvas->clear(SK_ColorTRANSPARENT); + mCanvas->drawString(buffer, 10, 30, font, paint); + mCanvas->flush(); + + if (!mTextureSource) { + mTextureSource = aCompositor->CreateDataTextureSource(); + mTexturedEffect = CreateTexturedEffect(mFormat, mTextureSource, + SamplingFilter::POINT, true); + mTexturedEffect->mTextureCoords = Rect(0, 0, 1.0f, 1.0f); + } + + mTextureSource->Update(mSurface); + + EffectChain effectChain; + effectChain.mPrimaryEffect = mTexturedEffect; + + gfx::Matrix4x4 identity; + Rect rect(mRect.X(), mRect.Y(), mRect.Width(), mRect.Height()); + aCompositor->DrawQuad(rect, mRect, effectChain, 1.0, identity); +} + +} // end namespace layers +} // end namespace mozilla diff --git a/gfx/layers/composite/PaintCounter.h b/gfx/layers/composite/PaintCounter.h new file mode 100644 index 0000000000..084330c998 --- /dev/null +++ b/gfx/layers/composite/PaintCounter.h @@ -0,0 +1,53 @@ +/* -*- 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_PaintCounter_h_ +#define mozilla_layers_PaintCounter_h_ + +#include <map> // for std::map +#include "mozilla/Maybe.h" +#include "mozilla/RefPtr.h" // for already_AddRefed, RefCounted +#include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration +#include "skia/include/core/SkCanvas.h" + +namespace mozilla { +namespace layers { + +class Compositor; + +using namespace mozilla::gfx; +using namespace mozilla::gl; + +// Keeps track and paints how long a full invalidation paint takes to rasterize +// and composite. +class PaintCounter { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PaintCounter) + + PaintCounter(); + void Draw(Compositor* aCompositor, TimeDuration aPaintTime, + TimeDuration aCompositeTime); + static IntRect GetPaintRect() { return PaintCounter::mRect; } + + private: + virtual ~PaintCounter(); + + SurfaceFormat mFormat; + std::unique_ptr<SkCanvas> mCanvas; + IntSize mSize; + int mStride; + + RefPtr<DataSourceSurface> mSurface; + RefPtr<DataTextureSource> mTextureSource; + RefPtr<TexturedEffect> mTexturedEffect; + Maybe<DataSourceSurface::ScopedMap> mMap; + static IntRect mRect; +}; + +} // namespace layers +} // namespace mozilla + +#endif // mozilla_layers_opengl_PaintCounter_h_ diff --git a/gfx/layers/composite/PaintedLayerComposite.cpp b/gfx/layers/composite/PaintedLayerComposite.cpp new file mode 100644 index 0000000000..fe8028d12f --- /dev/null +++ b/gfx/layers/composite/PaintedLayerComposite.cpp @@ -0,0 +1,169 @@ +/* -*- 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 "PaintedLayerComposite.h" +#include "CompositableHost.h" // for TiledLayerProperties, etc +#include "FrameMetrics.h" // for FrameMetrics +#include "Units.h" // for CSSRect, LayerPixel, etc +#include "gfxEnv.h" // for gfxEnv +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Polygon.h" // for Polygon +#include "mozilla/gfx/Rect.h" // for RoundedToInt, Rect +#include "mozilla/gfx/Types.h" // for SamplingFilter::LINEAR +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/ContentHost.h" // for ContentHost +#include "mozilla/layers/Effects.h" // for EffectChain +#include "mozilla/layers/LayerManagerCompositeUtils.h" +#include "mozilla/mozalloc.h" // for operator delete +#include "nsAString.h" +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "nsMathUtils.h" // for NS_lround +#include "nsString.h" // for nsAutoCString +#include "TextRenderer.h" +#include "GeckoProfiler.h" + +namespace mozilla { +namespace layers { + +PaintedLayerComposite::PaintedLayerComposite(LayerManagerComposite* aManager) + : PaintedLayer(aManager, nullptr), + LayerComposite(aManager), + mBuffer(nullptr) { + MOZ_COUNT_CTOR(PaintedLayerComposite); + mImplData = static_cast<LayerComposite*>(this); +} + +PaintedLayerComposite::~PaintedLayerComposite() { + MOZ_COUNT_DTOR(PaintedLayerComposite); + CleanupResources(); +} + +bool PaintedLayerComposite::SetCompositableHost(CompositableHost* aHost) { + switch (aHost->GetType()) { + case CompositableType::CONTENT_TILED: + case CompositableType::CONTENT_SINGLE: + case CompositableType::CONTENT_DOUBLE: { + ContentHost* newBuffer = static_cast<ContentHost*>(aHost); + if (mBuffer && newBuffer != mBuffer) { + mBuffer->Detach(this); + } + mBuffer = newBuffer; + return true; + } + default: + return false; + } +} + +void PaintedLayerComposite::Disconnect() { Destroy(); } + +void PaintedLayerComposite::Destroy() { + if (!mDestroyed) { + CleanupResources(); + mDestroyed = true; + } +} + +Layer* PaintedLayerComposite::GetLayer() { return this; } + +void PaintedLayerComposite::SetLayerManager(HostLayerManager* aManager) { + LayerComposite::SetLayerManager(aManager); + mManager = aManager; + if (mBuffer && mCompositor) { + mBuffer->SetTextureSourceProvider(mCompositor); + } +} + +void PaintedLayerComposite::RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) { + if (!mBuffer || !mBuffer->IsAttached()) { + return; + } + AUTO_PROFILER_LABEL("PaintedLayerComposite::RenderLayer", GRAPHICS); + + Compositor* compositor = mCompositeManager->GetCompositor(); + + MOZ_ASSERT(mBuffer->GetTextureSourceProvider() == compositor && + mBuffer->GetLayer() == this, + "buffer is corrupted"); + + const nsIntRegion visibleRegion = GetLocalVisibleRegion().ToUnknownRegion(); + +#ifdef MOZ_DUMP_PAINTING + if (gfxEnv::DumpCompositorTextures()) { + RefPtr<gfx::DataSourceSurface> surf = mBuffer->GetAsSurface(); + if (surf) { + WriteSnapshotToDumpFile(this, surf); + } + } +#endif + + RenderWithAllMasks( + this, compositor, aClipRect, + [&](EffectChain& effectChain, const gfx::IntRect& clipRect) { + mBuffer->SetPaintWillResample(MayResample()); + + mBuffer->Composite(compositor, this, effectChain, GetEffectiveOpacity(), + GetEffectiveTransform(), GetSamplingFilter(), + clipRect, &visibleRegion, aGeometry); + }); + + mBuffer->BumpFlashCounter(); + + compositor->MakeCurrent(); +} + +CompositableHost* PaintedLayerComposite::GetCompositableHost() { + if (mBuffer && mBuffer->IsAttached()) { + return mBuffer.get(); + } + + return nullptr; +} + +void PaintedLayerComposite::CleanupResources() { + if (mBuffer) { + mBuffer->Detach(this); + } + mBuffer = nullptr; +} + +bool PaintedLayerComposite::IsOpaque() { + if (!mBuffer || !mBuffer->IsAttached()) { + return false; + } + return PaintedLayer::IsOpaque(); +} + +void PaintedLayerComposite::GenEffectChain(EffectChain& aEffect) { + aEffect.mLayerRef = this; + aEffect.mPrimaryEffect = mBuffer->GenEffect(GetSamplingFilter()); +} + +void PaintedLayerComposite::PrintInfo(std::stringstream& aStream, + const char* aPrefix) { + PaintedLayer::PrintInfo(aStream, aPrefix); + if (mBuffer && mBuffer->IsAttached()) { + aStream << "\n"; + nsAutoCString pfx(aPrefix); + pfx += " "; + mBuffer->PrintInfo(aStream, pfx.get()); + } +} + +const gfx::TiledIntRegion& PaintedLayerComposite::GetInvalidRegion() { + if (mBuffer) { + nsIntRegion region = mInvalidRegion.GetRegion(); + mBuffer->AddAnimationInvalidation(region); + } + return mInvalidRegion; +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/PaintedLayerComposite.h b/gfx/layers/composite/PaintedLayerComposite.h new file mode 100644 index 0000000000..c2c22eb433 --- /dev/null +++ b/gfx/layers/composite/PaintedLayerComposite.h @@ -0,0 +1,86 @@ +/* -*- 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_PaintedLayerComposite_H +#define GFX_PaintedLayerComposite_H + +#include "Layers.h" // for Layer (ptr only), etc +#include "mozilla/gfx/Rect.h" +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/layers/LayerManagerComposite.h" // for LayerComposite, etc +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "nsRegion.h" // for nsIntRegion +#include "nscore.h" // for nsACString + +namespace mozilla { +namespace layers { + +/** + * PaintedLayers use ContentHosts for their compsositable host. + * By using different ContentHosts, PaintedLayerComposite support tiled and + * non-tiled PaintedLayers and single or double buffering. + */ + +class CompositableHost; +class ContentHost; + +class PaintedLayerComposite : public PaintedLayer, public LayerComposite { + public: + explicit PaintedLayerComposite(LayerManagerComposite* aManager); + + protected: + virtual ~PaintedLayerComposite(); + + public: + void Disconnect() override; + + CompositableHost* GetCompositableHost() override; + + void Destroy() override; + + Layer* GetLayer() override; + + void SetLayerManager(HostLayerManager* aManager) override; + + void RenderLayer(const gfx::IntRect& aClipRect, + const Maybe<gfx::Polygon>& aGeometry) override; + + void CleanupResources() override; + + bool IsOpaque() override; + + void GenEffectChain(EffectChain& aEffect) override; + + bool SetCompositableHost(CompositableHost* aHost) override; + + HostLayer* AsHostLayer() override { return this; } + + void InvalidateRegion(const nsIntRegion& aRegion) override { + MOZ_CRASH("PaintedLayerComposites can't fill invalidated regions"); + } + + const gfx::TiledIntRegion& GetInvalidRegion() override; + + MOZ_LAYER_DECL_NAME("PaintedLayerComposite", TYPE_PAINTED) + + protected: + virtual void PrintInfo(std::stringstream& aStream, + const char* aPrefix) override; + + private: + gfx::SamplingFilter GetSamplingFilter() { + return gfx::SamplingFilter::LINEAR; + } + + private: + RefPtr<ContentHost> mBuffer; +}; + +} // namespace layers +} // namespace mozilla + +#endif /* GFX_PaintedLayerComposite_H */ diff --git a/gfx/layers/composite/TextRenderer.cpp b/gfx/layers/composite/TextRenderer.cpp new file mode 100644 index 0000000000..3bd1a7d9b3 --- /dev/null +++ b/gfx/layers/composite/TextRenderer.cpp @@ -0,0 +1,245 @@ +/* -*- 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 "TextRenderer.h" +#include "FontData.h" +#include "ConsolasFontData.h" +#include "png.h" +#include "mozilla/Base64.h" +#include "mozilla/layers/Compositor.h" +#include "mozilla/layers/TextureHost.h" +#include "mozilla/layers/Effects.h" + +namespace mozilla { +namespace layers { + +using namespace gfx; + +const Float sBackgroundOpacity = 0.8f; +const SurfaceFormat sTextureFormat = SurfaceFormat::B8G8R8A8; + +static void PNGAPI info_callback(png_structp png_ptr, png_infop info_ptr) { + png_read_update_info(png_ptr, info_ptr); +} + +static void PNGAPI row_callback(png_structp png_ptr, png_bytep new_row, + png_uint_32 row_num, int pass) { + MOZ_ASSERT(sTextureFormat == SurfaceFormat::B8G8R8A8); + + TextRenderer::FontCache* cache = + static_cast<TextRenderer::FontCache*>(png_get_progressive_ptr(png_ptr)); + + uint32_t* dst = + (uint32_t*)(cache->mMap.mData + cache->mMap.mStride * row_num); + + for (uint32_t x = 0; x < cache->mInfo->mTextureWidth; x++) { + // We blend to a transparent white background, this will make text readable + // even if it's on a dark background. Without hurting our ability to + // interact with the content behind the text. + Float alphaValue = Float(0xFF - new_row[x]) / 255.0f; + Float baseValue = sBackgroundOpacity * (1.0f - alphaValue); + // FIXME(aosmond): PNGs may have color profiles. Should we be checking for + // that and performing color management? + sRGBColor pixelColor(baseValue, baseValue, baseValue, + baseValue + alphaValue); + dst[x] = pixelColor.ToABGR(); + } +} + +TextRenderer::~TextRenderer() = default; + +TextRenderer::FontCache::~FontCache() { mGlyphBitmaps->Unmap(); } + +void TextRenderer::RenderText(Compositor* aCompositor, const std::string& aText, + const IntPoint& aOrigin, + const Matrix4x4& aTransform, uint32_t aTextSize, + uint32_t aTargetPixelWidth, FontType aFontType) { + const FontBitmapInfo* info = GetFontInfo(aFontType); + + // For now we only have a bitmap font with a 24px cell size, so we just + // scale it up if the user wants larger text. + Float scaleFactor = Float(aTextSize) / Float(info->mCellHeight); + aTargetPixelWidth /= scaleFactor; + + RefPtr<TextureSource> src = + RenderText(aCompositor, aText, aTargetPixelWidth, aFontType); + if (!src) { + return; + } + + RefPtr<EffectRGB> effect = new EffectRGB(src, true, SamplingFilter::LINEAR); + EffectChain chain; + chain.mPrimaryEffect = effect; + + Matrix4x4 transform = aTransform; + transform.PreScale(scaleFactor, scaleFactor, 1.0f); + + IntRect drawRect(aOrigin, src->GetSize()); + IntRect clip(-10000, -10000, 20000, 20000); + aCompositor->DrawQuad(Rect(drawRect), clip, chain, 1.0f, transform); +} + +IntSize TextRenderer::ComputeSurfaceSize(const std::string& aText, + uint32_t aTargetPixelWidth, + FontType aFontType) { + if (!EnsureInitialized(aFontType)) { + return IntSize(); + } + + FontCache* cache = mFonts[aFontType].get(); + const FontBitmapInfo* info = cache->mInfo; + + uint32_t numLines = 1; + uint32_t maxWidth = 0; + uint32_t lineWidth = 0; + // Calculate the size of the surface needed to draw all the glyphs. + for (uint32_t i = 0; i < aText.length(); i++) { + // Insert a line break if we go past the TargetPixelWidth. + // XXX - this has the downside of overrunning the intended width, causing + // things at the edge of a window to be cut off. + if (aText[i] == '\n' || + (aText[i] == ' ' && lineWidth > aTargetPixelWidth)) { + numLines++; + lineWidth = 0; + continue; + } + + lineWidth += info->GetGlyphWidth(aText[i]); + maxWidth = std::max(lineWidth, maxWidth); + } + + return IntSize(maxWidth, numLines * info->mCellHeight); +} + +RefPtr<TextureSource> TextRenderer::RenderText(TextureSourceProvider* aProvider, + const std::string& aText, + uint32_t aTargetPixelWidth, + FontType aFontType) { + if (!EnsureInitialized(aFontType)) { + return nullptr; + } + + IntSize size = ComputeSurfaceSize(aText, aTargetPixelWidth, aFontType); + + // Create a DrawTarget to draw our glyphs to. + RefPtr<DrawTarget> dt = + Factory::CreateDrawTarget(BackendType::SKIA, size, sTextureFormat); + + RenderTextToDrawTarget(dt, aText, aTargetPixelWidth, aFontType); + RefPtr<SourceSurface> surf = dt->Snapshot(); + RefPtr<DataSourceSurface> dataSurf = surf->GetDataSurface(); + RefPtr<DataTextureSource> src = aProvider->CreateDataTextureSource(); + + if (!src->Update(dataSurf)) { + // Upload failed. + return nullptr; + } + + return src; +} + +void TextRenderer::RenderTextToDrawTarget(DrawTarget* aDrawTarget, + const std::string& aText, + uint32_t aTargetPixelWidth, + FontType aFontType) { + if (!EnsureInitialized(aFontType)) { + return; + } + + // Initialize the DrawTarget to transparent white. + // FIXME(aosmond): Should the background be color managed if we color manage + // the glyphs or is this part of a mask? + IntSize size = aDrawTarget->GetSize(); + aDrawTarget->FillRect( + Rect(0, 0, size.width, size.height), + ColorPattern(DeviceColor(1.0, 1.0, 1.0, sBackgroundOpacity)), + DrawOptions(1.0, CompositionOp::OP_SOURCE)); + + IntPoint currentPos; + + FontCache* cache = mFonts[aFontType].get(); + const FontBitmapInfo* info = cache->mInfo; + + const unsigned int kGlyphsPerLine = info->mTextureWidth / info->mCellWidth; + + // Copy our glyphs onto the DrawTarget. + for (uint32_t i = 0; i < aText.length(); i++) { + if (aText[i] == '\n' || + (aText[i] == ' ' && currentPos.x > int32_t(aTargetPixelWidth))) { + currentPos.y += info->mCellHeight; + currentPos.x = 0; + continue; + } + + uint32_t index = aText[i] - info->mFirstChar; + uint32_t cellIndexY = index / kGlyphsPerLine; + uint32_t cellIndexX = index - (cellIndexY * kGlyphsPerLine); + uint32_t glyphWidth = info->GetGlyphWidth(aText[i]); + IntRect srcRect(cellIndexX * info->mCellWidth, + cellIndexY * info->mCellHeight, glyphWidth, + info->mCellHeight); + + aDrawTarget->CopySurface(cache->mGlyphBitmaps, srcRect, currentPos); + + currentPos.x += glyphWidth; + } +} + +/* static */ const FontBitmapInfo* TextRenderer::GetFontInfo(FontType aType) { + switch (aType) { + case FontType::Default: + return &sDefaultCompositorFont; + case FontType::FixedWidth: + return &sFixedWidthCompositorFont; + default: + MOZ_ASSERT_UNREACHABLE("unknown font type"); + return nullptr; + } +} + +bool TextRenderer::EnsureInitialized(FontType aType) { + if (mFonts[aType]) { + return true; + } + + const FontBitmapInfo* info = GetFontInfo(aType); + + IntSize size(info->mTextureWidth, info->mTextureHeight); + RefPtr<DataSourceSurface> surface = + Factory::CreateDataSourceSurface(size, sTextureFormat); + if (NS_WARN_IF(!surface)) { + return false; + } + + DataSourceSurface::MappedSurface map; + if (NS_WARN_IF(!surface->Map(DataSourceSurface::MapType::READ_WRITE, &map))) { + return false; + } + + UniquePtr<FontCache> cache = MakeUnique<FontCache>(); + cache->mGlyphBitmaps = surface; + cache->mMap = map; + cache->mInfo = info; + + png_structp png_ptr = NULL; + png_ptr = + png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); + + png_set_progressive_read_fn(png_ptr, cache.get(), info_callback, row_callback, + nullptr); + png_infop info_ptr = NULL; + info_ptr = png_create_info_struct(png_ptr); + + png_process_data(png_ptr, info_ptr, (uint8_t*)info->mPNG, info->mPNGLength); + + png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); + + mFonts[aType] = std::move(cache); + return true; +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/TextRenderer.h b/gfx/layers/composite/TextRenderer.h new file mode 100644 index 0000000000..e88fc1d8f5 --- /dev/null +++ b/gfx/layers/composite/TextRenderer.h @@ -0,0 +1,95 @@ +/* -*- 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_TextRenderer_H +#define GFX_TextRenderer_H + +#include "mozilla/EnumeratedArray.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/UniquePtr.h" +#include "nsISupportsImpl.h" +#include <string> + +namespace mozilla { +namespace layers { + +class Compositor; +class TextureSource; +class TextureSourceProvider; +struct FontBitmapInfo; + +class TextRenderer final { + ~TextRenderer(); + + public: + NS_INLINE_DECL_REFCOUNTING(TextRenderer) + + enum class FontType { Default, FixedWidth, NumTypes }; + + TextRenderer() = default; + + RefPtr<TextureSource> RenderText(TextureSourceProvider* aProvider, + const std::string& aText, + uint32_t aTargetPixelWidth, + FontType aFontType); + + void RenderText(Compositor* aCompositor, const std::string& aText, + const gfx::IntPoint& aOrigin, + const gfx::Matrix4x4& aTransform, uint32_t aTextSize, + uint32_t aTargetPixelWidth, + FontType aFontType = FontType::Default); + + gfx::IntSize ComputeSurfaceSize(const std::string& aText, + uint32_t aTargetPixelWidth, + FontType aFontType = FontType::Default); + + void RenderTextToDrawTarget(gfx::DrawTarget* aDrawTarget, + const std::string& aText, + uint32_t aTargetPixelWidth, + FontType aFontType = FontType::Default); + + struct FontCache { + ~FontCache(); + RefPtr<gfx::DataSourceSurface> mGlyphBitmaps; + gfx::DataSourceSurface::MappedSurface mMap; + const FontBitmapInfo* mInfo; + }; + + protected: + // Note that this may still fail to set mGlyphBitmaps to a valid value + // if the underlying CreateDataSourceSurface fails for some reason. + bool EnsureInitialized(FontType aType); + + static const FontBitmapInfo* GetFontInfo(FontType aType); + + private: + EnumeratedArray<FontType, FontType::NumTypes, UniquePtr<FontCache>> mFonts; +}; + +struct FontBitmapInfo { + Maybe<unsigned int> mGlyphWidth; + Maybe<const unsigned short*> mGlyphWidths; + unsigned int mTextureWidth; + unsigned int mTextureHeight; + unsigned int mCellWidth; + unsigned int mCellHeight; + unsigned int mFirstChar; + const unsigned char* mPNG; + size_t mPNGLength; + + unsigned int GetGlyphWidth(char aGlyph) const { + if (mGlyphWidth) { + return mGlyphWidth.value(); + } + MOZ_ASSERT(unsigned(aGlyph) >= mFirstChar); + return mGlyphWidths.value()[unsigned(aGlyph) - mFirstChar]; + } +}; + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/TextureHost.cpp b/gfx/layers/composite/TextureHost.cpp new file mode 100644 index 0000000000..92ced1ee89 --- /dev/null +++ b/gfx/layers/composite/TextureHost.cpp @@ -0,0 +1,1371 @@ +/* -*- 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 "TextureHost.h" + +#include "CompositableHost.h" // for CompositableHost +#include "LayerScope.h" +#include "mozilla/gfx/2D.h" // for DataSourceSurface, Factory +#include "mozilla/gfx/gfxVars.h" +#include "mozilla/ipc/Shmem.h" // for Shmem +#include "mozilla/layers/AsyncImagePipelineManager.h" +#include "mozilla/layers/BufferTexture.h" +#include "mozilla/layers/CompositableTransactionParent.h" // for CompositableParentManager +#include "mozilla/layers/CompositorBridgeParent.h" +#include "mozilla/layers/Compositor.h" // for Compositor +#include "mozilla/layers/ISurfaceAllocator.h" // for ISurfaceAllocator +#include "mozilla/layers/ImageBridgeParent.h" // for ImageBridgeParent +#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor, etc +#include "mozilla/layers/TextureHostBasic.h" +#include "mozilla/layers/TextureHostOGL.h" // for TextureHostOGL +#include "mozilla/layers/ImageDataSerializer.h" +#include "mozilla/layers/TextureClient.h" +#ifdef XP_DARWIN +# include "mozilla/layers/TextureSync.h" +#endif +#include "mozilla/layers/GPUVideoTextureHost.h" +#include "mozilla/layers/WebRenderTextureHost.h" +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/StaticPrefs_gfx.h" +#include "mozilla/webrender/RenderBufferTextureHost.h" +#include "mozilla/webrender/RenderBufferTextureHostSWGL.h" +#include "mozilla/webrender/RenderExternalTextureHost.h" +#include "mozilla/webrender/RenderThread.h" +#include "mozilla/webrender/WebRenderAPI.h" +#include "nsAString.h" +#include "mozilla/RefPtr.h" // for nsRefPtr +#include "nsPrintfCString.h" // for nsPrintfCString +#include "mozilla/layers/PTextureParent.h" +#include "mozilla/Unused.h" +#include <limits> +#include "../opengl/CompositorOGL.h" + +#include "gfxUtils.h" +#include "IPDLActor.h" + +#ifdef MOZ_ENABLE_D3D10_LAYER +# include "../d3d11/CompositorD3D11.h" +#endif + +#ifdef MOZ_X11 +# include "mozilla/layers/X11TextureHost.h" +#endif + +#ifdef XP_MACOSX +# include "../opengl/MacIOSurfaceTextureHostOGL.h" +#endif + +#ifdef XP_WIN +# include "mozilla/layers/TextureD3D11.h" +# include "mozilla/layers/TextureDIB.h" +#endif + +#if 0 +# define RECYCLE_LOG(...) printf_stderr(__VA_ARGS__) +#else +# define RECYCLE_LOG(...) \ + do { \ + } while (0) +#endif + +namespace mozilla { +namespace layers { + +/** + * TextureParent is the host-side IPDL glue between TextureClient and + * TextureHost. It is an IPDL actor just like LayerParent, CompositableParent, + * etc. + */ +class TextureParent : public ParentActor<PTextureParent> { + public: + TextureParent(HostIPCAllocator* aAllocator, uint64_t aSerial, + const wr::MaybeExternalImageId& aExternalImageId); + + virtual ~TextureParent(); + + bool Init(const SurfaceDescriptor& aSharedData, + const ReadLockDescriptor& aReadLock, + const LayersBackend& aLayersBackend, const TextureFlags& aFlags); + + void NotifyNotUsed(uint64_t aTransactionId); + + mozilla::ipc::IPCResult RecvRecycleTexture( + const TextureFlags& aTextureFlags) final; + + TextureHost* GetTextureHost() { return mTextureHost; } + + void Destroy() override; + + uint64_t GetSerial() const { return mSerial; } + + HostIPCAllocator* mSurfaceAllocator; + RefPtr<TextureHost> mTextureHost; + // mSerial is unique in TextureClient's process. + const uint64_t mSerial; + wr::MaybeExternalImageId mExternalImageId; +}; + +static bool WrapWithWebRenderTextureHost(ISurfaceAllocator* aDeallocator, + LayersBackend aBackend, + TextureFlags aFlags) { + if ((aFlags & TextureFlags::SNAPSHOT) || + (aBackend != LayersBackend::LAYERS_WR) || + (!aDeallocator->UsesImageBridge() && + !aDeallocator->AsCompositorBridgeParentBase())) { + return false; + } + return true; +} + +//////////////////////////////////////////////////////////////////////////////// +PTextureParent* TextureHost::CreateIPDLActor( + HostIPCAllocator* aAllocator, const SurfaceDescriptor& aSharedData, + const ReadLockDescriptor& aReadLock, LayersBackend aLayersBackend, + TextureFlags aFlags, uint64_t aSerial, + const wr::MaybeExternalImageId& aExternalImageId) { + TextureParent* actor = + new TextureParent(aAllocator, aSerial, aExternalImageId); + if (!actor->Init(aSharedData, aReadLock, aLayersBackend, aFlags)) { + actor->ActorDestroy(ipc::IProtocol::ActorDestroyReason::FailedConstructor); + delete actor; + return nullptr; + } + return actor; +} + +// static +bool TextureHost::DestroyIPDLActor(PTextureParent* actor) { + delete actor; + return true; +} + +// static +bool TextureHost::SendDeleteIPDLActor(PTextureParent* actor) { + return PTextureParent::Send__delete__(actor); +} + +// static +TextureHost* TextureHost::AsTextureHost(PTextureParent* actor) { + if (!actor) { + return nullptr; + } + return static_cast<TextureParent*>(actor)->mTextureHost; +} + +// static +uint64_t TextureHost::GetTextureSerial(PTextureParent* actor) { + if (!actor) { + return UINT64_MAX; + } + return static_cast<TextureParent*>(actor)->mSerial; +} + +PTextureParent* TextureHost::GetIPDLActor() { return mActor; } + +void TextureHost::SetLastFwdTransactionId(uint64_t aTransactionId) { + MOZ_ASSERT(mFwdTransactionId <= aTransactionId); + mFwdTransactionId = aTransactionId; +} + +already_AddRefed<TextureHost> CreateDummyBufferTextureHost( + mozilla::layers::LayersBackend aBackend, + mozilla::layers::TextureFlags aFlags) { + // Ensure that the host will delete the memory. + aFlags &= ~TextureFlags::DEALLOCATE_CLIENT; + UniquePtr<TextureData> textureData(BufferTextureData::Create( + gfx::IntSize(1, 1), gfx::SurfaceFormat::B8G8R8A8, gfx::BackendType::SKIA, + aBackend, aFlags, TextureAllocationFlags::ALLOC_DEFAULT, nullptr)); + SurfaceDescriptor surfDesc; + textureData->Serialize(surfDesc); + const SurfaceDescriptorBuffer& bufferDesc = + surfDesc.get_SurfaceDescriptorBuffer(); + const MemoryOrShmem& data = bufferDesc.data(); + RefPtr<TextureHost> host = + new MemoryTextureHost(reinterpret_cast<uint8_t*>(data.get_uintptr_t()), + bufferDesc.desc(), aFlags); + return host.forget(); +} + +already_AddRefed<TextureHost> TextureHost::Create( + const SurfaceDescriptor& aDesc, const ReadLockDescriptor& aReadLock, + ISurfaceAllocator* aDeallocator, LayersBackend aBackend, + TextureFlags aFlags, wr::MaybeExternalImageId& aExternalImageId) { + RefPtr<TextureHost> result; + + switch (aDesc.type()) { + case SurfaceDescriptor::TSurfaceDescriptorBuffer: + case SurfaceDescriptor::TSurfaceDescriptorDIB: + case SurfaceDescriptor::TSurfaceDescriptorFileMapping: + case SurfaceDescriptor::TSurfaceDescriptorGPUVideo: + result = CreateBackendIndependentTextureHost(aDesc, aDeallocator, + aBackend, aFlags); + break; + + case SurfaceDescriptor::TEGLImageDescriptor: + case SurfaceDescriptor::TSurfaceTextureDescriptor: + case SurfaceDescriptor::TSurfaceDescriptorAndroidHardwareBuffer: + case SurfaceDescriptor::TSurfaceDescriptorSharedGLTexture: + case SurfaceDescriptor::TSurfaceDescriptorDMABuf: + result = CreateTextureHostOGL(aDesc, aDeallocator, aBackend, aFlags); + break; + + case SurfaceDescriptor::TSurfaceDescriptorMacIOSurface: + if (aBackend == LayersBackend::LAYERS_OPENGL || + aBackend == LayersBackend::LAYERS_WR) { + result = CreateTextureHostOGL(aDesc, aDeallocator, aBackend, aFlags); + break; + } else { + result = CreateTextureHostBasic(aDesc, aDeallocator, aBackend, aFlags); + break; + } + +#ifdef MOZ_X11 + case SurfaceDescriptor::TSurfaceDescriptorX11: { + if (!aDeallocator->IsSameProcess()) { + NS_ERROR( + "A client process is trying to peek at our address space using a " + "X11Texture!"); + return nullptr; + } + + const SurfaceDescriptorX11& desc = aDesc.get_SurfaceDescriptorX11(); + result = MakeAndAddRef<X11TextureHost>(aFlags, desc); + break; + } +#endif + +#ifdef XP_WIN + case SurfaceDescriptor::TSurfaceDescriptorD3D10: + case SurfaceDescriptor::TSurfaceDescriptorDXGIYCbCr: + result = CreateTextureHostD3D11(aDesc, aDeallocator, aBackend, aFlags); + break; +#endif + case SurfaceDescriptor::TSurfaceDescriptorRecorded: { + const SurfaceDescriptorRecorded& desc = + aDesc.get_SurfaceDescriptorRecorded(); + UniquePtr<SurfaceDescriptor> realDesc = + aDeallocator->AsCompositorBridgeParentBase() + ->LookupSurfaceDescriptorForClientTexture(desc.textureId()); + if (!realDesc) { + gfxCriticalNote << "Failed to get descriptor for recorded texture."; + // Create a dummy to prevent any crashes due to missing IPDL actors. + result = CreateDummyBufferTextureHost(aBackend, aFlags); + break; + } + + result = TextureHost::Create(*realDesc, aReadLock, aDeallocator, aBackend, + aFlags, aExternalImageId); + return result.forget(); + } + default: + MOZ_CRASH("GFX: Unsupported Surface type host"); + } + + if (!result) { + gfxCriticalNote << "TextureHost creation failure type=" << aDesc.type(); + } + + if (result && WrapWithWebRenderTextureHost(aDeallocator, aBackend, aFlags)) { + MOZ_ASSERT(aExternalImageId.isSome()); + result = + new WebRenderTextureHost(aDesc, aFlags, result, aExternalImageId.ref()); + } + + if (result) { + result->DeserializeReadLock(aReadLock, aDeallocator); + } + + return result.forget(); +} + +already_AddRefed<TextureHost> CreateBackendIndependentTextureHost( + const SurfaceDescriptor& aDesc, ISurfaceAllocator* aDeallocator, + LayersBackend aBackend, TextureFlags aFlags) { + RefPtr<TextureHost> result; + switch (aDesc.type()) { + case SurfaceDescriptor::TSurfaceDescriptorBuffer: { + const SurfaceDescriptorBuffer& bufferDesc = + aDesc.get_SurfaceDescriptorBuffer(); + const MemoryOrShmem& data = bufferDesc.data(); + switch (data.type()) { + case MemoryOrShmem::TShmem: { + const ipc::Shmem& shmem = data.get_Shmem(); + const BufferDescriptor& desc = bufferDesc.desc(); + if (!shmem.IsReadable()) { + // We failed to map the shmem so we can't verify its size. This + // should not be a fatal error, so just create the texture with + // nothing backing it. + result = new ShmemTextureHost(shmem, desc, aDeallocator, aFlags); + break; + } + + size_t bufSize = shmem.Size<char>(); + size_t reqSize = SIZE_MAX; + switch (desc.type()) { + case BufferDescriptor::TYCbCrDescriptor: { + const YCbCrDescriptor& ycbcr = desc.get_YCbCrDescriptor(); + reqSize = ImageDataSerializer::ComputeYCbCrBufferSize( + ycbcr.ySize(), ycbcr.yStride(), ycbcr.cbCrSize(), + ycbcr.cbCrStride(), ycbcr.yOffset(), ycbcr.cbOffset(), + ycbcr.crOffset()); + break; + } + case BufferDescriptor::TRGBDescriptor: { + const RGBDescriptor& rgb = desc.get_RGBDescriptor(); + reqSize = ImageDataSerializer::ComputeRGBBufferSize(rgb.size(), + rgb.format()); + break; + } + default: + gfxCriticalError() + << "Bad buffer host descriptor " << (int)desc.type(); + MOZ_CRASH("GFX: Bad descriptor"); + } + + if (reqSize == 0 || bufSize < reqSize) { + NS_ERROR( + "A client process gave a shmem too small to fit for its " + "descriptor!"); + return nullptr; + } + + result = new ShmemTextureHost(shmem, desc, aDeallocator, aFlags); + break; + } + case MemoryOrShmem::Tuintptr_t: { + if (!aDeallocator->IsSameProcess()) { + NS_ERROR( + "A client process is trying to peek at our address space using " + "a MemoryTexture!"); + return nullptr; + } + + result = new MemoryTextureHost( + reinterpret_cast<uint8_t*>(data.get_uintptr_t()), + bufferDesc.desc(), aFlags); + break; + } + default: + gfxCriticalError() + << "Failed texture host for backend " << (int)data.type(); + MOZ_CRASH("GFX: No texture host for backend"); + } + break; + } + case SurfaceDescriptor::TSurfaceDescriptorGPUVideo: { + if (aDesc.get_SurfaceDescriptorGPUVideo().type() == + SurfaceDescriptorGPUVideo::TSurfaceDescriptorPlugin) { + MOZ_ASSERT(aDeallocator && aDeallocator->UsesImageBridge()); + auto ibpBase = static_cast<ImageBridgeParent*>(aDeallocator); + result = + ibpBase->LookupTextureHost(aDesc.get_SurfaceDescriptorGPUVideo()); + if (!result) { + return nullptr; + } + MOZ_ASSERT(aFlags == result->GetFlags()); + break; + } + + MOZ_ASSERT(aDesc.get_SurfaceDescriptorGPUVideo().type() == + SurfaceDescriptorGPUVideo::TSurfaceDescriptorRemoteDecoder); + result = GPUVideoTextureHost::CreateFromDescriptor( + aFlags, aDesc.get_SurfaceDescriptorGPUVideo()); + break; + } +#ifdef XP_WIN + case SurfaceDescriptor::TSurfaceDescriptorDIB: { + if (!aDeallocator->IsSameProcess()) { + NS_ERROR( + "A client process is trying to peek at our address space using a " + "DIBTexture!"); + return nullptr; + } + + result = new DIBTextureHost(aFlags, aDesc); + break; + } + case SurfaceDescriptor::TSurfaceDescriptorFileMapping: { + result = new TextureHostFileMapping(aFlags, aDesc); + break; + } +#endif + default: { + NS_WARNING("No backend independent TextureHost for this descriptor type"); + } + } + return result.forget(); +} + +TextureHost::TextureHost(TextureFlags aFlags) + : AtomicRefCountedWithFinalize("TextureHost"), + mActor(nullptr), + mFlags(aFlags), + mCompositableCount(0), + mFwdTransactionId(0), + mReadLocked(false) {} + +TextureHost::~TextureHost() { + if (mReadLocked) { + // If we still have a ReadLock, unlock it. At this point we don't care about + // the texture client being written into on the other side since it should + // be destroyed by now. But we will hit assertions if we don't ReadUnlock + // before destroying the lock itself. + ReadUnlock(); + MaybeNotifyUnlocked(); + } +} + +void TextureHost::Finalize() { + MaybeDestroyRenderTexture(); + + if (!(GetFlags() & TextureFlags::DEALLOCATE_CLIENT)) { + DeallocateSharedData(); + DeallocateDeviceData(); + } +} + +void TextureHost::UnbindTextureSource() { + if (mReadLocked) { + // This TextureHost is not used anymore. Since most compositor backends are + // working asynchronously under the hood a compositor could still be using + // this texture, so it is generally best to wait until the end of the next + // composition before calling ReadUnlock. We ask the compositor to take care + // of that for us. + if (mProvider) { + mProvider->UnlockAfterComposition(this); + } else { + // GetCompositor returned null which means no compositor can be using this + // texture. We can ReadUnlock right away. + ReadUnlock(); + MaybeNotifyUnlocked(); + } + } +} + +void TextureHost::RecycleTexture(TextureFlags aFlags) { + MOZ_ASSERT(GetFlags() & TextureFlags::RECYCLE); + MOZ_ASSERT(aFlags & TextureFlags::RECYCLE); + mFlags = aFlags; +} + +void TextureHost::NotifyNotUsed() { + if (!mActor) { + return; + } + + // Do not need to call NotifyNotUsed() if TextureHost does not have + // TextureFlags::RECYCLE flag nor TextureFlags::WAIT_HOST_USAGE_END flag. + if (!(GetFlags() & TextureFlags::RECYCLE) && + !(GetFlags() & TextureFlags::WAIT_HOST_USAGE_END)) { + return; + } + + // The following cases do not need to defer NotifyNotUsed until next + // Composite. + // - TextureHost does not have Compositor. + // - Compositor is BasicCompositor. + // - TextureHost has intermediate buffer. + // end of buffer usage. + if (!mProvider || HasIntermediateBuffer() || + !mProvider->NotifyNotUsedAfterComposition(this)) { + static_cast<TextureParent*>(mActor)->NotifyNotUsed(mFwdTransactionId); + return; + } +} + +void TextureHost::CallNotifyNotUsed() { + if (!mActor) { + return; + } + static_cast<TextureParent*>(mActor)->NotifyNotUsed(mFwdTransactionId); +} + +void TextureHost::MaybeDestroyRenderTexture() { + if (mExternalImageId.isNothing()) { + // RenderTextureHost was not created + return; + } + // When TextureHost created RenderTextureHost, delete it here. + TextureHost::DestroyRenderTexture(mExternalImageId.ref()); +} + +void TextureHost::DestroyRenderTexture( + const wr::ExternalImageId& aExternalImageId) { + wr::RenderThread::Get()->UnregisterExternalImage( + wr::AsUint64(aExternalImageId)); +} + +void TextureHost::EnsureRenderTexture( + const wr::MaybeExternalImageId& aExternalImageId) { + if (aExternalImageId.isNothing()) { + // TextureHost is wrapped by GPUVideoTextureHost. + if (mExternalImageId.isSome()) { + // RenderTextureHost was already created. + return; + } + mExternalImageId = + Some(AsyncImagePipelineManager::GetNextExternalImageId()); + } else { + // TextureHost is wrapped by WebRenderTextureHost. + if (aExternalImageId == mExternalImageId) { + // The texture has already been created. + return; + } + MOZ_ASSERT(mExternalImageId.isNothing()); + mExternalImageId = aExternalImageId; + } + CreateRenderTexture(mExternalImageId.ref()); +} + +void TextureHost::PrintInfo(std::stringstream& aStream, const char* aPrefix) { + aStream << aPrefix; + aStream << nsPrintfCString("%s (0x%p)", Name(), this).get(); + // Note: the TextureHost needs to be locked before it is safe to call + // GetSize() and GetFormat() on it. + if (Lock()) { + aStream << " [size=" << GetSize() << "]" + << " [format=" << GetFormat() << "]"; + Unlock(); + } + aStream << " [flags=" << mFlags << "]"; +#ifdef MOZ_DUMP_PAINTING + if (StaticPrefs::layers_dump_texture()) { + nsAutoCString pfx(aPrefix); + pfx += " "; + + aStream << "\n" << pfx.get() << "Surface: "; + RefPtr<gfx::DataSourceSurface> dSurf = GetAsSurface(); + if (dSurf) { + aStream << gfxUtils::GetAsLZ4Base64Str(dSurf).get(); + } + } +#endif +} + +void TextureHost::Updated(const nsIntRegion* aRegion) { + LayerScope::ContentChanged(this); + UpdatedInternal(aRegion); +} + +TextureSource::TextureSource() : mCompositableCount(0) {} + +TextureSource::~TextureSource() = default; +BufferTextureHost::BufferTextureHost(const BufferDescriptor& aDesc, + TextureFlags aFlags) + : TextureHost(aFlags), + mUpdateSerial(1), + mLocked(false), + mNeedsFullUpdate(false) { + mDescriptor = aDesc; + switch (mDescriptor.type()) { + case BufferDescriptor::TYCbCrDescriptor: { + const YCbCrDescriptor& ycbcr = mDescriptor.get_YCbCrDescriptor(); + mSize = ycbcr.display().Size(); + mFormat = gfx::SurfaceFormat::YUV; + mHasIntermediateBuffer = ycbcr.hasIntermediateBuffer(); + break; + } + case BufferDescriptor::TRGBDescriptor: { + const RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor(); + mSize = rgb.size(); + mFormat = rgb.format(); + mHasIntermediateBuffer = rgb.hasIntermediateBuffer(); + break; + } + default: + gfxCriticalError() << "Bad buffer host descriptor " + << (int)mDescriptor.type(); + MOZ_CRASH("GFX: Bad descriptor"); + } + if (aFlags & TextureFlags::COMPONENT_ALPHA) { + // One texture of a component alpha texture pair will start out all white. + // This hack allows us to easily make sure that white will be uploaded. + // See bug 1138934 + mNeedsFullUpdate = true; + } + +#ifdef XP_MACOSX + const int kMinSize = 1024; + const int kMaxSize = 4096; + mUseExternalTextures = + kMaxSize >= mSize.width && mSize.width >= kMinSize && + kMaxSize >= mSize.height && mSize.height >= kMinSize && + StaticPrefs::gfx_webrender_enable_client_storage_AtStartup(); +#else + mUseExternalTextures = false; +#endif +} + +BufferTextureHost::~BufferTextureHost() = default; + +void BufferTextureHost::UpdatedInternal(const nsIntRegion* aRegion) { + ++mUpdateSerial; + // If the last frame wasn't uploaded yet, and we -don't- have a partial + // update, we still need to update the full surface. + if (aRegion && !mNeedsFullUpdate) { + mMaybeUpdatedRegion.OrWith(*aRegion); + } else { + mNeedsFullUpdate = true; + } + if (GetFlags() & TextureFlags::IMMEDIATE_UPLOAD) { + DebugOnly<bool> result = + MaybeUpload(!mNeedsFullUpdate ? &mMaybeUpdatedRegion : nullptr); + NS_WARNING_ASSERTION(result, "Failed to upload a texture"); + } +} + +void BufferTextureHost::SetTextureSourceProvider( + TextureSourceProvider* aProvider) { + if (mProvider == aProvider) { + return; + } + if (mFirstSource && mFirstSource->IsOwnedBy(this)) { + mFirstSource->SetOwner(nullptr); + } + if (mFirstSource) { + mFirstSource = nullptr; + mNeedsFullUpdate = true; + } + mProvider = aProvider; +} + +void BufferTextureHost::DeallocateDeviceData() { + if (mFirstSource && mFirstSource->NumCompositableRefs() > 0) { + // WrappingTextureSourceYCbCrBasic wraps YUV format BufferTextureHost. + // When BufferTextureHost is destroyed, data of + // WrappingTextureSourceYCbCrBasic becomes invalid. + if (mFirstSource->AsWrappingTextureSourceYCbCrBasic() && + mFirstSource->IsOwnedBy(this)) { + mFirstSource->SetOwner(nullptr); + mFirstSource->DeallocateDeviceData(); + } + return; + } + + if (!mFirstSource || !mFirstSource->IsOwnedBy(this)) { + mFirstSource = nullptr; + return; + } + + mFirstSource->SetOwner(nullptr); + + RefPtr<TextureSource> it = mFirstSource; + while (it) { + it->DeallocateDeviceData(); + it = it->GetNextSibling(); + } +} + +bool BufferTextureHost::Lock() { + MOZ_ASSERT(!mLocked); + if (!UploadIfNeeded()) { + return false; + } + mLocked = !!mFirstSource; + return mLocked; +} + +void BufferTextureHost::Unlock() { + MOZ_ASSERT(mLocked); + mLocked = false; +} + +void BufferTextureHost::CreateRenderTexture( + const wr::ExternalImageId& aExternalImageId) { + RefPtr<wr::RenderTextureHost> texture; + + if (gfx::gfxVars::UseSoftwareWebRender()) { + texture = + new wr::RenderBufferTextureHostSWGL(GetBuffer(), GetBufferDescriptor()); + } else if (UseExternalTextures()) { + texture = + new wr::RenderExternalTextureHost(GetBuffer(), GetBufferDescriptor()); + } else { + texture = + new wr::RenderBufferTextureHost(GetBuffer(), GetBufferDescriptor()); + } + + wr::RenderThread::Get()->RegisterExternalImage(wr::AsUint64(aExternalImageId), + texture.forget()); +} + +uint32_t BufferTextureHost::NumSubTextures() { + if (GetFormat() == gfx::SurfaceFormat::YUV) { + return 3; + } + + return 1; +} + +void BufferTextureHost::PushResourceUpdates( + wr::TransactionBuilder& aResources, ResourceUpdateOp aOp, + const Range<wr::ImageKey>& aImageKeys, const wr::ExternalImageId& aExtID) { + auto method = aOp == TextureHost::ADD_IMAGE + ? &wr::TransactionBuilder::AddExternalImage + : &wr::TransactionBuilder::UpdateExternalImage; + + auto imageType = UseExternalTextures() || gfx::gfxVars::UseSoftwareWebRender() + ? wr::ExternalImageType::TextureHandle( + wr::ImageBufferKind::TextureRect) + : wr::ExternalImageType::Buffer(); + + if (GetFormat() != gfx::SurfaceFormat::YUV) { + MOZ_ASSERT(aImageKeys.length() == 1); + + wr::ImageDescriptor descriptor( + GetSize(), + ImageDataSerializer::ComputeRGBStride(GetFormat(), GetSize().width), + GetFormat()); + (aResources.*method)(aImageKeys[0], descriptor, aExtID, imageType, 0); + } else { + MOZ_ASSERT(aImageKeys.length() == 3); + + const layers::YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + wr::ImageDescriptor yDescriptor( + desc.ySize(), desc.yStride(), + SurfaceFormatForColorDepth(desc.colorDepth())); + wr::ImageDescriptor cbcrDescriptor( + desc.cbCrSize(), desc.cbCrStride(), + SurfaceFormatForColorDepth(desc.colorDepth())); + (aResources.*method)(aImageKeys[0], yDescriptor, aExtID, imageType, 0); + (aResources.*method)(aImageKeys[1], cbcrDescriptor, aExtID, imageType, 1); + (aResources.*method)(aImageKeys[2], cbcrDescriptor, aExtID, imageType, 2); + } +} + +void BufferTextureHost::PushDisplayItems(wr::DisplayListBuilder& aBuilder, + const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + wr::ImageRendering aFilter, + const Range<wr::ImageKey>& aImageKeys, + PushDisplayItemFlagSet aFlags) { + // SWGL should always try to bypass shaders and composite directly. + bool preferCompositorSurface = + aFlags.contains(PushDisplayItemFlag::PREFER_COMPOSITOR_SURFACE); + bool useExternalSurface = + aFlags.contains(PushDisplayItemFlag::SUPPORTS_EXTERNAL_BUFFER_TEXTURES); + if (GetFormat() != gfx::SurfaceFormat::YUV) { + MOZ_ASSERT(aImageKeys.length() == 1); + aBuilder.PushImage(aBounds, aClip, true, aFilter, aImageKeys[0], + !(mFlags & TextureFlags::NON_PREMULTIPLIED), + wr::ColorF{1.0f, 1.0f, 1.0f, 1.0f}, + preferCompositorSurface, useExternalSurface); + } else { + MOZ_ASSERT(aImageKeys.length() == 3); + const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + aBuilder.PushYCbCrPlanarImage( + aBounds, aClip, true, aImageKeys[0], aImageKeys[1], aImageKeys[2], + wr::ToWrColorDepth(desc.colorDepth()), + wr::ToWrYuvColorSpace(desc.yUVColorSpace()), + wr::ToWrColorRange(desc.colorRange()), aFilter, preferCompositorSurface, + useExternalSurface); + } +} + +void TextureHost::DeserializeReadLock(const ReadLockDescriptor& aDesc, + ISurfaceAllocator* aAllocator) { + if (mReadLock) { + return; + } + + mReadLock = TextureReadLock::Deserialize(aDesc, aAllocator); +} + +void TextureHost::SetReadLocked() { + if (!mReadLock) { + return; + } + // If mReadLocked is true it means we haven't read unlocked yet and the + // content side should not have been able to write into this texture and read + // lock again! + MOZ_ASSERT(!mReadLocked); + mReadLocked = true; + if (mProvider) { + mProvider->MaybeUnlockBeforeNextComposition(this); + } +} + +void TextureHost::ReadUnlock() { + if (mReadLock && mReadLocked) { + mReadLock->ReadUnlock(); + mReadLocked = false; + } +} + +bool TextureHost::NeedsYFlip() const { + return bool(mFlags & TextureFlags::ORIGIN_BOTTOM_LEFT); +} + +bool BufferTextureHost::EnsureWrappingTextureSource() { + MOZ_ASSERT(!mHasIntermediateBuffer); + + if (mFirstSource && mFirstSource->IsOwnedBy(this)) { + return true; + } + // We don't own it, apparently. + if (mFirstSource) { + mNeedsFullUpdate = true; + mFirstSource = nullptr; + } + + if (!mProvider) { + return false; + } + + if (mFormat == gfx::SurfaceFormat::YUV) { + mFirstSource = mProvider->CreateDataTextureSourceAroundYCbCr(this); + } else { + uint8_t* data = GetBuffer(); + if (!data) { + return false; + } + RefPtr<gfx::DataSourceSurface> surf = + gfx::Factory::CreateWrappingDataSourceSurface( + data, ImageDataSerializer::ComputeRGBStride(mFormat, mSize.width), + mSize, mFormat); + if (!surf) { + return false; + } + mFirstSource = mProvider->CreateDataTextureSourceAround(surf); + } + + if (!mFirstSource) { + // BasicCompositor::CreateDataTextureSourceAround never returns null + // and we don't expect to take this branch if we are using another backend. + // Returning false is fine but if we get into this situation it probably + // means something fishy is going on, like a texture being used with + // several compositor backends. + NS_WARNING("Failed to use a BufferTextureHost without intermediate buffer"); + return false; + } + + mFirstSource->SetUpdateSerial(mUpdateSerial); + mFirstSource->SetOwner(this); + + return true; +} + +static bool IsCompatibleTextureSource(TextureSource* aTexture, + const BufferDescriptor& aDescriptor, + TextureSourceProvider* aProvider) { + if (!aProvider) { + return false; + } + + switch (aDescriptor.type()) { + case BufferDescriptor::TYCbCrDescriptor: { + const YCbCrDescriptor& ycbcr = aDescriptor.get_YCbCrDescriptor(); + + if (!aProvider->SupportsEffect(EffectTypes::YCBCR)) { + return aTexture->GetFormat() == gfx::SurfaceFormat::B8G8R8X8 && + aTexture->GetSize() == ycbcr.ySize(); + } + + if (aTexture->GetFormat() != gfx::SurfaceFormat::A8 || + aTexture->GetSize() != ycbcr.ySize()) { + return false; + } + + auto cbTexture = aTexture->GetSubSource(1); + if (!cbTexture || cbTexture->GetFormat() != gfx::SurfaceFormat::A8 || + cbTexture->GetSize() != ycbcr.cbCrSize()) { + return false; + } + + auto crTexture = aTexture->GetSubSource(2); + if (!crTexture || crTexture->GetFormat() != gfx::SurfaceFormat::A8 || + crTexture->GetSize() != ycbcr.cbCrSize()) { + return false; + } + + return true; + } + case BufferDescriptor::TRGBDescriptor: { + const RGBDescriptor& rgb = aDescriptor.get_RGBDescriptor(); + return aTexture->GetFormat() == rgb.format() && + aTexture->GetSize() == rgb.size(); + } + default: { + return false; + } + } +} + +void BufferTextureHost::PrepareTextureSource( + CompositableTextureSourceRef& aTexture) { + // Reuse WrappingTextureSourceYCbCrBasic to reduce memory consumption. + if (mFormat == gfx::SurfaceFormat::YUV && !mHasIntermediateBuffer && + aTexture.get() && aTexture->AsWrappingTextureSourceYCbCrBasic() && + aTexture->NumCompositableRefs() <= 1 && + aTexture->GetSize() == GetSize()) { + aTexture->AsSourceBasic()->SetBufferTextureHost(this); + aTexture->AsDataTextureSource()->SetOwner(this); + mFirstSource = aTexture->AsDataTextureSource(); + mNeedsFullUpdate = true; + } + + if (!mHasIntermediateBuffer) { + EnsureWrappingTextureSource(); + } + + if (mFirstSource && mFirstSource->IsOwnedBy(this)) { + // We are already attached to a TextureSource, nothing to do except tell + // the compositable to use it. + aTexture = mFirstSource.get(); + return; + } + + // We don't own it, apparently. + if (mFirstSource) { + mNeedsFullUpdate = true; + mFirstSource = nullptr; + } + + DataTextureSource* texture = + aTexture.get() ? aTexture->AsDataTextureSource() : nullptr; + + bool compatibleFormats = + texture && IsCompatibleTextureSource(texture, mDescriptor, mProvider); + + bool shouldCreateTexture = !compatibleFormats || + texture->NumCompositableRefs() > 1 || + texture->HasOwner(); + + if (!shouldCreateTexture) { + mFirstSource = texture; + mFirstSource->SetOwner(this); + mNeedsFullUpdate = true; + + // It's possible that texture belonged to a different compositor, + // so make sure we update it (and all of its siblings) to the + // current one. + RefPtr<TextureSource> it = mFirstSource; + while (it) { + it->SetTextureSourceProvider(mProvider); + it = it->GetNextSibling(); + } + } +} + +bool BufferTextureHost::BindTextureSource( + CompositableTextureSourceRef& aTexture) { + MOZ_ASSERT(mLocked); + MOZ_ASSERT(mFirstSource); + aTexture = mFirstSource; + return !!aTexture; +} + +bool BufferTextureHost::AcquireTextureSource( + CompositableTextureSourceRef& aTexture) { + if (!UploadIfNeeded()) { + return false; + } + aTexture = mFirstSource; + return !!mFirstSource; +} + +void BufferTextureHost::ReadUnlock() { + if (mFirstSource) { + mFirstSource->Sync(true); + } + + TextureHost::ReadUnlock(); +} + +void BufferTextureHost::MaybeNotifyUnlocked() { +#ifdef XP_DARWIN + auto actor = GetIPDLActor(); + if (actor) { + AutoTArray<uint64_t, 1> serials; + serials.AppendElement(TextureHost::GetTextureSerial(actor)); + TextureSync::SetTexturesUnlocked(actor->OtherPid(), serials); + } +#endif +} + +void BufferTextureHost::UnbindTextureSource() { + if (mFirstSource && mFirstSource->IsOwnedBy(this)) { + mFirstSource->Unbind(); + } + + // This texture is not used by any layer anymore. + // If the texture doesn't have an intermediate buffer, it means we are + // compositing synchronously on the CPU, so we don't need to wait until + // the end of the next composition to ReadUnlock (which other textures do + // by default). + // If the texture has an intermediate buffer we don't care either because + // texture uploads are also performed synchronously for BufferTextureHost. + ReadUnlock(); + MaybeNotifyUnlocked(); +} + +gfx::SurfaceFormat BufferTextureHost::GetFormat() const { + // mFormat is the format of the data that we share with the content process. + // GetFormat, on the other hand, expects the format that we present to the + // Compositor (it is used to choose the effect type). + // if the compositor does not support YCbCr effects, we give it a RGBX texture + // instead (see BufferTextureHost::Upload) + if (mFormat == gfx::SurfaceFormat::YUV && mProvider && + !mProvider->SupportsEffect(EffectTypes::YCBCR)) { + return gfx::SurfaceFormat::R8G8B8X8; + } + return mFormat; +} + +gfx::YUVColorSpace BufferTextureHost::GetYUVColorSpace() const { + if (mFormat == gfx::SurfaceFormat::YUV) { + const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + return desc.yUVColorSpace(); + } + return gfx::YUVColorSpace::UNKNOWN; +} + +gfx::ColorDepth BufferTextureHost::GetColorDepth() const { + if (mFormat == gfx::SurfaceFormat::YUV) { + const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + return desc.colorDepth(); + } + return gfx::ColorDepth::COLOR_8; +} + +gfx::ColorRange BufferTextureHost::GetColorRange() const { + if (mFormat == gfx::SurfaceFormat::YUV) { + const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + return desc.colorRange(); + } + return TextureHost::GetColorRange(); +} + +bool BufferTextureHost::UploadIfNeeded() { + return MaybeUpload(!mNeedsFullUpdate ? &mMaybeUpdatedRegion : nullptr); +} + +bool BufferTextureHost::MaybeUpload(nsIntRegion* aRegion) { + auto serial = mFirstSource ? mFirstSource->GetUpdateSerial() : 0; + + if (serial == mUpdateSerial) { + return true; + } + + if (serial == 0) { + // 0 means the source has no valid content + aRegion = nullptr; + } + + if (!Upload(aRegion)) { + return false; + } + + if (mHasIntermediateBuffer) { + // We just did the texture upload, the content side can now freely write + // into the shared buffer. + ReadUnlock(); + MaybeNotifyUnlocked(); + } + + // We no longer have an invalid region. + mNeedsFullUpdate = false; + mMaybeUpdatedRegion.SetEmpty(); + + // If upload returns true we know mFirstSource is not null + mFirstSource->SetUpdateSerial(mUpdateSerial); + return true; +} + +bool BufferTextureHost::Upload(nsIntRegion* aRegion) { + uint8_t* buf = GetBuffer(); + if (!buf) { + // We don't have a buffer; a possible cause is that the IPDL actor + // is already dead. This inevitably happens as IPDL actors can die + // at any time, so we want to silently return in this case. + // another possible cause is that IPDL failed to map the shmem when + // deserializing it. + return false; + } + if (!mProvider) { + // This can happen if we send textures to a compositable that isn't yet + // attached to a layer. + return false; + } + if (!mHasIntermediateBuffer && EnsureWrappingTextureSource()) { + if (!mFirstSource || !mFirstSource->IsDirectMap()) { + return true; + } + } + + if (mFormat == gfx::SurfaceFormat::UNKNOWN) { + NS_WARNING("BufferTextureHost: unsupported format!"); + return false; + } else if (mFormat == gfx::SurfaceFormat::YUV) { + const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor(); + + if (!mProvider->SupportsEffect(EffectTypes::YCBCR)) { + RefPtr<gfx::DataSourceSurface> surf = + ImageDataSerializer::DataSourceSurfaceFromYCbCrDescriptor( + buf, mDescriptor.get_YCbCrDescriptor()); + if (NS_WARN_IF(!surf)) { + return false; + } + if (!mFirstSource) { + mFirstSource = mProvider->CreateDataTextureSource( + mFlags | TextureFlags::RGB_FROM_YCBCR); + mFirstSource->SetOwner(this); + } + return mFirstSource->Update(surf, aRegion); + } + + RefPtr<DataTextureSource> srcY; + RefPtr<DataTextureSource> srcU; + RefPtr<DataTextureSource> srcV; + if (!mFirstSource) { + // We don't support BigImages for YCbCr compositing. + srcY = mProvider->CreateDataTextureSource( + mFlags | TextureFlags::DISALLOW_BIGIMAGE); + srcU = mProvider->CreateDataTextureSource( + mFlags | TextureFlags::DISALLOW_BIGIMAGE); + srcV = mProvider->CreateDataTextureSource( + mFlags | TextureFlags::DISALLOW_BIGIMAGE); + mFirstSource = srcY; + mFirstSource->SetOwner(this); + srcY->SetNextSibling(srcU); + srcU->SetNextSibling(srcV); + } else { + // mFormat never changes so if this was created as a YCbCr host and + // already contains a source it should already have 3 sources. + // BufferTextureHost only uses DataTextureSources so it is safe to assume + // all 3 sources are DataTextureSource. + MOZ_ASSERT(mFirstSource->GetNextSibling()); + MOZ_ASSERT(mFirstSource->GetNextSibling()->GetNextSibling()); + srcY = mFirstSource; + srcU = mFirstSource->GetNextSibling()->AsDataTextureSource(); + srcV = mFirstSource->GetNextSibling() + ->GetNextSibling() + ->AsDataTextureSource(); + } + + RefPtr<gfx::DataSourceSurface> tempY = + gfx::Factory::CreateWrappingDataSourceSurface( + ImageDataSerializer::GetYChannel(buf, desc), desc.yStride(), + desc.ySize(), SurfaceFormatForColorDepth(desc.colorDepth())); + RefPtr<gfx::DataSourceSurface> tempCb = + gfx::Factory::CreateWrappingDataSourceSurface( + ImageDataSerializer::GetCbChannel(buf, desc), desc.cbCrStride(), + desc.cbCrSize(), SurfaceFormatForColorDepth(desc.colorDepth())); + RefPtr<gfx::DataSourceSurface> tempCr = + gfx::Factory::CreateWrappingDataSourceSurface( + ImageDataSerializer::GetCrChannel(buf, desc), desc.cbCrStride(), + desc.cbCrSize(), SurfaceFormatForColorDepth(desc.colorDepth())); + // We don't support partial updates for Y U V textures + NS_ASSERTION(!aRegion, "Unsupported partial updates for YCbCr textures"); + if (!tempY || !tempCb || !tempCr || !srcY->Update(tempY) || + !srcU->Update(tempCb) || !srcV->Update(tempCr)) { + NS_WARNING("failed to update the DataTextureSource"); + return false; + } + } else { + // non-YCbCr case + nsIntRegion* regionToUpdate = aRegion; + if (!mFirstSource) { + mFirstSource = mProvider->CreateDataTextureSource(mFlags); + mFirstSource->SetOwner(this); + if (mFlags & TextureFlags::COMPONENT_ALPHA) { + // Update the full region the first time for component alpha textures. + regionToUpdate = nullptr; + } + } + + RefPtr<gfx::DataSourceSurface> surf = + gfx::Factory::CreateWrappingDataSourceSurface( + GetBuffer(), + ImageDataSerializer::ComputeRGBStride(mFormat, mSize.width), mSize, + mFormat); + if (!surf) { + return false; + } + + if (!mFirstSource->Update(surf.get(), regionToUpdate)) { + NS_WARNING("failed to update the DataTextureSource"); + return false; + } + } + MOZ_ASSERT(mFirstSource); + return true; +} + +already_AddRefed<gfx::DataSourceSurface> BufferTextureHost::GetAsSurface() { + RefPtr<gfx::DataSourceSurface> result; + if (mFormat == gfx::SurfaceFormat::UNKNOWN) { + NS_WARNING("BufferTextureHost: unsupported format!"); + return nullptr; + } else if (mFormat == gfx::SurfaceFormat::YUV) { + result = ImageDataSerializer::DataSourceSurfaceFromYCbCrDescriptor( + GetBuffer(), mDescriptor.get_YCbCrDescriptor()); + if (NS_WARN_IF(!result)) { + return nullptr; + } + } else { + result = gfx::Factory::CreateWrappingDataSourceSurface( + GetBuffer(), + ImageDataSerializer::GetRGBStride(mDescriptor.get_RGBDescriptor()), + mSize, mFormat); + } + return result.forget(); +} + +ShmemTextureHost::ShmemTextureHost(const ipc::Shmem& aShmem, + const BufferDescriptor& aDesc, + ISurfaceAllocator* aDeallocator, + TextureFlags aFlags) + : BufferTextureHost(aDesc, aFlags), mDeallocator(aDeallocator) { + if (aShmem.IsReadable()) { + mShmem = MakeUnique<ipc::Shmem>(aShmem); + } else { + // This can happen if we failed to map the shmem on this process, perhaps + // because it was big and we didn't have enough contiguous address space + // available, even though we did on the child process. + // As a result this texture will be in an invalid state and Lock will + // always fail. + + gfxCriticalNote << "Failed to create a valid ShmemTextureHost"; + } + + MOZ_COUNT_CTOR(ShmemTextureHost); +} + +ShmemTextureHost::~ShmemTextureHost() { + MOZ_ASSERT(!mShmem || (mFlags & TextureFlags::DEALLOCATE_CLIENT), + "Leaking our buffer"); + DeallocateDeviceData(); + MOZ_COUNT_DTOR(ShmemTextureHost); +} + +void ShmemTextureHost::DeallocateSharedData() { + if (mShmem) { + MOZ_ASSERT(mDeallocator, + "Shared memory would leak without a ISurfaceAllocator"); + mDeallocator->AsShmemAllocator()->DeallocShmem(*mShmem); + mShmem = nullptr; + } +} + +void ShmemTextureHost::ForgetSharedData() { + if (mShmem) { + mShmem = nullptr; + } +} + +void ShmemTextureHost::OnShutdown() { mShmem = nullptr; } + +uint8_t* ShmemTextureHost::GetBuffer() { + return mShmem ? mShmem->get<uint8_t>() : nullptr; +} + +size_t ShmemTextureHost::GetBufferSize() { + return mShmem ? mShmem->Size<uint8_t>() : 0; +} + +MemoryTextureHost::MemoryTextureHost(uint8_t* aBuffer, + const BufferDescriptor& aDesc, + TextureFlags aFlags) + : BufferTextureHost(aDesc, aFlags), mBuffer(aBuffer) { + MOZ_COUNT_CTOR(MemoryTextureHost); +} + +MemoryTextureHost::~MemoryTextureHost() { + MOZ_ASSERT(!mBuffer || (mFlags & TextureFlags::DEALLOCATE_CLIENT), + "Leaking our buffer"); + DeallocateDeviceData(); + MOZ_COUNT_DTOR(MemoryTextureHost); +} + +void MemoryTextureHost::DeallocateSharedData() { + if (mBuffer) { + GfxMemoryImageReporter::WillFree(mBuffer); + } + delete[] mBuffer; + mBuffer = nullptr; +} + +void MemoryTextureHost::ForgetSharedData() { mBuffer = nullptr; } + +uint8_t* MemoryTextureHost::GetBuffer() { return mBuffer; } + +size_t MemoryTextureHost::GetBufferSize() { + // MemoryTextureHost just trusts that the buffer size is large enough to read + // anything we need to. That's because MemoryTextureHost has to trust the + // buffer pointer anyway, so the security model here is just that + // MemoryTexture's are restricted to same-process clients. + return std::numeric_limits<size_t>::max(); +} + +TextureParent::TextureParent(HostIPCAllocator* aSurfaceAllocator, + uint64_t aSerial, + const wr::MaybeExternalImageId& aExternalImageId) + : mSurfaceAllocator(aSurfaceAllocator), + mSerial(aSerial), + mExternalImageId(aExternalImageId) { + MOZ_COUNT_CTOR(TextureParent); +} + +TextureParent::~TextureParent() { MOZ_COUNT_DTOR(TextureParent); } + +void TextureParent::NotifyNotUsed(uint64_t aTransactionId) { + if (!mTextureHost) { + return; + } + mSurfaceAllocator->NotifyNotUsed(this, aTransactionId); +} + +bool TextureParent::Init(const SurfaceDescriptor& aSharedData, + const ReadLockDescriptor& aReadLock, + const LayersBackend& aBackend, + const TextureFlags& aFlags) { + mTextureHost = TextureHost::Create(aSharedData, aReadLock, mSurfaceAllocator, + aBackend, aFlags, mExternalImageId); + if (mTextureHost) { + mTextureHost->mActor = this; + } + + return !!mTextureHost; +} + +void TextureParent::Destroy() { + if (!mTextureHost) { + return; + } + + if (mTextureHost->mReadLocked) { + // ReadUnlock here to make sure the ReadLock's shmem does not outlive the + // protocol that created it. + mTextureHost->ReadUnlock(); + mTextureHost->MaybeNotifyUnlocked(); + } + + if (mTextureHost->GetFlags() & TextureFlags::DEALLOCATE_CLIENT) { + mTextureHost->ForgetSharedData(); + } + + mTextureHost->mActor = nullptr; + mTextureHost = nullptr; +} + +void TextureHost::ReceivedDestroy(PTextureParent* aActor) { + static_cast<TextureParent*>(aActor)->RecvDestroy(); +} + +mozilla::ipc::IPCResult TextureParent::RecvRecycleTexture( + const TextureFlags& aTextureFlags) { + if (!mTextureHost) { + return IPC_OK(); + } + mTextureHost->RecycleTexture(aTextureFlags); + return IPC_OK(); +} + +//////////////////////////////////////////////////////////////////////////////// + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/TextureHost.h b/gfx/layers/composite/TextureHost.h new file mode 100644 index 0000000000..aafbde1e0d --- /dev/null +++ b/gfx/layers/composite/TextureHost.h @@ -0,0 +1,1082 @@ +/* -*- 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_TEXTUREHOST_H +#define MOZILLA_GFX_TEXTUREHOST_H + +#include <stddef.h> // for size_t +#include <stdint.h> // for uint64_t, uint32_t, uint8_t +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr, already_AddRefed, etc +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/Matrix.h" +#include "mozilla/gfx/Point.h" // for IntSize, IntPoint +#include "mozilla/gfx/Rect.h" +#include "mozilla/gfx/Types.h" // for SurfaceFormat, etc +#include "mozilla/ipc/FileDescriptor.h" +#include "mozilla/layers/CompositorTypes.h" // for TextureFlags, etc +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "mozilla/layers/LayersSurfaces.h" +#include "mozilla/mozalloc.h" // for operator delete +#include "mozilla/Range.h" +#include "mozilla/UniquePtr.h" // for UniquePtr +#include "mozilla/webrender/WebRenderTypes.h" +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsDebug.h" // for NS_WARNING +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc +#include "nsRect.h" +#include "nsRegion.h" // for nsIntRegion +#include "nsTraceRefcnt.h" // for MOZ_COUNT_CTOR, etc +#include "nscore.h" // for nsACString +#include "mozilla/layers/AtomicRefCountedWithFinalize.h" + +class MacIOSurface; +namespace mozilla { +namespace gfx { +class DataSourceSurface; +} + +namespace ipc { +class Shmem; +} // namespace ipc + +namespace wr { +class DisplayListBuilder; +class TransactionBuilder; +} // namespace wr + +namespace layers { + +class AndroidHardwareBuffer; +class AndroidHardwareBufferTextureHost; +class BufferDescriptor; +class BufferTextureHost; +class Compositor; +class CompositableParentManager; +class ReadLockDescriptor; +class CompositorBridgeParent; +class SurfaceDescriptor; +class HostIPCAllocator; +class ISurfaceAllocator; +class MacIOSurfaceTextureHostOGL; +class SurfaceTextureHost; +class TextureHostOGL; +class TextureReadLock; +class TextureSourceOGL; +class TextureSourceD3D11; +class TextureSourceBasic; +class TextureSourceProvider; +class DataTextureSource; +class PTextureParent; +class TextureParent; +class WebRenderTextureHost; +class WrappingTextureSourceYCbCrBasic; + +/** + * A view on a TextureHost where the texture is internally represented as tiles + * (contrast with a tiled buffer, where each texture is a tile). For iteration + * by the texture's buffer host. This is only useful when the underlying surface + * is too big to fit in one device texture, which forces us to split it in + * smaller parts. Tiled Compositable is a different thing. + */ +class BigImageIterator { + public: + virtual void BeginBigImageIteration() = 0; + virtual void EndBigImageIteration(){}; + virtual gfx::IntRect GetTileRect() = 0; + virtual size_t GetTileCount() = 0; + virtual bool NextTile() = 0; +}; + +/** + * TextureSource is the interface for texture objects that can be composited + * by a given compositor backend. Since the drawing APIs are different + * between backends, the TextureSource interface is split into different + * interfaces (TextureSourceOGL, etc.), and TextureSource mostly provide + * access to these interfaces. + * + * This class is used on the compositor side. + */ +class TextureSource : public RefCounted<TextureSource> { + public: + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(TextureSource) + + TextureSource(); + + virtual ~TextureSource(); + + virtual const char* Name() const = 0; + + /** + * Should be overridden in order to deallocate the data that is associated + * with the rendering backend, such as GL textures. + */ + virtual void DeallocateDeviceData() {} + + /** + * Return the size of the texture in texels. + * If this is a tile iterator, GetSize must return the size of the current + * tile. + */ + virtual gfx::IntSize GetSize() const = 0; + + /** + * Return the pixel format of this texture + */ + virtual gfx::SurfaceFormat GetFormat() const { + return gfx::SurfaceFormat::UNKNOWN; + } + + /** + * Cast to a TextureSource for for each backend.. + */ + virtual TextureSourceOGL* AsSourceOGL() { + gfxCriticalNote << "Failed to cast " << Name() + << " into a TextureSourceOGL"; + return nullptr; + } + virtual TextureSourceD3D11* AsSourceD3D11() { return nullptr; } + virtual TextureSourceBasic* AsSourceBasic() { return nullptr; } + /** + * Cast to a DataTextureSurce. + */ + virtual DataTextureSource* AsDataTextureSource() { return nullptr; } + virtual WrappingTextureSourceYCbCrBasic* AsWrappingTextureSourceYCbCrBasic() { + return nullptr; + } + + /** + * Overload this if the TextureSource supports big textures that don't fit in + * one device texture and must be tiled internally. + */ + virtual BigImageIterator* AsBigImageIterator() { return nullptr; } + + virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) {} + + virtual void Unbind() {} + + void SetNextSibling(TextureSource* aTexture) { mNextSibling = aTexture; } + + TextureSource* GetNextSibling() const { return mNextSibling; } + + /** + * In some rare cases we currently need to consider a group of textures as one + * TextureSource, that can be split in sub-TextureSources. + */ + TextureSource* GetSubSource(int index) { + switch (index) { + case 0: + return this; + case 1: + return GetNextSibling(); + case 2: + return GetNextSibling() ? GetNextSibling()->GetNextSibling() : nullptr; + } + return nullptr; + } + + void AddCompositableRef() { ++mCompositableCount; } + + void ReleaseCompositableRef() { + --mCompositableCount; + MOZ_ASSERT(mCompositableCount >= 0); + } + + // When iterating as a BigImage, this creates temporary TextureSources + // wrapping individual tiles. + virtual RefPtr<TextureSource> ExtractCurrentTile() { + NS_WARNING("Implementation does not expose tile sources"); + return nullptr; + } + + int NumCompositableRefs() const { return mCompositableCount; } + + // Some texture sources could wrap the cpu buffer to gpu directly. Then, + // we could get better performance of texture uploading. + virtual bool IsDirectMap() { return false; } + // The direct-map cpu buffer should be alive when gpu uses it. And it + // should not be updated while gpu reads it. This Sync() function + // implements this synchronized behavior by allowing us to check if + // the GPU is done with the texture, and block on it if aBlocking is + // true. + virtual bool Sync(bool aBlocking) { return true; } + + protected: + RefPtr<TextureSource> mNextSibling; + int mCompositableCount; +}; + +/// Equivalent of a RefPtr<TextureSource>, that calls AddCompositableRef and +/// ReleaseCompositableRef in addition to the usual AddRef and Release. +/// +/// The semantoics of these CompositableTextureRefs are important because they +/// are used both as a synchronization/safety mechanism, and as an optimization +/// mechanism. They are also tricky and subtle because we use them in a very +/// implicit way (assigning to a CompositableTextureRef is less visible than +/// explicitly calling a method or whatnot). +/// It is Therefore important to be careful about the way we use this tool. +/// +/// CompositableTextureRef is a mechanism that lets us count how many +/// compositables are using a given texture (for TextureSource and TextureHost). +/// We use it to run specific code when a texture is not used anymore, and also +/// we trigger fast paths on some operations when we can see that the texture's +/// CompositableTextureRef counter is equal to 1 (the texture is not shared +/// between compositables). +/// This means that it is important to observe the following rules: +/// * CompositableHosts that receive UseTexture and similar messages *must* +/// store all of the TextureHosts they receive in CompositableTextureRef slots +/// for as long as they may be using them. +/// * CompositableHosts must store each texture in a *single* +/// CompositableTextureRef slot to ensure that the counter properly reflects how +/// many compositables are using the texture. If a compositable needs to hold +/// two references to a given texture (for example to have a pointer to the +/// current texture in a list of textures that may be used), it can hold its +/// extra references with RefPtr or whichever pointer type makes sense. +template <typename T> +class CompositableTextureRef { + public: + CompositableTextureRef() = default; + + explicit CompositableTextureRef(const CompositableTextureRef& aOther) { + *this = aOther; + } + + explicit CompositableTextureRef(T* aOther) { *this = aOther; } + + ~CompositableTextureRef() { + if (mRef) { + mRef->ReleaseCompositableRef(); + } + } + + CompositableTextureRef& operator=(const CompositableTextureRef& aOther) { + if (aOther.get()) { + aOther->AddCompositableRef(); + } + if (mRef) { + mRef->ReleaseCompositableRef(); + } + mRef = aOther.get(); + return *this; + } + + CompositableTextureRef& operator=(T* aOther) { + if (aOther) { + aOther->AddCompositableRef(); + } + if (mRef) { + mRef->ReleaseCompositableRef(); + } + mRef = aOther; + return *this; + } + + T* get() const { return mRef; } + operator T*() const { return mRef; } + T* operator->() const { return mRef; } + T& operator*() const { return *mRef; } + + private: + RefPtr<T> mRef; +}; + +typedef CompositableTextureRef<TextureSource> CompositableTextureSourceRef; +typedef CompositableTextureRef<TextureHost> CompositableTextureHostRef; + +/** + * Interface for TextureSources that can be updated from a DataSourceSurface. + * + * All backend should implement at least one DataTextureSource. + */ +class DataTextureSource : public TextureSource { + public: + DataTextureSource() : mOwner(0), mUpdateSerial(0) {} + + const char* Name() const override { return "DataTextureSource"; } + + DataTextureSource* AsDataTextureSource() override { return this; } + + /** + * Upload a (portion of) surface to the TextureSource. + * + * The DataTextureSource doesn't own aSurface, although it owns and manage + * the device texture it uploads to internally. + */ + virtual bool Update(gfx::DataSourceSurface* aSurface, + nsIntRegion* aDestRegion = nullptr, + gfx::IntPoint* aSrcOffset = nullptr) = 0; + + /** + * A facility to avoid reuploading when it is not necessary. + * The caller of Update can use GetUpdateSerial to see if the number has + * changed since last update, and call SetUpdateSerial after each successful + * update. The caller is responsible for managing the update serial except + * when the texture data is deallocated in which case the TextureSource should + * always reset the update serial to zero. + */ + uint32_t GetUpdateSerial() const { return mUpdateSerial; } + void SetUpdateSerial(uint32_t aValue) { mUpdateSerial = aValue; } + + // By default at least set the update serial to zero. + // overloaded versions should do that too. + void DeallocateDeviceData() override { SetUpdateSerial(0); } + +#ifdef DEBUG + /** + * Provide read access to the data as a DataSourceSurface. + * + * This is expected to be very slow and should be used for mostly debugging. + * XXX - implement everywhere and make it pure virtual. + */ + virtual already_AddRefed<gfx::DataSourceSurface> ReadBack() { + return nullptr; + }; +#endif + + void SetOwner(TextureHost* aOwner) { + auto newOwner = (uintptr_t)aOwner; + if (newOwner != mOwner) { + mOwner = newOwner; + SetUpdateSerial(0); + } + } + + bool IsOwnedBy(TextureHost* aOwner) const { + return mOwner == (uintptr_t)aOwner; + } + + bool HasOwner() const { return !IsOwnedBy(nullptr); } + + private: + // We store mOwner as an integer rather than as a pointer to make it clear + // it is not intended to be dereferenced. + uintptr_t mOwner; + uint32_t mUpdateSerial; +}; + +/** + * TextureHost is a thin abstraction over texture data that need to be shared + * between the content process and the compositor process. It is the + * compositor-side half of a TextureClient/TextureHost pair. A corresponding + * TextureClient lives on the content-side. + * + * TextureHost only knows how to deserialize or synchronize generic image data + * (SurfaceDescriptor) and provide access to one or more TextureSource objects + * (these provide the necessary APIs for compositor backends to composite the + * image). + * + * A TextureHost implementation corresponds to one SurfaceDescriptor type, as + * opposed to TextureSource that corresponds to device textures. + * This means that for YCbCr planes, even though they are represented as + * 3 textures internally (3 TextureSources), we use 1 TextureHost and not 3, + * because the 3 planes are stored in the same buffer of shared memory, before + * they are uploaded separately. + * + * There is always one and only one TextureHost per TextureClient, and the + * TextureClient/Host pair only owns one buffer of image data through its + * lifetime. This means that the lifetime of the underlying shared data + * matches the lifetime of the TextureClient/Host pair. It also means + * TextureClient/Host do not implement double buffering, which is the + * reponsibility of the compositable (which would use two Texture pairs). + * + * The Lock/Unlock mecanism here mirrors Lock/Unlock in TextureClient. + * + */ +class TextureHost : public AtomicRefCountedWithFinalize<TextureHost> { + /** + * Called once, just before the destructor. + * + * Here goes the shut-down code that uses virtual methods. + * Must only be called by Release(). + */ + void Finalize(); + + friend class AtomicRefCountedWithFinalize<TextureHost>; + + public: + explicit TextureHost(TextureFlags aFlags); + + protected: + virtual ~TextureHost(); + + public: + /** + * Factory method. + */ + static already_AddRefed<TextureHost> Create( + const SurfaceDescriptor& aDesc, const ReadLockDescriptor& aReadLock, + ISurfaceAllocator* aDeallocator, LayersBackend aBackend, + TextureFlags aFlags, wr::MaybeExternalImageId& aExternalImageId); + + /** + * Lock the texture host for compositing. + */ + virtual bool Lock() { return true; } + /** + * Unlock the texture host after compositing. Lock() and Unlock() should be + * called in pair. + */ + virtual void Unlock() {} + + /** + * Lock the texture host for compositing without using compositor. + */ + virtual bool LockWithoutCompositor() { return true; } + /** + * Similar to Unlock(), but it should be called with LockWithoutCompositor(). + */ + virtual void UnlockWithoutCompositor() {} + + /** + * Note that the texture host format can be different from its corresponding + * texture source's. For example a ShmemTextureHost can have the ycbcr + * format and produce 3 "alpha" textures sources. + */ + virtual gfx::SurfaceFormat GetFormat() const = 0; + /** + * Return the format used for reading the texture. + * Apple's YCBCR_422 is R8G8B8X8. + */ + virtual gfx::SurfaceFormat GetReadFormat() const { return GetFormat(); } + + virtual gfx::YUVColorSpace GetYUVColorSpace() const { + return gfx::YUVColorSpace::UNKNOWN; + } + + /** + * Return the color depth of the image. Used with YUV textures. + */ + virtual gfx::ColorDepth GetColorDepth() const { + return gfx::ColorDepth::COLOR_8; + } + + /** + * Return true if using full range values (0-255 if 8 bits YUV). Used with YUV + * textures. + */ + virtual gfx::ColorRange GetColorRange() const { + return gfx::ColorRange::LIMITED; + } + + /** + * Called during the transaction. The TextureSource may or may not be + * composited. + * + * Note that this is called outside of lock/unlock. + */ + virtual void PrepareTextureSource(CompositableTextureSourceRef& aTexture) {} + + /** + * Called at composition time, just before compositing the TextureSource + * composited. + * + * Note that this is called only withing lock/unlock. + */ + virtual bool BindTextureSource(CompositableTextureSourceRef& aTexture) = 0; + + /** + * Called when preparing the rendering pipeline for advanced-layers. This is + * a lockless version of BindTextureSource. + */ + virtual bool AcquireTextureSource(CompositableTextureSourceRef& aTexture) { + return false; + } + + /** + * Called when another TextureHost will take over. + */ + virtual void UnbindTextureSource(); + + virtual bool IsValid() { return true; } + + /** + * Is called before compositing if the shared data has changed since last + * composition. + * This method should be overload in cases like when we need to do a texture + * upload for example. + * + * @param aRegion The region that has been changed, if nil, it means that the + * entire surface should be updated. + */ + void Updated(const nsIntRegion* aRegion = nullptr); + + /** + * Sets this TextureHost's compositor. A TextureHost can change compositor + * on certain occasions, in particular if it belongs to an async Compositable. + * aCompositor can be null, in which case the TextureHost must cleanup all + * of its device textures. + * + * Setting mProvider from this callback implicitly causes the texture to + * be locked for an extra frame after being detached from a compositable. + */ + virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) {} + + /** + * Should be overridden in order to deallocate the data that is associated + * with the rendering backend, such as GL textures. + */ + virtual void DeallocateDeviceData() {} + + /** + * Should be overridden in order to deallocate the data that is shared with + * the content side, such as shared memory. + */ + virtual void DeallocateSharedData() {} + + /** + * Should be overridden in order to force the TextureHost to drop all + * references to it's shared data. + * + * This is important to ensure the correctness of the deallocation protocol. + */ + virtual void ForgetSharedData() {} + + virtual gfx::IntSize GetSize() const = 0; + + /** + * Should be overridden if TextureHost supports crop rect. + */ + virtual void SetCropRect(nsIntRect aCropRect) {} + + /** + * Debug facility. + * XXX - cool kids use Moz2D. See bug 882113. + */ + virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() = 0; + + /** + * XXX - Flags should only be set at creation time, this will be removed. + */ + void SetFlags(TextureFlags aFlags) { mFlags = aFlags; } + + /** + * XXX - Flags should only be set at creation time, this will be removed. + */ + void AddFlag(TextureFlags aFlag) { mFlags |= aFlag; } + + TextureFlags GetFlags() { return mFlags; } + + /** + * Allocate and deallocate a TextureParent actor. + * + * TextureParent< is an implementation detail of TextureHost that is not + * exposed to the rest of the code base. CreateIPDLActor and DestroyIPDLActor + * are for use with the managing IPDL protocols only (so that they can + * implement AllocPTextureParent and DeallocPTextureParent). + */ + static PTextureParent* CreateIPDLActor( + HostIPCAllocator* aAllocator, const SurfaceDescriptor& aSharedData, + const ReadLockDescriptor& aDescriptor, LayersBackend aLayersBackend, + TextureFlags aFlags, uint64_t aSerial, + const wr::MaybeExternalImageId& aExternalImageId); + static bool DestroyIPDLActor(PTextureParent* actor); + + /** + * Destroy the TextureChild/Parent pair. + */ + static bool SendDeleteIPDLActor(PTextureParent* actor); + + static void ReceivedDestroy(PTextureParent* actor); + + /** + * Get the TextureHost corresponding to the actor passed in parameter. + */ + static TextureHost* AsTextureHost(PTextureParent* actor); + + static uint64_t GetTextureSerial(PTextureParent* actor); + + /** + * Return a pointer to the IPDLActor. + * + * This is to be used with IPDL messages only. Do not store the returned + * pointer. + */ + PTextureParent* GetIPDLActor(); + + // If a texture host holds a reference to shmem, it should override this + // method to forget about the shmem _without_ releasing it. + virtual void OnShutdown() {} + + // Forget buffer actor. Used only for hacky fix for bug 966446. + virtual void ForgetBufferActor() {} + + virtual const char* Name() { return "TextureHost"; } + virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix); + + /** + * Indicates whether the TextureHost implementation is backed by an + * in-memory buffer. The consequence of this is that locking the + * TextureHost does not contend with locking the texture on the client side. + */ + virtual bool HasIntermediateBuffer() const { return false; } + + /** + * Returns true if the TextureHost can be released before the rendering is + * completed, otherwise returns false. + */ + virtual bool NeedsDeferredDeletion() const { + return !HasIntermediateBuffer(); + } + + void AddCompositableRef() { + ++mCompositableCount; + if (mCompositableCount == 1) { + PrepareForUse(); + } + } + + void ReleaseCompositableRef() { + --mCompositableCount; + MOZ_ASSERT(mCompositableCount >= 0); + if (mCompositableCount == 0) { + UnbindTextureSource(); + // Send mFwdTransactionId to client side if necessary. + NotifyNotUsed(); + } + } + + int NumCompositableRefs() const { return mCompositableCount; } + + void SetLastFwdTransactionId(uint64_t aTransactionId); + + void DeserializeReadLock(const ReadLockDescriptor& aDesc, + ISurfaceAllocator* aAllocator); + void SetReadLocked(); + + TextureReadLock* GetReadLock() { return mReadLock; } + + virtual BufferTextureHost* AsBufferTextureHost() { return nullptr; } + virtual MacIOSurfaceTextureHostOGL* AsMacIOSurfaceTextureHost() { + return nullptr; + } + virtual WebRenderTextureHost* AsWebRenderTextureHost() { return nullptr; } + virtual SurfaceTextureHost* AsSurfaceTextureHost() { return nullptr; } + virtual AndroidHardwareBufferTextureHost* + AsAndroidHardwareBufferTextureHost() { + return nullptr; + } + + // Create the corresponding RenderTextureHost type of this texture, and + // register the RenderTextureHost into render thread. + virtual void CreateRenderTexture( + const wr::ExternalImageId& aExternalImageId) { + MOZ_RELEASE_ASSERT( + false, + "No CreateRenderTexture() implementation for this TextureHost type."); + } + + void EnsureRenderTexture(const wr::MaybeExternalImageId& aExternalImageId); + + // Destroy RenderTextureHost when it was created by the TextureHost. + // It is called in TextureHost::Finalize(). + virtual void MaybeDestroyRenderTexture(); + + static void DestroyRenderTexture(const wr::ExternalImageId& aExternalImageId); + + /// Returns the number of actual textures that will be used to render this. + /// For example in a lot of YUV cases it will be 3 + virtual uint32_t NumSubTextures() { return 1; } + + enum ResourceUpdateOp { + ADD_IMAGE, + UPDATE_IMAGE, + }; + + // Add all necessary TextureHost informations to the resource update queue. + virtual void PushResourceUpdates(wr::TransactionBuilder& aResources, + ResourceUpdateOp aOp, + const Range<wr::ImageKey>& aImageKeys, + const wr::ExternalImageId& aExtID) { + MOZ_ASSERT_UNREACHABLE("Unimplemented"); + } + + enum class PushDisplayItemFlag { + // Passed if the caller wants these display items to be promoted + // to compositor surfaces if possible. + PREFER_COMPOSITOR_SURFACE, + + // Passed in the RenderCompositor supports BufferTextureHosts + // being used directly as external compositor surfaces. + SUPPORTS_EXTERNAL_BUFFER_TEXTURES, + }; + using PushDisplayItemFlagSet = EnumSet<PushDisplayItemFlag>; + + // Put all necessary WR commands into DisplayListBuilder for this textureHost + // rendering. + virtual void PushDisplayItems(wr::DisplayListBuilder& aBuilder, + const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, + wr::ImageRendering aFilter, + const Range<wr::ImageKey>& aKeys, + PushDisplayItemFlagSet aFlags) { + MOZ_ASSERT_UNREACHABLE( + "No PushDisplayItems() implementation for this TextureHost type."); + } + + /** + * Some API's can use the cross-process IOSurface directly, such as OpenVR + */ + virtual MacIOSurface* GetMacIOSurface() { return nullptr; } + + virtual bool IsDirectMap() { return false; } + + virtual bool NeedsYFlip() const; + + TextureSourceProvider* GetProvider() const { return mProvider; } + + virtual void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) {} + + virtual void SetReleaseFence(mozilla::ipc::FileDescriptor&& aFenceFd) {} + + virtual mozilla::ipc::FileDescriptor GetAndResetReleaseFence() { + return mozilla::ipc::FileDescriptor(); + } + + virtual AndroidHardwareBuffer* GetAndroidHardwareBuffer() const { + return nullptr; + } + + virtual bool SupportsExternalCompositing() { return false; } + + protected: + virtual void ReadUnlock(); + + void RecycleTexture(TextureFlags aFlags); + + virtual void MaybeNotifyUnlocked() {} + + virtual void UpdatedInternal(const nsIntRegion* Region) {} + + /** + * Called when mCompositableCount becomes from 0 to 1. + */ + virtual void PrepareForUse() {} + + /** + * Called when mCompositableCount becomes 0. + */ + virtual void NotifyNotUsed(); + + // for Compositor. + void CallNotifyNotUsed(); + + PTextureParent* mActor; + RefPtr<TextureSourceProvider> mProvider; + RefPtr<TextureReadLock> mReadLock; + TextureFlags mFlags; + int mCompositableCount; + uint64_t mFwdTransactionId; + bool mReadLocked; + wr::MaybeExternalImageId mExternalImageId; + + friend class Compositor; + friend class TextureParent; + friend class TiledLayerBufferComposite; + friend class TextureSourceProvider; + friend class GPUVideoTextureHost; + friend class WebRenderTextureHost; +}; + +/** + * TextureHost that wraps a random access buffer such as a Shmem or some raw + * memory. + * + * This TextureHost is backend-independent and the backend-specific bits are + * in the TextureSource. + * This class must be inherited to implement GetBuffer and DeallocSharedData + * (see ShmemTextureHost and MemoryTextureHost) + * + * Uploads happen when Lock is called. + * + * BufferTextureHost supports YCbCr and flavours of RGBA images (RGBX, A, etc.). + */ +class BufferTextureHost : public TextureHost { + public: + BufferTextureHost(const BufferDescriptor& aDescriptor, TextureFlags aFlags); + + virtual ~BufferTextureHost(); + + virtual uint8_t* GetBuffer() = 0; + + virtual size_t GetBufferSize() = 0; + + bool Lock() override; + + void Unlock() override; + + void PrepareTextureSource(CompositableTextureSourceRef& aTexture) override; + + bool BindTextureSource(CompositableTextureSourceRef& aTexture) override; + bool AcquireTextureSource(CompositableTextureSourceRef& aTexture) override; + + void UnbindTextureSource() override; + + void DeallocateDeviceData() override; + + void SetTextureSourceProvider(TextureSourceProvider* aProvider) override; + + /** + * Return the format that is exposed to the compositor when calling + * BindTextureSource. + * + * If the shared format is YCbCr and the compositor does not support it, + * GetFormat will be RGB32 (even though mFormat is SurfaceFormat::YUV). + */ + gfx::SurfaceFormat GetFormat() const override; + + gfx::YUVColorSpace GetYUVColorSpace() const override; + + gfx::ColorDepth GetColorDepth() const override; + + gfx::ColorRange GetColorRange() const override; + + gfx::IntSize GetSize() const override { return mSize; } + + already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override; + + bool HasIntermediateBuffer() const override { return mHasIntermediateBuffer; } + + bool NeedsDeferredDeletion() const override { + return TextureHost::NeedsDeferredDeletion() || UseExternalTextures(); + } + + BufferTextureHost* AsBufferTextureHost() override { return this; } + + const BufferDescriptor& GetBufferDescriptor() const { return mDescriptor; } + + void CreateRenderTexture( + const wr::ExternalImageId& aExternalImageId) override; + + uint32_t NumSubTextures() override; + + void PushResourceUpdates(wr::TransactionBuilder& aResources, + ResourceUpdateOp aOp, + const Range<wr::ImageKey>& aImageKeys, + const wr::ExternalImageId& aExtID) override; + + void PushDisplayItems(wr::DisplayListBuilder& aBuilder, + const wr::LayoutRect& aBounds, + const wr::LayoutRect& aClip, wr::ImageRendering aFilter, + const Range<wr::ImageKey>& aImageKeys, + PushDisplayItemFlagSet aFlags) override; + + void ReadUnlock() override; + bool IsDirectMap() override { + return mFirstSource && mFirstSource->IsDirectMap(); + }; + + bool CanUnlock() { return !mFirstSource || mFirstSource->Sync(false); } + void DisableExternalTextures() { mUseExternalTextures = false; } + + protected: + bool UseExternalTextures() const { return mUseExternalTextures; } + bool Upload(nsIntRegion* aRegion = nullptr); + bool UploadIfNeeded(); + bool MaybeUpload(nsIntRegion* aRegion); + bool EnsureWrappingTextureSource(); + + void UpdatedInternal(const nsIntRegion* aRegion = nullptr) override; + void MaybeNotifyUnlocked() override; + + BufferDescriptor mDescriptor; + RefPtr<Compositor> mCompositor; + RefPtr<DataTextureSource> mFirstSource; + nsIntRegion mMaybeUpdatedRegion; + gfx::IntSize mSize; + gfx::SurfaceFormat mFormat; + uint32_t mUpdateSerial; + bool mLocked; + bool mNeedsFullUpdate; + bool mHasIntermediateBuffer; + bool mUseExternalTextures; + + class DataTextureSourceYCbCrBasic; +}; + +/** + * TextureHost that wraps shared memory. + * the corresponding texture on the client side is ShmemTextureClient. + * This TextureHost is backend-independent. + */ +class ShmemTextureHost : public BufferTextureHost { + public: + ShmemTextureHost(const mozilla::ipc::Shmem& aShmem, + const BufferDescriptor& aDesc, + ISurfaceAllocator* aDeallocator, TextureFlags aFlags); + + protected: + ~ShmemTextureHost(); + + public: + void DeallocateSharedData() override; + + void ForgetSharedData() override; + + uint8_t* GetBuffer() override; + + size_t GetBufferSize() override; + + const char* Name() override { return "ShmemTextureHost"; } + + void OnShutdown() override; + + protected: + UniquePtr<mozilla::ipc::Shmem> mShmem; + RefPtr<ISurfaceAllocator> mDeallocator; +}; + +/** + * TextureHost that wraps raw memory. + * The corresponding texture on the client side is MemoryTextureClient. + * Can obviously not be used in a cross process setup. + * This TextureHost is backend-independent. + */ +class MemoryTextureHost : public BufferTextureHost { + public: + MemoryTextureHost(uint8_t* aBuffer, const BufferDescriptor& aDesc, + TextureFlags aFlags); + + protected: + ~MemoryTextureHost(); + + public: + void DeallocateSharedData() override; + + void ForgetSharedData() override; + + uint8_t* GetBuffer() override; + + size_t GetBufferSize() override; + + const char* Name() override { return "MemoryTextureHost"; } + + protected: + uint8_t* mBuffer; +}; + +class MOZ_STACK_CLASS AutoLockTextureHost { + public: + explicit AutoLockTextureHost(TextureHost* aTexture) : mTexture(aTexture) { + mLocked = mTexture ? mTexture->Lock() : false; + } + + ~AutoLockTextureHost() { + if (mTexture && mLocked) { + mTexture->Unlock(); + } + } + + bool Failed() { return mTexture && !mLocked; } + + private: + RefPtr<TextureHost> mTexture; + bool mLocked; +}; + +class MOZ_STACK_CLASS AutoLockTextureHostWithoutCompositor { + public: + explicit AutoLockTextureHostWithoutCompositor(TextureHost* aTexture) + : mTexture(aTexture) { + mLocked = mTexture ? mTexture->LockWithoutCompositor() : false; + } + + ~AutoLockTextureHostWithoutCompositor() { + if (mTexture && mLocked) { + mTexture->UnlockWithoutCompositor(); + } + } + + bool Failed() { return mTexture && !mLocked; } + + private: + RefPtr<TextureHost> mTexture; + bool mLocked; +}; + +/** + * This can be used as an offscreen rendering target by the compositor, and + * subsequently can be used as a source by the compositor. + */ +class CompositingRenderTarget : public TextureSource { + public: + explicit CompositingRenderTarget(const gfx::IntPoint& aOrigin) + : mClearOnBind(false), + mOrigin(aOrigin), + mZNear(0), + mZFar(0), + mHasComplexProjection(false), + mEnableDepthBuffer(false) {} + virtual ~CompositingRenderTarget() = default; + + const char* Name() const override { return "CompositingRenderTarget"; } + +#ifdef MOZ_DUMP_PAINTING + virtual already_AddRefed<gfx::DataSourceSurface> Dump( + Compositor* aCompositor) { + return nullptr; + } +#endif + + /** + * Perform a clear when recycling a non opaque surface. + * The clear is deferred to when the render target is bound. + */ + void ClearOnBind() { mClearOnBind = true; } + + const gfx::IntPoint& GetOrigin() const { return mOrigin; } + gfx::IntRect GetRect() { return gfx::IntRect(GetOrigin(), GetSize()); } + + /** + * If a Projection matrix is set, then it is used for rendering to + * this render target instead of generating one. If no explicit + * projection is set, Compositors are expected to generate an + * orthogonal maaping that maps 0..1 to the full size of the render + * target. + */ + bool HasComplexProjection() const { return mHasComplexProjection; } + void ClearProjection() { mHasComplexProjection = false; } + void SetProjection(const gfx::Matrix4x4& aNewMatrix, bool aEnableDepthBuffer, + float aZNear, float aZFar) { + mProjectionMatrix = aNewMatrix; + mEnableDepthBuffer = aEnableDepthBuffer; + mZNear = aZNear; + mZFar = aZFar; + mHasComplexProjection = true; + } + void GetProjection(gfx::Matrix4x4& aMatrix, bool& aEnableDepth, float& aZNear, + float& aZFar) { + MOZ_ASSERT(mHasComplexProjection); + aMatrix = mProjectionMatrix; + aEnableDepth = mEnableDepthBuffer; + aZNear = mZNear; + aZFar = mZFar; + } + + protected: + bool mClearOnBind; + + private: + gfx::IntPoint mOrigin; + + gfx::Matrix4x4 mProjectionMatrix; + float mZNear, mZFar; + bool mHasComplexProjection; + bool mEnableDepthBuffer; +}; + +/** + * Creates a TextureHost that can be used with any of the existing backends + * Not all SurfaceDescriptor types are supported + */ +already_AddRefed<TextureHost> CreateBackendIndependentTextureHost( + const SurfaceDescriptor& aDesc, ISurfaceAllocator* aDeallocator, + LayersBackend aBackend, TextureFlags aFlags); + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/TiledContentHost.cpp b/gfx/layers/composite/TiledContentHost.cpp new file mode 100644 index 0000000000..02f7c3b846 --- /dev/null +++ b/gfx/layers/composite/TiledContentHost.cpp @@ -0,0 +1,658 @@ +/* -*- 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 "TiledContentHost.h" +#include "PaintedLayerComposite.h" // for PaintedLayerComposite +#include "mozilla/gfx/BaseSize.h" // for BaseSize +#include "mozilla/gfx/Matrix.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for IntSize +#include "mozilla/layers/Compositor.h" // for Compositor +// clang-format off +//#include "mozilla/layers/CompositorBridgeParent.h" // for CompositorBridgeParent +// clang-format on +#include "mozilla/layers/Effects.h" // for TexturedEffect, Effect, etc +#include "mozilla/layers/LayerMetricsWrapper.h" // for LayerMetricsWrapper +#include "mozilla/layers/PTextureParent.h" +#include "mozilla/layers/TextureHostOGL.h" // for TextureHostOGL +#ifdef XP_DARWIN +# include "mozilla/layers/TextureSync.h" // for TextureSync +#endif +#include "nsAString.h" +#include "nsDebug.h" // for NS_WARNING +#include "nsPoint.h" // for IntPoint +#include "nsPrintfCString.h" // for nsPrintfCString +#include "nsRect.h" // for IntRect +#include "mozilla/StaticPrefs_layers.h" +#include "mozilla/layers/TextureClient.h" + +namespace mozilla { +using namespace gfx; +namespace layers { + +class Layer; + +float TileHost::GetFadeInOpacity(float aOpacity) { + TimeStamp now = TimeStamp::Now(); + if (!StaticPrefs::layers_tiles_fade_in_enabled() || mFadeStart.IsNull() || + now < mFadeStart) { + return aOpacity; + } + + float duration = StaticPrefs::layers_tiles_fade_in_duration_ms(); + float elapsed = (now - mFadeStart).ToMilliseconds(); + if (elapsed > duration) { + mFadeStart = TimeStamp(); + return aOpacity; + } + return aOpacity * (elapsed / duration); +} + +RefPtr<TextureSource> TileHost::AcquireTextureSource() const { + if (!mTextureHost || !mTextureHost->AcquireTextureSource(mTextureSource)) { + return nullptr; + } + return mTextureSource.get(); +} + +RefPtr<TextureSource> TileHost::AcquireTextureSourceOnWhite() const { + if (!mTextureHostOnWhite || + !mTextureHostOnWhite->AcquireTextureSource(mTextureSourceOnWhite)) { + return nullptr; + } + return mTextureSourceOnWhite.get(); +} + +TiledLayerBufferComposite::TiledLayerBufferComposite() : mFrameResolution() {} + +TiledLayerBufferComposite::~TiledLayerBufferComposite() { Clear(); } + +void TiledLayerBufferComposite::SetTextureSourceProvider( + TextureSourceProvider* aProvider) { + MOZ_ASSERT(aProvider); + for (TileHost& tile : mRetainedTiles) { + if (tile.IsPlaceholderTile()) continue; + tile.mTextureHost->SetTextureSourceProvider(aProvider); + if (tile.mTextureHostOnWhite) { + tile.mTextureHostOnWhite->SetTextureSourceProvider(aProvider); + } + } +} + +void TiledLayerBufferComposite::AddAnimationInvalidation(nsIntRegion& aRegion) { + // We need to invalidate rects where we have a tile that is in the + // process of fading in. + for (size_t i = 0; i < mRetainedTiles.Length(); i++) { + if (!mRetainedTiles[i].mFadeStart.IsNull()) { + TileCoordIntPoint coord = mTiles.TileCoord(i); + IntPoint offset = GetTileOffset(coord); + nsIntRegion tileRegion = IntRect(offset, GetScaledTileSize()); + aRegion.OrWith(tileRegion); + } + } +} + +TiledContentHost::TiledContentHost(const TextureInfo& aTextureInfo) + : ContentHost(aTextureInfo), + mTiledBuffer(TiledLayerBufferComposite()), + mLowPrecisionTiledBuffer(TiledLayerBufferComposite()) { + MOZ_COUNT_CTOR(TiledContentHost); +} + +TiledContentHost::~TiledContentHost() { MOZ_COUNT_DTOR(TiledContentHost); } + +already_AddRefed<TexturedEffect> TiledContentHost::GenEffect( + const gfx::SamplingFilter aSamplingFilter) { + MOZ_ASSERT(mTiledBuffer.GetTileCount() == 1 && + mLowPrecisionTiledBuffer.GetTileCount() == 0); + MOZ_ASSERT(mTiledBuffer.GetTile(0).mTextureHost); + + TileHost& tile = mTiledBuffer.GetTile(0); + if (!tile.mTextureHost->BindTextureSource(tile.mTextureSource)) { + return nullptr; + } + + return CreateTexturedEffect(tile.mTextureSource, nullptr, aSamplingFilter, + true); +} + +void TiledContentHost::Attach(Layer* aLayer, TextureSourceProvider* aProvider, + AttachFlags aFlags /* = NO_FLAGS */) { + CompositableHost::Attach(aLayer, aProvider, aFlags); +} + +void TiledContentHost::Detach(Layer* aLayer, + AttachFlags aFlags /* = NO_FLAGS */) { + if (!mKeepAttached || aLayer == mLayer || aFlags & FORCE_DETACH) { + // Clear the TiledLayerBuffers, which will take care of releasing the + // copy-on-write locks. + mTiledBuffer.Clear(); + mLowPrecisionTiledBuffer.Clear(); + } + CompositableHost::Detach(aLayer, aFlags); +} + +bool TiledContentHost::UseTiledLayerBuffer( + ISurfaceAllocator* aAllocator, + const SurfaceDescriptorTiles& aTiledDescriptor) { + HostLayerManager* lm = GetLayerManager(); + if (!lm) { + return false; + } + + if (aTiledDescriptor.resolution() < 1) { + if (!mLowPrecisionTiledBuffer.UseTiles(aTiledDescriptor, lm, aAllocator)) { + return false; + } + } else { + if (!mTiledBuffer.UseTiles(aTiledDescriptor, lm, aAllocator)) { + return false; + } + } + return true; +} + +static void UseTileTexture(CompositableTextureHostRef& aTexture, + CompositableTextureSourceRef& aTextureSource, + const IntRect& aUpdateRect, + TextureSourceProvider* aProvider) { + MOZ_ASSERT(aTexture); + if (!aTexture) { + return; + } + + if (aProvider) { + aTexture->SetTextureSourceProvider(aProvider); + } + + if (!aUpdateRect.IsEmpty()) { + // For !HasIntermediateBuffer() textures, this is likely a no-op. + nsIntRegion region = aUpdateRect; + aTexture->Updated(®ion); + } + + aTexture->PrepareTextureSource(aTextureSource); +} + +class TextureSourceRecycler { + public: + explicit TextureSourceRecycler(nsTArray<TileHost>&& aTileSet) + : mTiles(std::move(aTileSet)), mFirstPossibility(0) {} + + // Attempts to recycle a texture source that is already bound to the + // texture host for aTile. + void RecycleTextureSourceForTile(TileHost& aTile) { + for (size_t i = mFirstPossibility; i < mTiles.Length(); i++) { + // Skip over existing tiles without a retained texture source + // and make sure we don't iterate them in the future. + if (!mTiles[i].mTextureSource) { + if (i == mFirstPossibility) { + mFirstPossibility++; + } + continue; + } + + // If this tile matches, then copy across the retained texture source (if + // any). + if (aTile.mTextureHost == mTiles[i].mTextureHost) { + aTile.mTextureSource = std::move(mTiles[i].mTextureSource); + if (aTile.mTextureHostOnWhite) { + aTile.mTextureSourceOnWhite = + std::move(mTiles[i].mTextureSourceOnWhite); + } + break; + } + } + } + + // Attempts to recycle any texture source to avoid needing to allocate + // a new one. + void RecycleTextureSource(TileHost& aTile) { + for (size_t i = mFirstPossibility; i < mTiles.Length(); i++) { + if (!mTiles[i].mTextureSource) { + if (i == mFirstPossibility) { + mFirstPossibility++; + } + continue; + } + + if (mTiles[i].mTextureSource && mTiles[i].mTextureHost->GetFormat() == + aTile.mTextureHost->GetFormat()) { + aTile.mTextureSource = std::move(mTiles[i].mTextureSource); + if (aTile.mTextureHostOnWhite) { + aTile.mTextureSourceOnWhite = + std::move(mTiles[i].mTextureSourceOnWhite); + } + break; + } + } + } + + void RecycleTileFading(TileHost& aTile) { + for (size_t i = 0; i < mTiles.Length(); i++) { + if (mTiles[i].mTextureHost == aTile.mTextureHost) { + aTile.mFadeStart = mTiles[i].mFadeStart; + } + } + } + + protected: + nsTArray<TileHost> mTiles; + size_t mFirstPossibility; +}; + +bool TiledLayerBufferComposite::UseTiles(const SurfaceDescriptorTiles& aTiles, + HostLayerManager* aLayerManager, + ISurfaceAllocator* aAllocator) { + if (mResolution != aTiles.resolution() || aTiles.tileSize() != mTileSize) { + Clear(); + } + MOZ_ASSERT(aAllocator); + MOZ_ASSERT(aLayerManager); + if (!aAllocator || !aLayerManager) { + return false; + } + + if (aTiles.resolution() == 0 || IsNaN(aTiles.resolution())) { + // There are divisions by mResolution so this protects the compositor + // process against malicious content processes and fuzzing. + return false; + } + + TilesPlacement newTiles(aTiles.firstTileX(), aTiles.firstTileY(), + aTiles.retainedWidth(), aTiles.retainedHeight()); + + const nsTArray<TileDescriptor>& tileDescriptors = aTiles.tiles(); + + TextureSourceRecycler oldRetainedTiles(std::move(mRetainedTiles)); + mRetainedTiles.SetLength(tileDescriptors.Length()); + + AutoTArray<uint64_t, 10> lockedTextureSerials; + base::ProcessId lockedTexturePid = 0; + + // Step 1, deserialize the incoming set of tiles into mRetainedTiles, and + // attempt to recycle the TextureSource for any repeated tiles. + // + // Since we don't have any retained 'tile' object, we have to search for + // instances of the same TextureHost in the old tile set. The cost of binding + // a TextureHost to a TextureSource for gralloc (binding EGLImage to GL + // texture) can be really high, so we avoid this whenever possible. + for (size_t i = 0; i < tileDescriptors.Length(); i++) { + const TileDescriptor& tileDesc = tileDescriptors[i]; + + TileHost& tile = mRetainedTiles[i]; + + if (tileDesc.type() != TileDescriptor::TTexturedTileDescriptor) { + NS_WARNING_ASSERTION( + tileDesc.type() == TileDescriptor::TPlaceholderTileDescriptor, + "Unrecognised tile descriptor type"); + continue; + } + + const TexturedTileDescriptor& texturedDesc = + tileDesc.get_TexturedTileDescriptor(); + + tile.mTextureHost = + TextureHost::AsTextureHost(texturedDesc.textureParent()); + if (texturedDesc.readLocked()) { + tile.mTextureHost->SetReadLocked(); + auto actor = tile.mTextureHost->GetIPDLActor(); + if (actor && tile.mTextureHost->IsDirectMap()) { + lockedTextureSerials.AppendElement( + TextureHost::GetTextureSerial(actor)); + + if (lockedTexturePid) { + MOZ_ASSERT(lockedTexturePid == actor->OtherPid()); + } + lockedTexturePid = actor->OtherPid(); + } + } + + if (texturedDesc.textureOnWhiteParent().isSome()) { + tile.mTextureHostOnWhite = + TextureHost::AsTextureHost(texturedDesc.textureOnWhiteParent().ref()); + if (texturedDesc.readLockedOnWhite()) { + tile.mTextureHostOnWhite->SetReadLocked(); + auto actor = tile.mTextureHostOnWhite->GetIPDLActor(); + if (actor && tile.mTextureHostOnWhite->IsDirectMap()) { + lockedTextureSerials.AppendElement( + TextureHost::GetTextureSerial(actor)); + } + } + } + + tile.mTileCoord = newTiles.TileCoord(i); + + // If this same tile texture existed in the old tile set then this will move + // the texture source into our new tile. + oldRetainedTiles.RecycleTextureSourceForTile(tile); + + // If this tile is in the process of fading, we need to keep that going + oldRetainedTiles.RecycleTileFading(tile); + + if (aTiles.isProgressive() && texturedDesc.wasPlaceholder()) { + // This is a progressive paint, and the tile used to be a placeholder. + // We need to begin fading it in (if enabled via + // layers.tiles.fade-in.enabled) + tile.mFadeStart = TimeStamp::Now(); + + aLayerManager->CompositeUntil( + tile.mFadeStart + + TimeDuration::FromMilliseconds( + StaticPrefs::layers_tiles_fade_in_duration_ms())); + } + } + +#ifdef XP_DARWIN + if (lockedTextureSerials.Length() > 0) { + TextureSync::SetTexturesLocked(lockedTexturePid, lockedTextureSerials); + } +#endif + + // Step 2, attempt to recycle unused texture sources from the old tile set + // into new tiles. + // + // For gralloc, binding a new TextureHost to the existing TextureSource is the + // fastest way to ensure that any implicit locking on the old gralloc image is + // released. + for (TileHost& tile : mRetainedTiles) { + if (!tile.mTextureHost || tile.mTextureSource) { + continue; + } + oldRetainedTiles.RecycleTextureSource(tile); + } + + // Step 3, handle the texture uploads, texture source binding and release the + // copy-on-write locks for textures with an internal buffer. + for (size_t i = 0; i < mRetainedTiles.Length(); i++) { + TileHost& tile = mRetainedTiles[i]; + if (!tile.mTextureHost) { + continue; + } + + const TileDescriptor& tileDesc = tileDescriptors[i]; + const TexturedTileDescriptor& texturedDesc = + tileDesc.get_TexturedTileDescriptor(); + + UseTileTexture(tile.mTextureHost, tile.mTextureSource, + texturedDesc.updateRect(), + aLayerManager->GetTextureSourceProvider()); + + if (tile.mTextureHostOnWhite) { + UseTileTexture(tile.mTextureHostOnWhite, tile.mTextureSourceOnWhite, + texturedDesc.updateRect(), + aLayerManager->GetTextureSourceProvider()); + } + } + + mTiles = newTiles; + mTileSize = aTiles.tileSize(); + mTileOrigin = aTiles.tileOrigin(); + mValidRegion = aTiles.validRegion(); + mResolution = aTiles.resolution(); + mFrameResolution = CSSToParentLayerScale2D(aTiles.frameXResolution(), + aTiles.frameYResolution()); + + return true; +} + +void TiledLayerBufferComposite::Clear() { + mRetainedTiles.Clear(); + mTiles.mFirst = TileCoordIntPoint(); + mTiles.mSize = TileCoordIntSize(); + mValidRegion = nsIntRegion(); + mResolution = 1.0; +} + +void TiledContentHost::Composite( + Compositor* aCompositor, LayerComposite* aLayer, EffectChain& aEffectChain, + float aOpacity, const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, const gfx::IntRect& aClipRect, + const nsIntRegion* aVisibleRegion /* = nullptr */, + const Maybe<gfx::Polygon>& aGeometry) { + // Reduce the opacity of the low-precision buffer to make it a + // little more subtle and less jarring. In particular, text + // rendered at low-resolution and scaled tends to look pretty + // heavy and this helps mitigate that. When we reduce the opacity + // we also make sure to draw the background color behind the + // reduced-opacity tile so that content underneath doesn't show + // through. + // However, in cases where the background is transparent, or the layer + // already has some opacity, we want to skip this behaviour. Otherwise + // we end up changing the expected overall transparency of the content, + // and it just looks wrong. + DeviceColor backgroundColor; + if (aOpacity == 1.0f && StaticPrefs::layers_low_precision_opacity() < 1.0f) { + // Background colors are only stored on scrollable layers. Grab + // the one from the nearest scrollable ancestor layer. + for (LayerMetricsWrapper ancestor(GetLayer(), + LayerMetricsWrapper::StartAt::BOTTOM); + ancestor; ancestor = ancestor.GetParent()) { + if (ancestor.Metrics().IsScrollable()) { + backgroundColor = ancestor.Metadata().GetBackgroundColor(); + break; + } + } + } + float lowPrecisionOpacityReduction = + (aOpacity == 1.0f && backgroundColor.a == 1.0f) + ? StaticPrefs::layers_low_precision_opacity() + : 1.0f; + + nsIntRegion tmpRegion; + const nsIntRegion* renderRegion = aVisibleRegion; +#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE + if (PaintWillResample()) { + // If we're resampling, then the texture image will contain exactly the + // entire visible region's bounds, and we should draw it all in one quad + // to avoid unexpected aliasing. + tmpRegion = aVisibleRegion->GetBounds(); + renderRegion = &tmpRegion; + } +#endif + + // Render the low and high precision buffers. + RenderLayerBuffer( + mLowPrecisionTiledBuffer, aCompositor, + lowPrecisionOpacityReduction < 1.0f ? &backgroundColor : nullptr, + aEffectChain, lowPrecisionOpacityReduction * aOpacity, aSamplingFilter, + aClipRect, *renderRegion, aTransform, aGeometry); + + RenderLayerBuffer(mTiledBuffer, aCompositor, nullptr, aEffectChain, aOpacity, + aSamplingFilter, aClipRect, *renderRegion, aTransform, + aGeometry); +} + +void TiledContentHost::RenderTile( + TileHost& aTile, Compositor* aCompositor, EffectChain& aEffectChain, + float aOpacity, const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, const gfx::IntRect& aClipRect, + const nsIntRegion& aScreenRegion, const IntPoint& aTextureOffset, + const IntSize& aTextureBounds, const gfx::Rect& aVisibleRect, + const Maybe<gfx::Polygon>& aGeometry) { + MOZ_ASSERT(!aTile.IsPlaceholderTile()); + + AutoLockTextureHost autoLock(aTile.mTextureHost); + AutoLockTextureHost autoLockOnWhite(aTile.mTextureHostOnWhite); + if (autoLock.Failed() || autoLockOnWhite.Failed()) { + NS_WARNING("Failed to lock tile"); + return; + } + + if (!aTile.mTextureHost->BindTextureSource(aTile.mTextureSource)) { + return; + } + + if (aTile.mTextureHostOnWhite && + !aTile.mTextureHostOnWhite->BindTextureSource( + aTile.mTextureSourceOnWhite)) { + return; + } + + RefPtr<TexturedEffect> effect = CreateTexturedEffect( + aTile.mTextureSource, aTile.mTextureSourceOnWhite, aSamplingFilter, true); + if (!effect) { + return; + } + + float opacity = aTile.GetFadeInOpacity(aOpacity); + aEffectChain.mPrimaryEffect = effect; + + for (auto iter = aScreenRegion.RectIter(); !iter.Done(); iter.Next()) { + const IntRect& rect = iter.Get(); + Rect graphicsRect(rect.X(), rect.Y(), rect.Width(), rect.Height()); + Rect textureRect(rect.X() - aTextureOffset.x, rect.Y() - aTextureOffset.y, + rect.Width(), rect.Height()); + + effect->mTextureCoords.SetRect( + textureRect.X() / aTextureBounds.width, + textureRect.Y() / aTextureBounds.height, + textureRect.Width() / aTextureBounds.width, + textureRect.Height() / aTextureBounds.height); + + aCompositor->DrawGeometry(graphicsRect, aClipRect, aEffectChain, opacity, + aTransform, aVisibleRect, aGeometry); + } + + DiagnosticFlags flags = DiagnosticFlags::CONTENT | DiagnosticFlags::TILE; + if (aTile.mTextureHostOnWhite) { + flags |= DiagnosticFlags::COMPONENT_ALPHA; + } + aCompositor->DrawDiagnostics(flags, aScreenRegion, aClipRect, aTransform, + mFlashCounter); +} + +void TiledContentHost::RenderLayerBuffer( + TiledLayerBufferComposite& aLayerBuffer, Compositor* aCompositor, + const DeviceColor* aBackgroundColor, EffectChain& aEffectChain, + float aOpacity, const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, nsIntRegion aVisibleRegion, + gfx::Matrix4x4 aTransform, const Maybe<Polygon>& aGeometry) { + float resolution = aLayerBuffer.GetResolution(); + gfx::Size layerScale(1, 1); + + // We assume that the current frame resolution is the one used in our high + // precision layer buffer. Compensate for a changing frame resolution when + // rendering the low precision buffer. + if (aLayerBuffer.GetFrameResolution() != mTiledBuffer.GetFrameResolution()) { + const CSSToParentLayerScale2D& layerResolution = + aLayerBuffer.GetFrameResolution(); + const CSSToParentLayerScale2D& localResolution = + mTiledBuffer.GetFrameResolution(); + layerScale.width = layerResolution.xScale / localResolution.xScale; + layerScale.height = layerResolution.yScale / localResolution.yScale; + aVisibleRegion.ScaleRoundOut(layerScale.width, layerScale.height); + } + + // Make sure we don't render at low resolution where we have valid high + // resolution content, to avoid overdraw and artifacts with semi-transparent + // layers. + nsIntRegion maskRegion; + if (resolution != mTiledBuffer.GetResolution()) { + maskRegion = mTiledBuffer.GetValidRegion(); + // XXX This should be ScaleRoundIn, but there is no such function on + // nsIntRegion. + maskRegion.ScaleRoundOut(layerScale.width, layerScale.height); + } + + // Make sure the resolution and difference in frame resolution are accounted + // for in the layer transform. + aTransform.PreScale(1 / (resolution * layerScale.width), + 1 / (resolution * layerScale.height), 1); + + DiagnosticFlags componentAlphaDiagnostic = DiagnosticFlags::NO_DIAGNOSTIC; + + nsIntRegion compositeRegion = aLayerBuffer.GetValidRegion(); + compositeRegion.AndWith(aVisibleRegion); + compositeRegion.SubOut(maskRegion); + + IntRect visibleRect = aVisibleRegion.GetBounds(); + + if (compositeRegion.IsEmpty()) { + return; + } + + if (aBackgroundColor) { + nsIntRegion backgroundRegion = compositeRegion; + backgroundRegion.ScaleRoundOut(resolution, resolution); + EffectChain effect; + effect.mPrimaryEffect = new EffectSolidColor(*aBackgroundColor); + for (auto iter = backgroundRegion.RectIter(); !iter.Done(); iter.Next()) { + const IntRect& rect = iter.Get(); + Rect graphicsRect(rect.X(), rect.Y(), rect.Width(), rect.Height()); + aCompositor->DrawGeometry(graphicsRect, aClipRect, effect, 1.0, + aTransform, aGeometry); + } + } + + for (size_t i = 0; i < aLayerBuffer.GetTileCount(); ++i) { + TileHost& tile = aLayerBuffer.GetTile(i); + if (tile.IsPlaceholderTile()) { + continue; + } + + TileCoordIntPoint tileCoord = aLayerBuffer.GetPlacement().TileCoord(i); + // A sanity check that catches a lot of mistakes. + MOZ_ASSERT(tileCoord.x == tile.mTileCoord.x && + tileCoord.y == tile.mTileCoord.y); + + IntPoint tileOffset = aLayerBuffer.GetTileOffset(tileCoord); + nsIntRegion tileDrawRegion = + IntRect(tileOffset, aLayerBuffer.GetScaledTileSize()); + tileDrawRegion.AndWith(compositeRegion); + + if (tileDrawRegion.IsEmpty()) { + continue; + } + + tileDrawRegion.ScaleRoundOut(resolution, resolution); + RenderTile(tile, aCompositor, aEffectChain, aOpacity, aTransform, + aSamplingFilter, aClipRect, tileDrawRegion, + tileOffset * resolution, aLayerBuffer.GetTileSize(), + gfx::Rect(visibleRect.X(), visibleRect.Y(), visibleRect.Width(), + visibleRect.Height()), + aGeometry); + + if (tile.mTextureHostOnWhite) { + componentAlphaDiagnostic = DiagnosticFlags::COMPONENT_ALPHA; + } + } + + gfx::Rect rect(visibleRect.X(), visibleRect.Y(), visibleRect.Width(), + visibleRect.Height()); + aCompositor->DrawDiagnostics( + DiagnosticFlags::CONTENT | componentAlphaDiagnostic, rect, aClipRect, + aTransform, mFlashCounter); +} + +void TiledContentHost::PrintInfo(std::stringstream& aStream, + const char* aPrefix) { + aStream << aPrefix; + aStream << nsPrintfCString("TiledContentHost (0x%p)", this).get(); + +#if defined(MOZ_DUMP_PAINTING) + if (StaticPrefs::layers_dump_texture()) { + nsAutoCString pfx(aPrefix); + pfx += " "; + + Dump(aStream, pfx.get(), false); + } +#endif +} + +void TiledContentHost::Dump(std::stringstream& aStream, const char* aPrefix, + bool aDumpHtml) { + mTiledBuffer.Dump( + aStream, aPrefix, aDumpHtml, + TextureDumpMode:: + DoNotCompress /* compression not supported on host side */); +} + +void TiledContentHost::AddAnimationInvalidation(nsIntRegion& aRegion) { + return mTiledBuffer.AddAnimationInvalidation(aRegion); +} + +} // namespace layers +} // namespace mozilla diff --git a/gfx/layers/composite/TiledContentHost.h b/gfx/layers/composite/TiledContentHost.h new file mode 100644 index 0000000000..fa754bff30 --- /dev/null +++ b/gfx/layers/composite/TiledContentHost.h @@ -0,0 +1,263 @@ +/* -*- 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_TILEDCONTENTHOST_H +#define GFX_TILEDCONTENTHOST_H + +#include <stdint.h> // for uint16_t +#include <stdio.h> // for FILE +#include <algorithm> // for swap +#include "ContentHost.h" // for ContentHost +#include "TiledLayerBuffer.h" // for TiledLayerBuffer, etc +#include "CompositableHost.h" +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/Attributes.h" // for override +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4 +#include "mozilla/gfx/Point.h" // for Point +#include "mozilla/gfx/Rect.h" // for Rect +#include "mozilla/gfx/Types.h" // for SamplingFilter +#include "mozilla/layers/CompositorTypes.h" // for TextureInfo, etc +#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor +#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc +#include "mozilla/layers/TextureHost.h" // for TextureHost +#include "mozilla/layers/TextureClient.h" +#include "mozilla/mozalloc.h" // for operator delete +#include "nsRegion.h" // for nsIntRegion +#include "nscore.h" // for nsACString + +namespace mozilla { + +namespace layers { + +class Compositor; +class ISurfaceAllocator; +class Layer; +class ThebesBufferData; +class TextureReadLock; +struct EffectChain; + +class TileHost { + public: + // Constructs a placeholder TileHost. See the comments above + // TiledLayerBuffer for more information on what this is used for; + // essentially, this is a sentinel used to represent an invalid or blank + // tile. + TileHost() = default; + + // Constructs a TileHost from a TextureReadLock and TextureHost. + TileHost(TextureReadLock* aSharedLock, TextureHost* aTextureHost, + TextureHost* aTextureHostOnWhite, TextureSource* aSource, + TextureSource* aSourceOnWhite) + : mTextureHost(aTextureHost), + mTextureHostOnWhite(aTextureHostOnWhite), + mTextureSource(aSource), + mTextureSourceOnWhite(aSourceOnWhite) {} + + TileHost(const TileHost& o) { + mTextureHost = o.mTextureHost; + mTextureHostOnWhite = o.mTextureHostOnWhite; + mTextureSource = o.mTextureSource; + mTextureSourceOnWhite = o.mTextureSourceOnWhite; + mTileCoord = o.mTileCoord; + } + TileHost& operator=(const TileHost& o) { + if (this == &o) { + return *this; + } + mTextureHost = o.mTextureHost; + mTextureHostOnWhite = o.mTextureHostOnWhite; + mTextureSource = o.mTextureSource; + mTextureSourceOnWhite = o.mTextureSourceOnWhite; + mTileCoord = o.mTileCoord; + return *this; + } + + bool operator==(const TileHost& o) const { + return mTextureHost == o.mTextureHost; + } + bool operator!=(const TileHost& o) const { + return mTextureHost != o.mTextureHost; + } + + bool IsPlaceholderTile() const { return mTextureHost == nullptr; } + + void Dump(std::stringstream& aStream) { + aStream << "TileHost(...)"; // fill in as needed + } + + void DumpTexture(std::stringstream& aStream, + TextureDumpMode /* aCompress, ignored for host tiles */) { + // TODO We should combine the OnWhite/OnBlack here an just output a single + // image. + CompositableHost::DumpTextureHost(aStream, mTextureHost); + } + + RefPtr<TextureSource> AcquireTextureSource() const; + RefPtr<TextureSource> AcquireTextureSourceOnWhite() const; + + /** + * This does a linear tween of the passed opacity (which is assumed + * to be between 0.0 and 1.0). The duration of the fade is controlled + * by the 'layers.tiles.fade-in.duration-ms' preference. It is enabled + * via 'layers.tiles.fade-in.enabled' + */ + float GetFadeInOpacity(float aOpacity); + + CompositableTextureHostRef mTextureHost; + CompositableTextureHostRef mTextureHostOnWhite; + mutable CompositableTextureSourceRef mTextureSource; + mutable CompositableTextureSourceRef mTextureSourceOnWhite; + // This is not strictly necessary but makes debugging whole lot easier. + TileCoordIntPoint mTileCoord; + TimeStamp mFadeStart; +}; + +class TiledLayerBufferComposite + : public TiledLayerBuffer<TiledLayerBufferComposite, TileHost> { + friend class TiledLayerBuffer<TiledLayerBufferComposite, TileHost>; + + public: + TiledLayerBufferComposite(); + ~TiledLayerBufferComposite(); + + bool UseTiles(const SurfaceDescriptorTiles& aTileDescriptors, + HostLayerManager* aLayerManager, ISurfaceAllocator* aAllocator); + + void Clear(); + + TileHost GetPlaceholderTile() const { return TileHost(); } + + // Stores the absolute resolution of the containing frame, calculated + // by the sum of the resolutions of all parent layers' FrameMetrics. + const CSSToParentLayerScale2D& GetFrameResolution() { + return mFrameResolution; + } + + void SetTextureSourceProvider(TextureSourceProvider* aProvider); + + void AddAnimationInvalidation(nsIntRegion& aRegion); + + protected: + CSSToParentLayerScale2D mFrameResolution; +}; + +/** + * ContentHost for tiled PaintedLayers. Since tiled layers are special snow + * flakes, we have a unique update process. All the textures that back the + * tiles are added in the usual way, but Updated is called on the host side + * in response to a message that describes the transaction for every tile. + * Composition happens in the normal way. + * + * TiledContentHost has a TiledLayerBufferComposite which keeps hold of the + * tiles. Each tile has a reference to a texture host. During the layers + * transaction, we receive a list of descriptors for the client-side tile buffer + * tiles (UseTiledLayerBuffer). If we receive two transactions before a + * composition, we immediately unlock and discard the unused buffer. + * + * When the content host is composited, we first validate the TiledLayerBuffer + * (Upload), which calls Updated on each tile's texture host to make sure the + * texture data has been uploaded. For single-buffered tiles, we unlock at this + * point, for double-buffered tiles we unlock and discard the last composited + * buffer after compositing a new one. Rendering takes us to RenderTile which + * is similar to Composite for non-tiled ContentHosts. + */ +class TiledContentHost : public ContentHost { + public: + explicit TiledContentHost(const TextureInfo& aTextureInfo); + + protected: + virtual ~TiledContentHost(); + + public: + // Generate effect for layerscope when using hwc. + virtual already_AddRefed<TexturedEffect> GenEffect( + const gfx::SamplingFilter aSamplingFilter) override; + + virtual bool UpdateThebes(const ThebesBufferData& aData, + const nsIntRegion& aUpdated, + const nsIntRegion& aOldValidRegionBack) override { + NS_ERROR("N/A for tiled layers"); + return false; + } + + const nsIntRegion& GetValidLowPrecisionRegion() const { + return mLowPrecisionTiledBuffer.GetValidRegion(); + } + + const nsIntRegion& GetValidRegion() const { + return mTiledBuffer.GetValidRegion(); + } + + void SetTextureSourceProvider(TextureSourceProvider* aProvider) override { + CompositableHost::SetTextureSourceProvider(aProvider); + mTiledBuffer.SetTextureSourceProvider(aProvider); + mLowPrecisionTiledBuffer.SetTextureSourceProvider(aProvider); + } + + bool UseTiledLayerBuffer(ISurfaceAllocator* aAllocator, + const SurfaceDescriptorTiles& aTiledDescriptor); + + void Composite(Compositor* aCompositor, LayerComposite* aLayer, + EffectChain& aEffectChain, float aOpacity, + const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, + const nsIntRegion* aVisibleRegion = nullptr, + const Maybe<gfx::Polygon>& aGeometry = Nothing()) override; + + CompositableType GetType() override { + return CompositableType::CONTENT_TILED; + } + + TiledContentHost* AsTiledContentHost() override { return this; } + + void Attach(Layer* aLayer, TextureSourceProvider* aProvider, + AttachFlags aFlags = NO_FLAGS) override; + + void Detach(Layer* aLayer = nullptr, AttachFlags aFlags = NO_FLAGS) override; + + void Dump(std::stringstream& aStream, const char* aPrefix = "", + bool aDumpHtml = false) override; + + void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; + + void AddAnimationInvalidation(nsIntRegion& aRegion) override; + + TiledLayerBufferComposite& GetLowResBuffer() { + return mLowPrecisionTiledBuffer; + } + TiledLayerBufferComposite& GetHighResBuffer() { return mTiledBuffer; } + + private: + void RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer, + Compositor* aCompositor, + const gfx::DeviceColor* aBackgroundColor, + EffectChain& aEffectChain, float aOpacity, + const gfx::SamplingFilter aSamplingFilter, + const gfx::IntRect& aClipRect, nsIntRegion aMaskRegion, + gfx::Matrix4x4 aTransform, + const Maybe<gfx::Polygon>& aGeometry); + + // Renders a single given tile. + void RenderTile( + TileHost& aTile, Compositor* aCompositor, EffectChain& aEffectChain, + float aOpacity, const gfx::Matrix4x4& aTransform, + const gfx::SamplingFilter aSamplingFilter, const gfx::IntRect& aClipRect, + const nsIntRegion& aScreenRegion, const gfx::IntPoint& aTextureOffset, + const gfx::IntSize& aTextureBounds, const gfx::Rect& aVisibleRect, + const Maybe<gfx::Polygon>& aGeometry); + + void EnsureTileStore() {} + + TiledLayerBufferComposite mTiledBuffer; + TiledLayerBufferComposite mLowPrecisionTiledBuffer; +}; + +} // namespace layers +} // namespace mozilla + +#endif diff --git a/gfx/layers/composite/X11TextureHost.cpp b/gfx/layers/composite/X11TextureHost.cpp new file mode 100644 index 0000000000..5bbb7a82c8 --- /dev/null +++ b/gfx/layers/composite/X11TextureHost.cpp @@ -0,0 +1,103 @@ +/* -*- 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 "X11TextureHost.h" + +#include "mozilla/layers/BasicCompositor.h" +#include "mozilla/layers/CompositorOGL.h" +#include "mozilla/layers/X11TextureSourceBasic.h" +#include "mozilla/layers/X11TextureSourceOGL.h" +#include "gfx2DGlue.h" +#include "gfxPlatform.h" +#include "gfxXlibSurface.h" + +namespace mozilla::layers { + +using namespace mozilla::gfx; + +X11TextureHost::X11TextureHost(TextureFlags aFlags, + const SurfaceDescriptorX11& aDescriptor) + : TextureHost(aFlags) { + mSurface = aDescriptor.OpenForeign(); + + if (mSurface && !(aFlags & TextureFlags::DEALLOCATE_CLIENT)) { + mSurface->TakePixmap(); + } +} + +bool X11TextureHost::Lock() { + if (!mCompositor || !mSurface) { + return false; + } + + if (!mTextureSource) { + switch (mCompositor->GetBackendType()) { + case LayersBackend::LAYERS_BASIC: + mTextureSource = new X11TextureSourceBasic( + mCompositor->AsBasicCompositor(), mSurface); + break; + case LayersBackend::LAYERS_OPENGL: + mTextureSource = + new X11TextureSourceOGL(mCompositor->AsCompositorOGL(), mSurface); + break; + default: + return false; + } + } + + return true; +} + +void X11TextureHost::SetTextureSourceProvider( + TextureSourceProvider* aProvider) { + mProvider = aProvider; + if (mProvider) { + mCompositor = mProvider->AsCompositor(); + } else { + mCompositor = nullptr; + } + if (mTextureSource) { + mTextureSource->SetTextureSourceProvider(aProvider); + } +} + +SurfaceFormat X11TextureHost::GetFormat() const { + if (!mSurface) { + return SurfaceFormat::UNKNOWN; + } + gfxContentType type = mSurface->GetContentType(); + if (mCompositor->GetBackendType() == LayersBackend::LAYERS_OPENGL) { + return X11TextureSourceOGL::ContentTypeToSurfaceFormat(type); + } + return X11TextureSourceBasic::ContentTypeToSurfaceFormat(type); +} + +IntSize X11TextureHost::GetSize() const { + if (!mSurface) { + return IntSize(); + } + return mSurface->GetSize(); +} + +already_AddRefed<gfx::DataSourceSurface> X11TextureHost::GetAsSurface() { + if (!mTextureSource || !mTextureSource->AsSourceBasic()) { + return nullptr; + } + RefPtr<DrawTarget> tempDT = + gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(GetSize(), + GetFormat()); + if (!tempDT) { + return nullptr; + } + RefPtr<SourceSurface> surf = + mTextureSource->AsSourceBasic()->GetSurface(tempDT); + if (!surf) { + return nullptr; + } + return surf->GetDataSurface(); +} + +} // namespace mozilla::layers diff --git a/gfx/layers/composite/X11TextureHost.h b/gfx/layers/composite/X11TextureHost.h new file mode 100644 index 0000000000..568e136ff1 --- /dev/null +++ b/gfx/layers/composite/X11TextureHost.h @@ -0,0 +1,65 @@ +/* -*- 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_X11TEXTUREHOST__H +#define MOZILLA_GFX_X11TEXTUREHOST__H + +#include "mozilla/layers/TextureHost.h" +#include "mozilla/layers/LayersSurfaces.h" +#include "mozilla/gfx/Types.h" + +#include "gfxXlibSurface.h" + +namespace mozilla { +namespace layers { + +class X11TextureSource : public TextureSource { + public: + // Called when the underlying X surface has been changed. + // Useful for determining whether to rebind a GLXPixmap to a texture. + virtual void Updated() = 0; + + const char* Name() const override { return "X11TextureSource"; } +}; + +// TextureHost for Xlib-backed TextureSources. +class X11TextureHost : public TextureHost { + public: + X11TextureHost(TextureFlags aFlags, const SurfaceDescriptorX11& aDescriptor); + + void SetTextureSourceProvider(TextureSourceProvider* aProvider) override; + + bool Lock() override; + + gfx::SurfaceFormat GetFormat() const override; + + gfx::IntSize GetSize() const override; + + bool BindTextureSource(CompositableTextureSourceRef& aTexture) override { + aTexture = mTextureSource; + return !!aTexture; + } + + already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override; + +#ifdef MOZ_LAYERS_HAVE_LOG + const char* Name() override { return "X11TextureHost"; } +#endif + + protected: + void UpdatedInternal(const nsIntRegion*) override { + if (mTextureSource) mTextureSource->Updated(); + } + + RefPtr<Compositor> mCompositor; + RefPtr<X11TextureSource> mTextureSource; + RefPtr<gfxXlibSurface> mSurface; +}; + +} // namespace layers +} // namespace mozilla + +#endif // MOZILLA_GFX_X11TEXTUREHOST__H |