Created bufferInfo to track buffer data in a single place (1/2) (4244e035) · Commits · e / os / android_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+77 −47

Original line number	Original line	Diff line number	Diff line
	@@ -81,7 +81,7 @@ void BufferLayer::useSurfaceDamage() {
	if (mFlinger->mForceFullDamage) {		if (mFlinger->mForceFullDamage) {
	surfaceDamageRegion = Region::INVALID_REGION;		surfaceDamageRegion = Region::INVALID_REGION;
	} else {		} else {
	surfaceDamageRegion = getDrawingSurfaceDamage();		surfaceDamageRegion = mBufferInfo.mSurfaceDamage;
	}		}
	}		}

	@@ -187,7 +187,7 @@ std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition
	// Query the texture matrix given our current filtering mode.		// Query the texture matrix given our current filtering mode.
	float textureMatrix[16];		float textureMatrix[16];
	setFilteringEnabled(useFiltering);		setFilteringEnabled(useFiltering);
	getDrawingTransformMatrix(textureMatrix);		memcpy(textureMatrix, mBufferInfo.mTransformMatrix, sizeof(mBufferInfo.mTransformMatrix));

	if (getTransformToDisplayInverse()) {		if (getTransformToDisplayInverse()) {
	/*		/*
	@@ -254,8 +254,8 @@ std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition

	bool BufferLayer::isHdrY410() const {		bool BufferLayer::isHdrY410() const {
	// pixel format is HDR Y410 masquerading as RGBA_1010102		// pixel format is HDR Y410 masquerading as RGBA_1010102
	return (mCurrentDataSpace == ui::Dataspace::BT2020_ITU_PQ &&		return (mBufferInfo.mDataspace == ui::Dataspace::BT2020_ITU_PQ &&
	getDrawingApi() == NATIVE_WINDOW_API_MEDIA &&		mBufferInfo.mApi == NATIVE_WINDOW_API_MEDIA &&
	mActiveBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);		mActiveBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);
	}		}

	@@ -268,7 +268,7 @@ void BufferLayer::latchPerFrameState(
	compositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;		compositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;
	} else {		} else {
	// Normal buffer layers		// Normal buffer layers
	compositionState.hdrMetadata = getDrawingHdrMetadata();		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;
	@@ -300,13 +300,13 @@ bool BufferLayer::onPostComposition(const std::optional<DisplayId>& displayId,
	}		}

	// Update mFrameTracker.		// Update mFrameTracker.
	nsecs_t desiredPresentTime = getDesiredPresentTime();		nsecs_t desiredPresentTime = mBufferInfo.mDesiredPresentTime;
	mFrameTracker.setDesiredPresentTime(desiredPresentTime);		mFrameTracker.setDesiredPresentTime(desiredPresentTime);

	const int32_t layerID = getSequence();		const int32_t layerID = getSequence();
	mFlinger->mTimeStats->setDesiredTime(layerID, mCurrentFrameNumber, desiredPresentTime);		mFlinger->mTimeStats->setDesiredTime(layerID, mCurrentFrameNumber, desiredPresentTime);

	std::shared_ptr<FenceTime> frameReadyFence = getCurrentFenceTime();		std::shared_ptr<FenceTime> frameReadyFence = mBufferInfo.mFenceTime;
	if (frameReadyFence->isValid()) {		if (frameReadyFence->isValid()) {
	mFrameTracker.setFrameReadyFence(std::move(frameReadyFence));		mFrameTracker.setFrameReadyFence(std::move(frameReadyFence));
	} else {		} else {
	@@ -394,6 +394,9 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
	return false;		return false;
	}		}

			BufferInfo oldBufferInfo = mBufferInfo;
			gatherBufferInfo();

	mRefreshPending = true;		mRefreshPending = true;
	mFrameLatencyNeeded = true;		mFrameLatencyNeeded = true;
	if (oldBuffer == nullptr) {		if (oldBuffer == nullptr) {
	@@ -402,43 +405,10 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
	recomputeVisibleRegions = true;		recomputeVisibleRegions = true;
	}		}

	ui::Dataspace dataSpace = getDrawingDataSpace();		if ((mBufferInfo.mCrop != oldBufferInfo.mCrop) \|\|
	// translate legacy dataspaces to modern dataspaces		(mBufferInfo.mTransform != oldBufferInfo.mTransform) \|\|
	switch (dataSpace) {		(mBufferInfo.mScaleMode != oldBufferInfo.mScaleMode) \|\|
	case ui::Dataspace::SRGB:		(mBufferInfo.mTransformToDisplayInverse != oldBufferInfo.mTransformToDisplayInverse)) {
	dataSpace = ui::Dataspace::V0_SRGB;
	break;
	case ui::Dataspace::SRGB_LINEAR:
	dataSpace = ui::Dataspace::V0_SRGB_LINEAR;
	break;
	case ui::Dataspace::JFIF:
	dataSpace = ui::Dataspace::V0_JFIF;
	break;
	case ui::Dataspace::BT601_625:
	dataSpace = ui::Dataspace::V0_BT601_625;
	break;
	case ui::Dataspace::BT601_525:
	dataSpace = ui::Dataspace::V0_BT601_525;
	break;
	case ui::Dataspace::BT709:
	dataSpace = ui::Dataspace::V0_BT709;
	break;
	default:
	break;
	}
	mCurrentDataSpace = dataSpace;

	Rect crop(getDrawingCrop());
	const uint32_t transform(getDrawingTransform());
	const uint32_t scalingMode(getDrawingScalingMode());
	const bool transformToDisplayInverse(getTransformToDisplayInverse());
	if ((crop != mCurrentCrop) \|\| (transform != mCurrentTransform) \|\|
	(scalingMode != mCurrentScalingMode) \|\|
	(transformToDisplayInverse != mTransformToDisplayInverse)) {
	mCurrentCrop = crop;
	mCurrentTransform = transform;
	mCurrentScalingMode = scalingMode;
	mTransformToDisplayInverse = transformToDisplayInverse;
	recomputeVisibleRegions = true;		recomputeVisibleRegions = true;
	}		}

	@@ -510,7 +480,7 @@ uint32_t BufferLayer::getEffectiveScalingMode() const {
	return mOverrideScalingMode;		return mOverrideScalingMode;
	}		}

	return mCurrentScalingMode;		return mBufferInfo.mScaleMode;
	}		}

	bool BufferLayer::isProtected() const {		bool BufferLayer::isProtected() const {
	@@ -626,7 +596,7 @@ Rect BufferLayer::getBufferSize(const State& s) const {
	uint32_t bufHeight = mActiveBuffer->getHeight();		uint32_t bufHeight = mActiveBuffer->getHeight();

	// Undo any transformations on the buffer and return the result.		// Undo any transformations on the buffer and return the result.
	if (mCurrentTransform & ui::Transform::ROT_90) {		if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
	std::swap(bufWidth, bufHeight);		std::swap(bufWidth, bufHeight);
	}		}

	@@ -662,7 +632,7 @@ FloatRect BufferLayer::computeSourceBounds(const FloatRect& parentBounds) const
	uint32_t bufHeight = mActiveBuffer->getHeight();		uint32_t bufHeight = mActiveBuffer->getHeight();

	// Undo any transformations on the buffer and return the result.		// Undo any transformations on the buffer and return the result.
	if (mCurrentTransform & ui::Transform::ROT_90) {		if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
	std::swap(bufWidth, bufHeight);		std::swap(bufWidth, bufHeight);
	}		}

	@@ -685,6 +655,66 @@ void BufferLayer::latchAndReleaseBuffer() {
	releasePendingBuffer(systemTime());		releasePendingBuffer(systemTime());
	}		}

			PixelFormat BufferLayer::getPixelFormat() const {
			return mBufferInfo.mPixelFormat;
			}

			bool BufferLayer::getTransformToDisplayInverse() const {
			return mBufferInfo.mTransformToDisplayInverse;
			}

			Rect BufferLayer::getBufferCrop() const {
			// this is the crop rectangle that applies to the buffer
			// itself (as opposed to the window)
			if (!mBufferInfo.mCrop.isEmpty()) {
			// if the buffer crop is defined, we use that
			return mBufferInfo.mCrop;
			} else if (mActiveBuffer != nullptr) {
			// otherwise we use the whole buffer
			return mActiveBuffer->getBounds();
			} else {
			// if we don't have a buffer yet, we use an empty/invalid crop
			return Rect();
			}
			}

			uint32_t BufferLayer::getBufferTransform() const {
			return mBufferInfo.mTransform;
			}

			ui::Dataspace BufferLayer::getDataSpace() const {
			return mBufferInfo.mDataspace;
			}

			ui::Dataspace BufferLayer::translateDataspace(ui::Dataspace dataspace) {
			ui::Dataspace updatedDataspace = dataspace;
			// translate legacy dataspaces to modern dataspaces
			switch (dataspace) {
			case ui::Dataspace::SRGB:
			updatedDataspace = ui::Dataspace::V0_SRGB;
			break;
			case ui::Dataspace::SRGB_LINEAR:
			updatedDataspace = ui::Dataspace::V0_SRGB_LINEAR;
			break;
			case ui::Dataspace::JFIF:
			updatedDataspace = ui::Dataspace::V0_JFIF;
			break;
			case ui::Dataspace::BT601_625:
			updatedDataspace = ui::Dataspace::V0_BT601_625;
			break;
			case ui::Dataspace::BT601_525:
			updatedDataspace = ui::Dataspace::V0_BT601_525;
			break;
			case ui::Dataspace::BT709:
			updatedDataspace = ui::Dataspace::V0_BT709;
			break;
			default:
			break;
			}

			return updatedDataspace;
			}

	} // namespace android		} // namespace android

	#if defined(__gl_h_)		#if defined(__gl_h_)

services/surfaceflinger/BufferLayer.h

+30 −16

Original line number	Original line	Diff line number	Diff line
	@@ -106,6 +106,14 @@ public:
	// Should only be called on the main thread.		// Should only be called on the main thread.
	void latchAndReleaseBuffer() override;		void latchAndReleaseBuffer() override;

			bool getTransformToDisplayInverse() const override;

			Rect getBufferCrop() const override;

			uint32_t getBufferTransform() const override;

			ui::Dataspace getDataSpace() const override;

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

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	@@ -115,18 +123,7 @@ private:
	virtual bool fenceHasSignaled() const = 0;		virtual bool fenceHasSignaled() const = 0;
	virtual bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0;		virtual bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0;

	virtual nsecs_t getDesiredPresentTime() = 0;		PixelFormat getPixelFormat() const;
	virtual std::shared_ptr<FenceTime> getCurrentFenceTime() const = 0;

	virtual void getDrawingTransformMatrix(float *matrix) = 0;
	virtual uint32_t getDrawingTransform() const = 0;
	virtual ui::Dataspace getDrawingDataSpace() const = 0;
	virtual Rect getDrawingCrop() const = 0;
	virtual uint32_t getDrawingScalingMode() const = 0;
	virtual Region getDrawingSurfaceDamage() const = 0;
	virtual const HdrMetadata& getDrawingHdrMetadata() const = 0;
	virtual int getDrawingApi() const = 0;
	virtual PixelFormat getPixelFormat() const = 0;

	virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;		virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;

	@@ -148,6 +145,25 @@ private:
	virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;		virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;

	protected:		protected:
			struct BufferInfo {
			nsecs_t mDesiredPresentTime;
			std::shared_ptr<FenceTime> mFenceTime;
			sp<Fence> mFence;
			float mTransformMatrix[16];
			uint32_t mTransform{0};
			ui::Dataspace mDataspace;
			Rect mCrop;
			uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
			Region mSurfaceDamage;
			HdrMetadata mHdrMetadata;
			int mApi;
			PixelFormat mPixelFormat;
			bool mTransformToDisplayInverse{false};
			};

			BufferInfo mBufferInfo;
			virtual void gatherBufferInfo() = 0;

	/*		/*
	* compositionengine::LayerFE overrides		* compositionengine::LayerFE overrides
	*/		*/
	@@ -171,16 +187,14 @@ protected:

	bool mRefreshPending{false};		bool mRefreshPending{false};

			ui::Dataspace translateDataspace(ui::Dataspace dataspace);

	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 sp<const DisplayDevice>& displayDevice) const override;

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

	uint32_t mCurrentScalingMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};

	bool mTransformToDisplayInverse{false};

	// main thread.		// main thread.
	bool mBufferLatched{false}; // TODO: Use mActiveBuffer?		bool mBufferLatched{false}; // TODO: Use mActiveBuffer?

