Merge "SF: Introduce LayerFE::prepareClientComposition" (d6e530be) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+23 −19

Original line number	Diff line number	Diff line
		@@ -132,13 +132,15 @@ static constexpr mat4 inverseOrientation(uint32_t transform) {
		return inverse(tr);
		}

		bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region& clip,
		bool useIdentityTransform, Region& clearRegion,
		const bool supportProtectedContent,
		renderengine::LayerSettings& layer) {
		std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition(
		compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
		ATRACE_CALL();
		Layer::prepareClientLayer(renderArea, clip, useIdentityTransform, clearRegion,
		supportProtectedContent, layer);

		auto result = Layer::prepareClientComposition(targetSettings);
		if (!result) {
		return result;
		}

		if (CC_UNLIKELY(mActiveBuffer == 0)) {
		// the texture has not been created yet, this Layer has
		// in fact never been drawn into. This happens frequently with
		@@ -159,15 +161,16 @@ bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region&
		under.orSelf(layer->visibleRegion);
		});
		// if not everything below us is covered, we plug the holes!
		Region holes(clip.subtract(under));
		Region holes(targetSettings.clip.subtract(under));
		if (!holes.isEmpty()) {
		clearRegion.orSelf(holes);
		targetSettings.clearRegion.orSelf(holes);
		}
		return false;
		return std::nullopt;
		}
		bool blackOutLayer =
		(isProtected() && !supportProtectedContent) \|\| (isSecure() && !renderArea.isSecure());
		bool blackOutLayer = (isProtected() && !targetSettings.supportProtectedContent) \|\|
		(isSecure() && !targetSettings.isSecure);
		const State& s(getDrawingState());
		auto& layer = *result;
		if (!blackOutLayer) {
		layer.source.buffer.buffer = mActiveBuffer;
		layer.source.buffer.isOpaque = isOpaque(s);
		@@ -176,8 +179,7 @@ bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region&
		layer.source.buffer.usePremultipliedAlpha = getPremultipledAlpha();
		layer.source.buffer.isY410BT2020 = isHdrY410();
		// TODO: we could be more subtle with isFixedSize()
		const bool useFiltering = needsFiltering(renderArea.getDisplayDevice()) \|\|
		renderArea.needsFiltering() \|\| isFixedSize();
		const bool useFiltering = targetSettings.needsFiltering \|\| mNeedsFiltering \|\| isFixedSize();

		// Query the texture matrix given our current filtering mode.
		float textureMatrix[16];
		@@ -244,7 +246,7 @@ bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region&
		layer.alpha = 1.0;
		}

		return true;
		return result;
		}

		bool BufferLayer::isHdrY410() const {
		@@ -572,21 +574,23 @@ bool BufferLayer::getOpacityForFormat(uint32_t format) {
		}

		bool BufferLayer::needsFiltering(const sp<const DisplayDevice>& displayDevice) const {
		// If we are not capturing based on the state of a known display device, we
		// only return mNeedsFiltering
		// If we are not capturing based on the state of a known display device,
		// just return false.
		if (displayDevice == nullptr) {
		return mNeedsFiltering;
		return false;
		}

		const auto outputLayer = findOutputLayerForDisplay(displayDevice);
		if (outputLayer == nullptr) {
		return mNeedsFiltering;
		return false;
		}

		// We need filtering if the sourceCrop rectangle size does not match the
		// displayframe rectangle size (not a 1:1 render)
		const auto& compositionState = outputLayer->getState();
		const auto displayFrame = compositionState.displayFrame;
		const auto sourceCrop = compositionState.sourceCrop;
		return mNeedsFiltering \|\| sourceCrop.getHeight() != displayFrame.getHeight() \|\|
		return sourceCrop.getHeight() != displayFrame.getHeight() \|\|
		sourceCrop.getWidth() != displayFrame.getWidth();
		}

services/surfaceflinger/BufferLayer.h

+8 −9

Original line number	Diff line number	Diff line
		@@ -82,7 +82,6 @@ public:

		bool isHdrY410() const override;

		bool onPreComposition(nsecs_t refreshStartTime) override;
		bool onPostComposition(const std::optional<DisplayId>& displayId,
		const std::shared_ptr<FenceTime>& glDoneFence,
		const std::shared_ptr<FenceTime>& presentFence,
		@@ -146,7 +145,13 @@ private:
		virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;

		protected:
		void latchPerFrameState(compositionengine::LayerFECompositionState& outState) const override;
		/*
		* compositionengine::LayerFE overrides
		*/
		bool onPreComposition(nsecs_t) override;
		void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;
		std::optional<renderengine::LayerSettings> prepareClientComposition(
		compositionengine::LayerFE::ClientCompositionTargetSettings&) override;

		// Loads the corresponding system property once per process
		static bool latchUnsignaledBuffers();
		@@ -163,15 +168,9 @@ protected:

		bool mRefreshPending{false};

		// prepareClientLayer - constructs a RenderEngine layer for GPU composition.
		bool prepareClientLayer(const RenderArea& renderArea, const Region& clip,
		bool useIdentityTransform, Region& clearRegion,
		const bool supportProtectedContent,
		renderengine::LayerSettings& layer) override;

		private:
		// Returns true if this layer requires filtering
		bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const;
		bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const override;

		uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

services/surfaceflinger/ColorLayer.cpp

+8 −10

Original line number	Diff line number	Diff line
		@@ -50,16 +50,14 @@ ColorLayer::ColorLayer(const LayerCreationArgs& args)

		ColorLayer::~ColorLayer() = default;

		bool ColorLayer::prepareClientLayer(const RenderArea& renderArea, const Region& clip,
		bool useIdentityTransform, Region& clearRegion,
		const bool supportProtectedContent,
		renderengine::LayerSettings& layer) {
		Layer::prepareClientLayer(renderArea, clip, useIdentityTransform, clearRegion,
		supportProtectedContent, layer);
		half4 color(getColor());
		half3 solidColor(color.r, color.g, color.b);
		layer.source.solidColor = solidColor;
		return true;
		std::optional<renderengine::LayerSettings> ColorLayer::prepareClientComposition(
		compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
		auto result = Layer::prepareClientComposition(targetSettings);
		if (!result) {
		return result;
		}
		result->source.solidColor = getColor().rgb;
		return result;
		}

		bool ColorLayer::isVisible() const {

services/surfaceflinger/ColorLayer.h

+5 −8

Original line number	Diff line number	Diff line
		@@ -39,16 +39,13 @@ public:

		void commitTransaction(const State& stateToCommit) override;

		bool onPreComposition(nsecs_t /refreshStartTime/) override { return false; }

		protected:
		virtual bool prepareClientLayer(const RenderArea& renderArea, const Region& clip,
		bool useIdentityTransform, Region& clearRegion,
		const bool supportProtectedContent,
		renderengine::LayerSettings& layer);

		private:
		/*
		* compositionengine::LayerFE overrides
		*/
		void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;
		std::optional<renderengine::LayerSettings> prepareClientComposition(
		compositionengine::LayerFE::ClientCompositionTargetSettings&) override;

		std::shared_ptr<compositionengine::Layer> mCompositionLayer;
		};

services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h

+31 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,9 @@

		#pragma once

		#include <optional>

		#include <renderengine/LayerSettings.h>
		#include <utils/RefBase.h>
		#include <utils/Timers.h>

		@@ -40,6 +43,34 @@ public:
		// geometry state can be skipped.
		virtual void latchCompositionState(LayerFECompositionState&, bool includeGeometry) const = 0;

		struct ClientCompositionTargetSettings {
		// The clip region, or visible region that is being rendered to
		const Region& clip;

		// If true, the layer should use an identity transform for its position
		// transform. Used only by the captureScreen API call.
		const bool useIdentityTransform;

		// If set to true, the layer should enable filtering when rendering.
		const bool needsFiltering;

		// If set to true, the buffer is being sent to a destination that is
		// expected to treat the buffer contents as secure.
		const bool isSecure;

		// If set to true, the target buffer has protected content support.
		const bool supportProtectedContent;

		// Modified by each call to prepareClientComposition to indicate the
		// region of the target buffer that should be cleared.
		Region& clearRegion;
		};

		// Returns the LayerSettings to pass to RenderEngine::drawLayers, or
		// nullopt_t if the layer does not render
		virtual std::optional<renderengine::LayerSettings> prepareClientComposition(
		ClientCompositionTargetSettings&) = 0;

		// Called after the layer is displayed to update the presentation fence
		virtual void onLayerDisplayed(const sp<Fence>&) = 0;