Merge "Created bufferInfo to track buffer data in a single place (1/2)" (7d2b2089) · Commits · e / os / android_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+77 −47

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

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

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

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

		@@ -269,7 +269,7 @@ void BufferLayer::latchPerFrameState(
		compositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND;
		} else {
		// Normal buffer layers
		compositionState.hdrMetadata = getDrawingHdrMetadata();
		compositionState.hdrMetadata = mBufferInfo.mHdrMetadata;
		compositionState.compositionType = mPotentialCursor
		? Hwc2::IComposerClient::Composition::CURSOR
		: Hwc2::IComposerClient::Composition::DEVICE;
		@@ -301,13 +301,13 @@ bool BufferLayer::onPostComposition(const std::optional<DisplayId>& displayId,
		}

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

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

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

		BufferInfo oldBufferInfo = mBufferInfo;
		gatherBufferInfo();

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

		ui::Dataspace dataSpace = getDrawingDataSpace();
		// translate legacy dataspaces to modern dataspaces
		switch (dataSpace) {
		case ui::Dataspace::SRGB:
		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;
		if ((mBufferInfo.mCrop != oldBufferInfo.mCrop) \|\|
		(mBufferInfo.mTransform != oldBufferInfo.mTransform) \|\|
		(mBufferInfo.mScaleMode != oldBufferInfo.mScaleMode) \|\|
		(mBufferInfo.mTransformToDisplayInverse != oldBufferInfo.mTransformToDisplayInverse)) {
		recomputeVisibleRegions = true;
		}

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

		return mCurrentScalingMode;
		return mBufferInfo.mScaleMode;
		}

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

		// 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);
		}

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

		// 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);
		}

		@@ -686,6 +656,66 @@ void BufferLayer::latchAndReleaseBuffer() {
		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

		#if defined(__gl_h_)

services/surfaceflinger/BufferLayer.h

+30 −16

Original line number	Diff line number	Diff line
		@@ -106,6 +106,14 @@ public:
		// Should only be called on the main thread.
		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 framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const = 0;

		virtual nsecs_t getDesiredPresentTime() = 0;
		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;
		PixelFormat getPixelFormat() const;

		virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;

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

		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
		*/
		@@ -171,16 +187,14 @@ protected:

		bool mRefreshPending{false};

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

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

		uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

		uint32_t mCurrentScalingMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};

		bool mTransformToDisplayInverse{false};

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

services/surfaceflinger/BufferQueueLayer.cpp

+17 −48

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

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

		void BufferQueueLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) {
		if (!mConsumer->releasePendingBuffer()) {
		return;
		@@ -155,55 +151,12 @@ bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co
		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
		// 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
		// current buffer so the consumer functions start with "getCurrent".
		//
		// 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 {
		Mutex::Autolock lock(mQueueItemLock);
		@@ -422,7 +375,7 @@ void BufferQueueLayer::latchPerFrameState(
		compositionState.buffer = mActiveBuffer;
		compositionState.bufferSlot =
		(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);
		}

		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

services/surfaceflinger/BufferQueueLayer.h

+2 −13

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

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

		bool getTransformToDisplayInverse() const override;

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

		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;

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

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

services/surfaceflinger/BufferStateLayer.cpp

+48 −78

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

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

		void BufferStateLayer::pushPendingState() {
		if (!mCurrentState.modified) {
		return;
		@@ -400,75 +396,6 @@ bool BufferStateLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co
		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 {
		return mFrameNumber;
		}
		@@ -506,8 +433,8 @@ bool BufferStateLayer::hasFrameUpdate() const {
		}

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

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

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

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

		mFrameNumber++;
		}
		@@ -707,4 +634,47 @@ void BufferStateLayer::HwcSlotGenerator::eraseBufferLocked(const client_cache_t&
		mFreeHwcCacheSlots.push(hwcCacheSlot);
		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