services/surfaceflinger/BufferQueueLayer.cpp

+17 −48

Original line number	Original line	Diff line number	Diff line
	@@ -70,10 +70,6 @@ std::vector<OccupancyTracker::Segment> BufferQueueLayer::getOccupancyHistory(boo
	return history;		return history;
	}		}

	bool BufferQueueLayer::getTransformToDisplayInverse() const {
	return mConsumer->getTransformToDisplayInverse();
	}

	void BufferQueueLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) {		void BufferQueueLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) {
	if (!mConsumer->releasePendingBuffer()) {		if (!mConsumer->releasePendingBuffer()) {
	return;		return;
	@@ -155,55 +151,12 @@ bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co
	return mQueueItems[0].mTimestamp <= expectedPresentTime;		return mQueueItems[0].mTimestamp <= expectedPresentTime;
	}		}

	nsecs_t BufferQueueLayer::getDesiredPresentTime() {
	return mConsumer->getTimestamp();
	}

	std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTime() const {
	return mConsumer->getCurrentFenceTime();
	}

	void BufferQueueLayer::getDrawingTransformMatrix(float *matrix) {
	return mConsumer->getTransformMatrix(matrix);
	}

	// NOTE: SurfaceFlinger's definitions of "Current" and "Drawing" do not neatly map to BufferQueue's		// NOTE: SurfaceFlinger's definitions of "Current" and "Drawing" do not neatly map to BufferQueue's
	// These functions get the fields for the frame that is currently in SurfaceFlinger's Drawing state		// These functions get the fields for the frame that is currently in SurfaceFlinger's Drawing state
	// so the functions start with "getDrawing". The data is retrieved from the BufferQueueConsumer's		// so the functions start with "getDrawing". The data is retrieved from the BufferQueueConsumer's
	// current buffer so the consumer functions start with "getCurrent".		// current buffer so the consumer functions start with "getCurrent".
	//		//
	// This results in the rather confusing functions below.		// This results in the rather confusing functions below.
	uint32_t BufferQueueLayer::getDrawingTransform() const {
	return mConsumer->getCurrentTransform();
	}

	ui::Dataspace BufferQueueLayer::getDrawingDataSpace() const {
	return mConsumer->getCurrentDataSpace();
	}

	Rect BufferQueueLayer::getDrawingCrop() const {
	return mConsumer->getCurrentCrop();
	}

	uint32_t BufferQueueLayer::getDrawingScalingMode() const {
	return mConsumer->getCurrentScalingMode();
	}

	Region BufferQueueLayer::getDrawingSurfaceDamage() const {
	return mConsumer->getSurfaceDamage();
	}

	const HdrMetadata& BufferQueueLayer::getDrawingHdrMetadata() const {
	return mConsumer->getCurrentHdrMetadata();
	}

	int BufferQueueLayer::getDrawingApi() const {
	return mConsumer->getCurrentApi();
	}

	PixelFormat BufferQueueLayer::getPixelFormat() const {
	return mFormat;
	}

	uint64_t BufferQueueLayer::getFrameNumber(nsecs_t expectedPresentTime) const {		uint64_t BufferQueueLayer::getFrameNumber(nsecs_t expectedPresentTime) const {
	Mutex::Autolock lock(mQueueItemLock);		Mutex::Autolock lock(mQueueItemLock);
	@@ -422,7 +375,7 @@ void BufferQueueLayer::latchPerFrameState(
	compositionState.buffer = mActiveBuffer;		compositionState.buffer = mActiveBuffer;
	compositionState.bufferSlot =		compositionState.bufferSlot =
	(mActiveBufferSlot == BufferQueue::INVALID_BUFFER_SLOT) ? 0 : mActiveBufferSlot;		(mActiveBufferSlot == BufferQueue::INVALID_BUFFER_SLOT) ? 0 : mActiveBufferSlot;
	compositionState.acquireFence = mConsumer->getCurrentFence();		compositionState.acquireFence = mBufferInfo.mFence;
	}		}

	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	@@ -573,4 +526,20 @@ uint32_t BufferQueueLayer::getProducerStickyTransform() const {
	return static_cast<uint32_t>(producerStickyTransform);		return static_cast<uint32_t>(producerStickyTransform);
	}		}

			void BufferQueueLayer::gatherBufferInfo() {
			mBufferInfo.mDesiredPresentTime = mConsumer->getTimestamp();
			mBufferInfo.mFenceTime = mConsumer->getCurrentFenceTime();
			mBufferInfo.mFence = mConsumer->getCurrentFence();
			mConsumer->getTransformMatrix(mBufferInfo.mTransformMatrix);
			mBufferInfo.mTransform = mConsumer->getCurrentTransform();
			mBufferInfo.mDataspace = translateDataspace(mConsumer->getCurrentDataSpace());
			mBufferInfo.mCrop = mConsumer->getCurrentCrop();
			mBufferInfo.mScaleMode = mConsumer->getCurrentScalingMode();
			mBufferInfo.mSurfaceDamage = mConsumer->getSurfaceDamage();
			mBufferInfo.mHdrMetadata = mConsumer->getCurrentHdrMetadata();
			mBufferInfo.mApi = mConsumer->getCurrentApi();
			mBufferInfo.mPixelFormat = mFormat;
			mBufferInfo.mTransformToDisplayInverse = mConsumer->getTransformToDisplayInverse();
			}

	} // namespace android		} // namespace android

