Merge "SF: Remove display lookup in Layer classes" into rvc-dev am: 8a908e784f (79ff7553) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/BufferLayer.cpp

+12 −22

Original line number	Original line	Diff line number	Diff line
	@@ -319,7 +319,7 @@ bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) {
	return hasReadyFrame();		return hasReadyFrame();
	}		}

	bool BufferLayer::onPostComposition(sp<const DisplayDevice> displayDevice,		bool BufferLayer::onPostComposition(const DisplayDevice* display,
	const std::shared_ptr<FenceTime>& glDoneFence,		const std::shared_ptr<FenceTime>& glDoneFence,
	const std::shared_ptr<FenceTime>& presentFence,		const std::shared_ptr<FenceTime>& presentFence,
	const CompositorTiming& compositorTiming) {		const CompositorTiming& compositorTiming) {
	@@ -342,7 +342,7 @@ bool BufferLayer::onPostComposition(sp<const DisplayDevice> displayDevice,
	const int32_t layerId = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mTimeStats->setDesiredTime(layerId, mCurrentFrameNumber, desiredPresentTime);		mFlinger->mTimeStats->setDesiredTime(layerId, mCurrentFrameNumber, desiredPresentTime);

	const auto outputLayer = findOutputLayerForDisplay(displayDevice);		const auto outputLayer = findOutputLayerForDisplay(display);
	if (outputLayer && outputLayer->requiresClientComposition()) {		if (outputLayer && outputLayer->requiresClientComposition()) {
	nsecs_t clientCompositionTimestamp = outputLayer->getState().clientCompositionTimestamp;		nsecs_t clientCompositionTimestamp = outputLayer->getState().clientCompositionTimestamp;
	mFlinger->mFrameTracer->traceTimestamp(layerId, getCurrentBufferId(), mCurrentFrameNumber,		mFlinger->mFrameTracer->traceTimestamp(layerId, getCurrentBufferId(), mCurrentFrameNumber,
	@@ -359,13 +359,15 @@ bool BufferLayer::onPostComposition(sp<const DisplayDevice> displayDevice,
	mFrameTracker.setFrameReadyTime(desiredPresentTime);		mFrameTracker.setFrameReadyTime(desiredPresentTime);
	}		}

	const auto displayId = displayDevice->getId();
	if (presentFence->isValid()) {		if (presentFence->isValid()) {
	mFlinger->mTimeStats->setPresentFence(layerId, mCurrentFrameNumber, presentFence);		mFlinger->mTimeStats->setPresentFence(layerId, mCurrentFrameNumber, presentFence);
	mFlinger->mFrameTracer->traceFence(layerId, getCurrentBufferId(), mCurrentFrameNumber,		mFlinger->mFrameTracer->traceFence(layerId, getCurrentBufferId(), mCurrentFrameNumber,
	presentFence, FrameTracer::FrameEvent::PRESENT_FENCE);		presentFence, FrameTracer::FrameEvent::PRESENT_FENCE);
	mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence));		mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence));
	} else if (displayId && mFlinger->getHwComposer().isConnected(*displayId)) {		} else if (!display) {
			// Do nothing.
			} else if (const auto displayId = display->getId();
			displayId && mFlinger->getHwComposer().isConnected(*displayId)) {
	// The HWC doesn't support present fences, so use the refresh		// The HWC doesn't support present fences, so use the refresh
	// timestamp instead.		// timestamp instead.
	const nsecs_t actualPresentTime = mFlinger->getHwComposer().getRefreshTimestamp(*displayId);		const nsecs_t actualPresentTime = mFlinger->getHwComposer().getRefreshTimestamp(*displayId);
	@@ -600,14 +602,8 @@ bool BufferLayer::getOpacityForFormat(uint32_t format) {
	return true;		return true;
	}		}

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

	const auto outputLayer = findOutputLayerForDisplay(displayDevice);
	if (outputLayer == nullptr) {		if (outputLayer == nullptr) {
	return false;		return false;
	}		}
	@@ -621,15 +617,9 @@ bool BufferLayer::needsFiltering(const sp<const DisplayDevice>& displayDevice) c
	sourceCrop.getWidth() != displayFrame.getWidth();		sourceCrop.getWidth() != displayFrame.getWidth();
	}		}

	bool BufferLayer::needsFilteringForScreenshots(const sp<const DisplayDevice>& displayDevice,		bool BufferLayer::needsFilteringForScreenshots(const DisplayDevice* display,
	const ui::Transform& inverseParentTransform) const {		const ui::Transform& inverseParentTransform) const {
	// If we are not capturing based on the state of a known display device,		const auto outputLayer = findOutputLayerForDisplay(display);
	// just return false.
	if (displayDevice == nullptr) {
	return false;
	}

	const auto outputLayer = findOutputLayerForDisplay(displayDevice);
	if (outputLayer == nullptr) {		if (outputLayer == nullptr) {
	return false;		return false;
	}		}
	@@ -637,7 +627,7 @@ bool BufferLayer::needsFilteringForScreenshots(const sp<const DisplayDevice>& di
	// We need filtering if the sourceCrop rectangle size does not match the		// We need filtering if the sourceCrop rectangle size does not match the
	// viewport rectangle size (not a 1:1 render)		// viewport rectangle size (not a 1:1 render)
	const auto& compositionState = outputLayer->getState();		const auto& compositionState = outputLayer->getState();
	const ui::Transform& displayTransform = displayDevice->getTransform();		const ui::Transform& displayTransform = display->getTransform();
	const ui::Transform inverseTransform = inverseParentTransform * displayTransform.inverse();		const ui::Transform inverseTransform = inverseParentTransform * displayTransform.inverse();
	// Undo the transformation of the displayFrame so that we're back into		// Undo the transformation of the displayFrame so that we're back into
	// layer-stack space.		// layer-stack space.
	@@ -843,7 +833,7 @@ void BufferLayer::updateCloneBufferInfo() {
	mDrawingState.inputInfo = tmpInputInfo;		mDrawingState.inputInfo = tmpInputInfo;
	}		}

	void BufferLayer::setTransformHint(ui::Transform::RotationFlags displayTransformHint) const {		void BufferLayer::setTransformHint(ui::Transform::RotationFlags displayTransformHint) {
	mTransformHint = getFixedTransformHint();		mTransformHint = getFixedTransformHint();
	if (mTransformHint == ui::Transform::ROT_INVALID) {		if (mTransformHint == ui::Transform::ROT_INVALID) {
	mTransformHint = displayTransformHint;		mTransformHint = displayTransformHint;

services/surfaceflinger/BufferLayer.h

+7 −10

Original line number	Original line	Diff line number	Diff line
	@@ -79,10 +79,9 @@ public:

	bool isHdrY410() const override;		bool isHdrY410() const override;

	bool onPostComposition(sp<const DisplayDevice> displayDevice,		bool onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& glDoneFence,
	const std::shared_ptr<FenceTime>& glDoneFence,
	const std::shared_ptr<FenceTime>& presentFence,		const std::shared_ptr<FenceTime>& presentFence,
	const CompositorTiming& compositorTiming) override;		const CompositorTiming&) override;

	// latchBuffer - called each time the screen is redrawn and returns whether		// latchBuffer - called each time the screen is redrawn and returns whether
	// the visible regions need to be recomputed (this is a fairly heavy		// the visible regions need to be recomputed (this is a fairly heavy
	@@ -119,10 +118,6 @@ public:

	ui::Transform::RotationFlags getTransformHint() const override { return mTransformHint; }		ui::Transform::RotationFlags getTransformHint() const override { return mTransformHint; }

	void setTransformHint(ui::Transform::RotationFlags displayTransformHint) const override;

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

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	// Functions that must be implemented by derived classes		// Functions that must be implemented by derived classes
	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	@@ -209,14 +204,16 @@ protected:

	virtual uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;		virtual uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

			void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;

	// Transform hint provided to the producer. This must be accessed holding		// Transform hint provided to the producer. This must be accessed holding
	/// the mStateLock.		/// the mStateLock.
	mutable ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0;		ui::Transform::RotationFlags mTransformHint = ui::Transform::ROT_0;

	private:		private:
	// Returns true if this layer requires filtering		// Returns true if this layer requires filtering
	bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const override;		bool needsFiltering(const DisplayDevice*) const override;
	bool needsFilteringForScreenshots(const sp<const DisplayDevice>& displayDevice,		bool needsFilteringForScreenshots(const DisplayDevice*,
	const ui::Transform& inverseParentTransform) const override;		const ui::Transform& inverseParentTransform) const override;

	// BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame		// BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame

services/surfaceflinger/BufferQueueLayer.cpp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -58,7 +58,7 @@ void BufferQueueLayer::onLayerDisplayed(const sp<Fence>& releaseFence) {
	}		}
	}		}

	void BufferQueueLayer::setTransformHint(ui::Transform::RotationFlags displayTransformHint) const {		void BufferQueueLayer::setTransformHint(ui::Transform::RotationFlags displayTransformHint) {
	BufferLayer::setTransformHint(displayTransformHint);		BufferLayer::setTransformHint(displayTransformHint);
	mConsumer->setTransformHint(mTransformHint);		mConsumer->setTransformHint(mTransformHint);
	}		}

services/surfaceflinger/BufferQueueLayer.h

+1 −2

Original line number	Original line	Diff line number	Diff line
	@@ -43,8 +43,6 @@ public:

	void onLayerDisplayed(const sp<Fence>& releaseFence) override;		void onLayerDisplayed(const sp<Fence>& releaseFence) override;

	void setTransformHint(ui::Transform::RotationFlags displayTransformHint) const override;

	std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;		std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;

	// If a buffer was replaced this frame, release the former buffer		// If a buffer was replaced this frame, release the former buffer
	@@ -72,6 +70,7 @@ private:
	bool getSidebandStreamChanged() const override;		bool getSidebandStreamChanged() const override;

	bool latchSidebandStream(bool& recomputeVisibleRegions) override;		bool latchSidebandStream(bool& recomputeVisibleRegions) override;
			void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;

	bool hasFrameUpdate() const override;		bool hasFrameUpdate() const override;

services/surfaceflinger/DisplayDevice.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -93,6 +93,10 @@ public:

	static ui::Transform::RotationFlags getPrimaryDisplayRotationFlags();		static ui::Transform::RotationFlags getPrimaryDisplayRotationFlags();

			ui::Transform::RotationFlags getTransformHint() const {
			return static_cast<ui::Transform::RotationFlags>(getTransform().getOrientation());
			}

	const ui::Transform& getTransform() const;		const ui::Transform& getTransform() const;
	const Rect& getViewport() const;		const Rect& getViewport() const;
	const Rect& getFrame() const;		const Rect& getFrame() const;