Merge "CE: Remove compositionengine::Layer" (da0f906c) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+21 −16

Original line number	Original line	Diff line number	Diff line
	@@ -26,8 +26,6 @@
	#include "BufferLayer.h"		#include "BufferLayer.h"

	#include <compositionengine/CompositionEngine.h>		#include <compositionengine/CompositionEngine.h>
	#include <compositionengine/Layer.h>
	#include <compositionengine/LayerCreationArgs.h>
	#include <compositionengine/LayerFECompositionState.h>		#include <compositionengine/LayerFECompositionState.h>
	#include <compositionengine/OutputLayer.h>		#include <compositionengine/OutputLayer.h>
	#include <compositionengine/impl/OutputLayerCompositionState.h>		#include <compositionengine/impl/OutputLayerCompositionState.h>
	@@ -66,8 +64,7 @@ static constexpr float defaultMaxContentLuminance = 1000.0;
	BufferLayer::BufferLayer(const LayerCreationArgs& args)		BufferLayer::BufferLayer(const LayerCreationArgs& args)
	: Layer(args),		: Layer(args),
	mTextureName(args.textureName),		mTextureName(args.textureName),
	mCompositionLayer{mFlinger->getCompositionEngine().createLayer(		mCompositionState{mFlinger->getCompositionEngine().createLayerFECompositionState()} {
	compositionengine::LayerCreationArgs{this})} {
	ALOGV("Creating Layer %s", getDebugName());		ALOGV("Creating Layer %s", getDebugName());

	mPremultipliedAlpha = !(args.flags & ISurfaceComposerClient::eNonPremultiplied);		mPremultipliedAlpha = !(args.flags & ISurfaceComposerClient::eNonPremultiplied);
	@@ -184,7 +181,7 @@ std::optional<compositionengine::LayerFE::LayerSettings> BufferLayer::prepareCli
	bool blackOutLayer = (isProtected() && !targetSettings.supportsProtectedContent) \|\|		bool blackOutLayer = (isProtected() && !targetSettings.supportsProtectedContent) \|\|
	(isSecure() && !targetSettings.isSecure);		(isSecure() && !targetSettings.isSecure);
	const State& s(getDrawingState());		const State& s(getDrawingState());
	LayerFE::LayerSettings& layer = *result;		compositionengine::LayerFE::LayerSettings& layer = *result;
	if (!blackOutLayer) {		if (!blackOutLayer) {
	layer.source.buffer.buffer = mBufferInfo.mBuffer;		layer.source.buffer.buffer = mBufferInfo.mBuffer;
	layer.source.buffer.isOpaque = isOpaque(s);		layer.source.buffer.isOpaque = isOpaque(s);
	@@ -282,17 +279,29 @@ bool BufferLayer::isHdrY410() const {
	mBufferInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);		mBufferInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);
	}		}

	void BufferLayer::latchPerFrameState(		sp<compositionengine::LayerFE> BufferLayer::getCompositionEngineLayerFE() const {
	compositionengine::LayerFECompositionState& compositionState) const {		return asLayerFE();
	Layer::latchPerFrameState(compositionState);		}

			compositionengine::LayerFECompositionState* BufferLayer::editCompositionState() {
			return mCompositionState.get();
			}

			const compositionengine::LayerFECompositionState* BufferLayer::getCompositionState() const {
			return mCompositionState.get();
			}

			void BufferLayer::preparePerFrameCompositionState() {
			Layer::preparePerFrameCompositionState();

	// Sideband layers		// Sideband layers
	if (compositionState.sidebandStream.get()) {		auto* compositionState = editCompositionState();
	compositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;		if (compositionState->sidebandStream.get()) {
			compositionState->compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;
	} else {		} else {
	// Normal buffer layers		// Normal buffer layers
	compositionState.hdrMetadata = mBufferInfo.mHdrMetadata;		compositionState->hdrMetadata = mBufferInfo.mHdrMetadata;
	compositionState.compositionType = mPotentialCursor		compositionState->compositionType = mPotentialCursor
	? Hwc2::IComposerClient::Composition::CURSOR		? Hwc2::IComposerClient::Composition::CURSOR
	: Hwc2::IComposerClient::Composition::DEVICE;		: Hwc2::IComposerClient::Composition::DEVICE;
	}		}
	@@ -641,10 +650,6 @@ Rect BufferLayer::getBufferSize(const State& s) const {
	return Rect(bufWidth, bufHeight);		return Rect(bufWidth, bufHeight);
	}		}

	std::shared_ptr<compositionengine::Layer> BufferLayer::getCompositionLayer() const {
	return mCompositionLayer;
	}

	FloatRect BufferLayer::computeSourceBounds(const FloatRect& parentBounds) const {		FloatRect BufferLayer::computeSourceBounds(const FloatRect& parentBounds) const {
	const State& s(getDrawingState());		const State& s(getDrawingState());

services/surfaceflinger/BufferLayer.h

+5 −3

Original line number	Original line	Diff line number	Diff line
	@@ -54,7 +54,8 @@ public:
	// Overriden from Layer		// Overriden from Layer
	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	public:		public:
	std::shared_ptr<compositionengine::Layer> getCompositionLayer() const override;		sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const override;
			compositionengine::LayerFECompositionState* editCompositionState() override;

	// If we have received a new buffer this frame, we will pass its surface		// If we have received a new buffer this frame, we will pass its surface
	// damage down to hardware composer. Otherwise, we must send a region with		// damage down to hardware composer. Otherwise, we must send a region with
	@@ -175,8 +176,9 @@ protected:
	/*		/*
	* compositionengine::LayerFE overrides		* compositionengine::LayerFE overrides
	*/		*/
			const compositionengine::LayerFECompositionState* getCompositionState() const override;
	bool onPreComposition(nsecs_t) override;		bool onPreComposition(nsecs_t) override;
	void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;		void preparePerFrameCompositionState() override;
	std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(		std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
	compositionengine::LayerFE::ClientCompositionTargetSettings&) override;		compositionengine::LayerFE::ClientCompositionTargetSettings&) override;

	@@ -210,7 +212,7 @@ private:
	// and its parent layer is not bounded		// and its parent layer is not bounded
	Rect getBufferSize(const State& s) const override;		Rect getBufferSize(const State& s) const override;

	std::shared_ptr<compositionengine::Layer> mCompositionLayer;		std::unique_ptr<compositionengine::LayerFECompositionState> mCompositionState;

	FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;		FloatRect computeSourceBounds(const FloatRect& parentBounds) const override;
	};		};

services/surfaceflinger/BufferQueueLayer.cpp

+13 −13

Original line number	Original line	Diff line number	Diff line
	@@ -23,7 +23,6 @@
	#define ATRACE_TAG ATRACE_TAG_GRAPHICS		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
	#include "BufferQueueLayer.h"		#include "BufferQueueLayer.h"

	#include <compositionengine/Layer.h>
	#include <compositionengine/LayerFECompositionState.h>		#include <compositionengine/LayerFECompositionState.h>
	#include <gui/BufferQueueConsumer.h>		#include <gui/BufferQueueConsumer.h>
	#include <system/window.h>		#include <system/window.h>
	@@ -223,9 +222,9 @@ bool BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
	if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {		if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {
	// mSidebandStreamChanged was changed to false		// mSidebandStreamChanged was changed to false
	mSidebandStream = mConsumer->getSidebandStream();		mSidebandStream = mConsumer->getSidebandStream();
	auto& layerCompositionState = getCompositionLayer()->editFEState();		auto* layerCompositionState = editCompositionState();
	layerCompositionState.sidebandStream = mSidebandStream;		layerCompositionState->sidebandStream = mSidebandStream;
	if (layerCompositionState.sidebandStream != nullptr) {		if (layerCompositionState->sidebandStream != nullptr) {
	setTransactionFlags(eTransactionNeeded);		setTransactionFlags(eTransactionNeeded);
	mFlinger->setTransactionFlags(eTraversalNeeded);		mFlinger->setTransactionFlags(eTraversalNeeded);
	}		}
	@@ -359,8 +358,8 @@ status_t BufferQueueLayer::updateActiveBuffer() {
	mPreviousBufferId = getCurrentBufferId();		mPreviousBufferId = getCurrentBufferId();
	mBufferInfo.mBuffer =		mBufferInfo.mBuffer =
	mConsumer->getCurrentBuffer(&mBufferInfo.mBufferSlot, &mBufferInfo.mFence);		mConsumer->getCurrentBuffer(&mBufferInfo.mBufferSlot, &mBufferInfo.mFence);
	auto& layerCompositionState = getCompositionLayer()->editFEState();		auto* layerCompositionState = editCompositionState();
	layerCompositionState.buffer = mBufferInfo.mBuffer;		layerCompositionState->buffer = mBufferInfo.mBuffer;

	if (mBufferInfo.mBuffer == nullptr) {		if (mBufferInfo.mBuffer == nullptr) {
	// this can only happen if the very first buffer was rejected.		// this can only happen if the very first buffer was rejected.
	@@ -380,18 +379,19 @@ status_t BufferQueueLayer::updateFrameNumber(nsecs_t latchTime) {
	return NO_ERROR;		return NO_ERROR;
	}		}

	void BufferQueueLayer::latchPerFrameState(		void BufferQueueLayer::preparePerFrameCompositionState() {
	compositionengine::LayerFECompositionState& compositionState) const {		BufferLayer::preparePerFrameCompositionState();
	BufferLayer::latchPerFrameState(compositionState);
	if (compositionState.compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {		auto* compositionState = editCompositionState();
			if (compositionState->compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {
	return;		return;
	}		}

	compositionState.buffer = mBufferInfo.mBuffer;		compositionState->buffer = mBufferInfo.mBuffer;
	compositionState.bufferSlot = (mBufferInfo.mBufferSlot == BufferQueue::INVALID_BUFFER_SLOT)		compositionState->bufferSlot = (mBufferInfo.mBufferSlot == BufferQueue::INVALID_BUFFER_SLOT)
	? 0		? 0
	: mBufferInfo.mBufferSlot;		: mBufferInfo.mBufferSlot;
	compositionState.acquireFence = mBufferInfo.mFence;		compositionState->acquireFence = mBufferInfo.mFence;
	}		}

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------

services/surfaceflinger/BufferQueueLayer.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -85,7 +85,7 @@ private:
	status_t updateActiveBuffer() override;		status_t updateActiveBuffer() override;
	status_t updateFrameNumber(nsecs_t latchTime) override;		status_t updateFrameNumber(nsecs_t latchTime) override;

	void latchPerFrameState(compositionengine::LayerFECompositionState&) const override;		void preparePerFrameCompositionState() override;
	sp<Layer> createClone() override;		sp<Layer> createClone() override;

	void onFrameAvailable(const BufferItem& item);		void onFrameAvailable(const BufferItem& item);

services/surfaceflinger/BufferStateLayer.cpp

+10 −12

Original line number	Original line	Diff line number	Diff line
	@@ -27,7 +27,6 @@

	#include <limits>		#include <limits>

	#include <compositionengine/Layer.h>
	#include <compositionengine/LayerFECompositionState.h>		#include <compositionengine/LayerFECompositionState.h>
	#include <gui/BufferQueue.h>		#include <gui/BufferQueue.h>
	#include <private/gui/SyncFeatures.h>		#include <private/gui/SyncFeatures.h>
	@@ -464,9 +463,8 @@ bool BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
	if (mSidebandStreamChanged.exchange(false)) {		if (mSidebandStreamChanged.exchange(false)) {
	const State& s(getDrawingState());		const State& s(getDrawingState());
	// mSidebandStreamChanged was true		// mSidebandStreamChanged was true
	LOG_ALWAYS_FATAL_IF(!getCompositionLayer());
	mSidebandStream = s.sidebandStream;		mSidebandStream = s.sidebandStream;
	getCompositionLayer()->editFEState().sidebandStream = mSidebandStream;		editCompositionState()->sidebandStream = mSidebandStream;
	if (mSidebandStream != nullptr) {		if (mSidebandStream != nullptr) {
	setTransactionFlags(eTransactionNeeded);		setTransactionFlags(eTransactionNeeded);
	mFlinger->setTransactionFlags(eTraversalNeeded);		mFlinger->setTransactionFlags(eTraversalNeeded);
	@@ -573,8 +571,7 @@ status_t BufferStateLayer::updateActiveBuffer() {
	mPreviousBufferId = getCurrentBufferId();		mPreviousBufferId = getCurrentBufferId();
	mBufferInfo.mBuffer = s.buffer;		mBufferInfo.mBuffer = s.buffer;
	mBufferInfo.mFence = s.acquireFence;		mBufferInfo.mFence = s.acquireFence;
	auto& layerCompositionState = getCompositionLayer()->editFEState();		editCompositionState()->buffer = mBufferInfo.mBuffer;
	layerCompositionState.buffer = mBufferInfo.mBuffer;

	return NO_ERROR;		return NO_ERROR;
	}		}
	@@ -590,16 +587,17 @@ status_t BufferStateLayer::updateFrameNumber(nsecs_t latchTime) {
	return NO_ERROR;		return NO_ERROR;
	}		}

	void BufferStateLayer::latchPerFrameState(		void BufferStateLayer::preparePerFrameCompositionState() {
	compositionengine::LayerFECompositionState& compositionState) const {		BufferLayer::preparePerFrameCompositionState();
	BufferLayer::latchPerFrameState(compositionState);
	if (compositionState.compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {		auto* compositionState = editCompositionState();
			if (compositionState->compositionType == Hwc2::IComposerClient::Composition::SIDEBAND) {
	return;		return;
	}		}

	compositionState.buffer = mBufferInfo.mBuffer;		compositionState->buffer = mBufferInfo.mBuffer;
	compositionState.bufferSlot = mBufferInfo.mBufferSlot;		compositionState->bufferSlot = mBufferInfo.mBufferSlot;
	compositionState.acquireFence = mBufferInfo.mFence;		compositionState->acquireFence = mBufferInfo.mFence;
	}		}

	void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {		void BufferStateLayer::HwcSlotGenerator::bufferErased(const client_cache_t& clientCacheId) {