services/surfaceflinger/BufferQueueLayer.h

+2 −13

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

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

	bool getTransformToDisplayInverse() const override;

	// If a buffer was replaced this frame, release the former buffer		// If a buffer was replaced this frame, release the former buffer
	void releasePendingBuffer(nsecs_t dequeueReadyTime) override;		void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
	@@ -66,18 +65,6 @@ public:
	bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;		bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;

	private:		private:
	nsecs_t getDesiredPresentTime() override;
	std::shared_ptr<FenceTime> getCurrentFenceTime() const override;

	void getDrawingTransformMatrix(float *matrix) override;
	uint32_t getDrawingTransform() const override;
	ui::Dataspace getDrawingDataSpace() const override;
	Rect getDrawingCrop() const override;
	uint32_t getDrawingScalingMode() const override;
	Region getDrawingSurfaceDamage() const override;
	const HdrMetadata& getDrawingHdrMetadata() const override;
	int getDrawingApi() const override;
	PixelFormat getPixelFormat() const override;

	uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;		uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;

	@@ -103,6 +90,8 @@ private:
	// Interface implementation for BufferLayerConsumer::ContentsChangedListener		// Interface implementation for BufferLayerConsumer::ContentsChangedListener
	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------
	protected:		protected:
			void gatherBufferInfo() override;

	void onFrameAvailable(const BufferItem& item) override;		void onFrameAvailable(const BufferItem& item) override;
	void onFrameReplaced(const BufferItem& item) override;		void onFrameReplaced(const BufferItem& item) override;
	void onSidebandStreamChanged() override;		void onSidebandStreamChanged() override;

services/surfaceflinger/BufferStateLayer.cpp

+48 −78

Original line number	Original line	Diff line number	Diff line
	@@ -125,10 +125,6 @@ bool BufferStateLayer::willPresentCurrentTransaction() const {
	(mCurrentState.buffer != nullptr \|\| mCurrentState.bgColorLayer != nullptr));		(mCurrentState.buffer != nullptr \|\| mCurrentState.bgColorLayer != nullptr));
	}		}

	bool BufferStateLayer::getTransformToDisplayInverse() const {
	return mCurrentState.transformToDisplayInverse;
	}

	void BufferStateLayer::pushPendingState() {		void BufferStateLayer::pushPendingState() {
	if (!mCurrentState.modified) {		if (!mCurrentState.modified) {
	return;		return;
	@@ -400,75 +396,6 @@ bool BufferStateLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co
	return mCurrentState.desiredPresentTime <= expectedPresentTime;		return mCurrentState.desiredPresentTime <= expectedPresentTime;
	}		}

	nsecs_t BufferStateLayer::getDesiredPresentTime() {
	return getDrawingState().desiredPresentTime;
	}

	std::shared_ptr<FenceTime> BufferStateLayer::getCurrentFenceTime() const {
	return std::make_shared<FenceTime>(getDrawingState().acquireFence);
	}

	void BufferStateLayer::getDrawingTransformMatrix(float *matrix) {
	std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix), matrix);
	}

	uint32_t BufferStateLayer::getDrawingTransform() const {
	return getDrawingState().transform;
	}

	ui::Dataspace BufferStateLayer::getDrawingDataSpace() const {
	return getDrawingState().dataspace;
	}

	// Crop that applies to the buffer
	Rect BufferStateLayer::getDrawingCrop() const {
	const State& s(getDrawingState());

	if (s.crop.isEmpty() && s.buffer) {
	return s.buffer->getBounds();
	} else if (s.buffer) {
	Rect crop = s.crop;
	crop.left = std::max(crop.left, 0);
	crop.top = std::max(crop.top, 0);
	uint32_t bufferWidth = s.buffer->getWidth();
	uint32_t bufferHeight = s.buffer->getHeight();
	if (bufferHeight <= std::numeric_limits<int32_t>::max() &&
	bufferWidth <= std::numeric_limits<int32_t>::max()) {
	crop.right = std::min(crop.right, static_cast<int32_t>(bufferWidth));
	crop.bottom = std::min(crop.bottom, static_cast<int32_t>(bufferHeight));
	}
	if (!crop.isValid()) {
	// Crop rect is out of bounds, return whole buffer
	return s.buffer->getBounds();
	}
	return crop;
	}
	return s.crop;
	}

	uint32_t BufferStateLayer::getDrawingScalingMode() const {
	return NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
	}

	Region BufferStateLayer::getDrawingSurfaceDamage() const {
	return getDrawingState().surfaceDamageRegion;
	}

	const HdrMetadata& BufferStateLayer::getDrawingHdrMetadata() const {
	return getDrawingState().hdrMetadata;
	}

	int BufferStateLayer::getDrawingApi() const {
	return getDrawingState().api;
	}

	PixelFormat BufferStateLayer::getPixelFormat() const {
	if (!mActiveBuffer) {
	return PIXEL_FORMAT_NONE;
	}
	return mActiveBuffer->format;
	}

	uint64_t BufferStateLayer::getFrameNumber(nsecs_t /expectedPresentTime/) const {		uint64_t BufferStateLayer::getFrameNumber(nsecs_t /expectedPresentTime/) const {
	return mFrameNumber;		return mFrameNumber;
	}		}
	@@ -506,8 +433,8 @@ bool BufferStateLayer::hasFrameUpdate() const {
	}		}

	void BufferStateLayer::setFilteringEnabled(bool enabled) {		void BufferStateLayer::setFilteringEnabled(bool enabled) {
	GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mCurrentCrop,		GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mBufferInfo.mCrop,
	mCurrentTransform, enabled);		mBufferInfo.mTransform, enabled);
	}		}

	status_t BufferStateLayer::bindTextureImage() {		status_t BufferStateLayer::bindTextureImage() {
	@@ -576,8 +503,8 @@ status_t BufferStateLayer::updateTexImage(bool& /recomputeVisibleRegions/, nse
	}		}

	const uint64_t bufferID = getCurrentBufferId();		const uint64_t bufferID = getCurrentBufferId();
	mFlinger->mTimeStats->setAcquireFence(layerID, mFrameNumber, getCurrentFenceTime());		mFlinger->mTimeStats->setAcquireFence(layerID, mFrameNumber, mBufferInfo.mFenceTime);
	mFlinger->mFrameTracer->traceFence(layerID, bufferID, mFrameNumber, getCurrentFenceTime(),		mFlinger->mFrameTracer->traceFence(layerID, bufferID, mFrameNumber, mBufferInfo.mFenceTime,
	FrameTracer::FrameEvent::ACQUIRE_FENCE);		FrameTracer::FrameEvent::ACQUIRE_FENCE);
	mFlinger->mTimeStats->setLatchTime(layerID, mFrameNumber, latchTime);		mFlinger->mTimeStats->setLatchTime(layerID, mFrameNumber, latchTime);
	mFlinger->mFrameTracer->traceTimestamp(layerID, bufferID, mFrameNumber, latchTime,		mFlinger->mFrameTracer->traceTimestamp(layerID, bufferID, mFrameNumber, latchTime,
	@@ -622,7 +549,7 @@ void BufferStateLayer::latchPerFrameState(

	compositionState.buffer = s.buffer;		compositionState.buffer = s.buffer;
	compositionState.bufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);		compositionState.bufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);
	compositionState.acquireFence = s.acquireFence;		compositionState.acquireFence = mBufferInfo.mFence;

	mFrameNumber++;		mFrameNumber++;
	}		}
	@@ -707,4 +634,47 @@ void BufferStateLayer::HwcSlotGenerator::eraseBufferLocked(const client_cache_t&
	mFreeHwcCacheSlots.push(hwcCacheSlot);		mFreeHwcCacheSlots.push(hwcCacheSlot);
	mCachedBuffers.erase(clientCacheId);		mCachedBuffers.erase(clientCacheId);
	}		}

			void BufferStateLayer::gatherBufferInfo() {
			const State& s(getDrawingState());

			mBufferInfo.mDesiredPresentTime = s.desiredPresentTime;
			mBufferInfo.mFenceTime = std::make_shared<FenceTime>(s.acquireFence);
			mBufferInfo.mFence = s.acquireFence;
			std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix),
			mBufferInfo.mTransformMatrix);
			mBufferInfo.mTransform = s.transform;
			mBufferInfo.mDataspace = translateDataspace(s.dataspace);
			mBufferInfo.mCrop = computeCrop(s);
			mBufferInfo.mScaleMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
			mBufferInfo.mSurfaceDamage = s.surfaceDamageRegion;
			mBufferInfo.mHdrMetadata = s.hdrMetadata;
			mBufferInfo.mApi = s.api;
			mBufferInfo.mPixelFormat = !mActiveBuffer ? PIXEL_FORMAT_NONE : mActiveBuffer->format;
			mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;
			}

			Rect BufferStateLayer::computeCrop(const State& s) {
			if (s.crop.isEmpty() && s.buffer) {
			return s.buffer->getBounds();
			} else if (s.buffer) {
			Rect crop = s.crop;
			crop.left = std::max(crop.left, 0);
			crop.top = std::max(crop.top, 0);
			uint32_t bufferWidth = s.buffer->getWidth();
			uint32_t bufferHeight = s.buffer->getHeight();
			if (bufferHeight <= std::numeric_limits<int32_t>::max() &&
			bufferWidth <= std::numeric_limits<int32_t>::max()) {
			crop.right = std::min(crop.right, static_cast<int32_t>(bufferWidth));
			crop.bottom = std::min(crop.bottom, static_cast<int32_t>(bufferHeight));
			}
			if (!crop.isValid()) {
			// Crop rect is out of bounds, return whole buffer
			return s.buffer->getBounds();
			}
			return crop;
			}
			return s.crop;
			}

	} // namespace android		} // namespace android