Remove unnecessary buffer count changes (3ced538a) · Commits · e / os / android_frameworks_native

libs/gui/BLASTBufferQueue.cpp

+3 −138

Original line number	Diff line number	Diff line
		@@ -527,13 +527,7 @@ void BLASTBufferQueue::releaseBuffer(const ReleaseCallbackId& callbackId,
		callbackId.to_string().c_str());
		return;
		}
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
		if (!it->second.disconnectedAfterAcquired) {
		mNumAcquired--;
		}
		#else
		mNumAcquired--;
		#endif
		BBQ_TRACE("frame=%" PRIu64, callbackId.framenumber);
		BQA_LOGV("released %s", callbackId.to_string().c_str());
		mBufferItemConsumer->releaseBuffer(it->second, releaseFence);
		@@ -584,7 +578,7 @@ status_t BLASTBufferQueue::acquireNextBufferLocked(
		applyTransaction = false;
		}

		BLASTBufferItem bufferItem;
		BufferItem bufferItem;

		status_t status =
		mBufferItemConsumer->acquireBuffer(&bufferItem, 0 /* expectedPresent */, false);
		@@ -795,9 +789,6 @@ void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) {
		}

		// add to shadow queue
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
		mNumDequeued--;
		#endif
		mNumFrameAvailable++;
		if (waitForTransactionCallback && mNumFrameAvailable >= 2) {
		acquireAndReleaseBuffer();
		@@ -852,19 +843,10 @@ void BLASTBufferQueue::onFrameDequeued(const uint64_t bufferId) {
		};

		void BLASTBufferQueue::onFrameCancelled(const uint64_t bufferId) {
		{
		std::lock_guard _lock{mTimestampMutex};
		mDequeueTimestamps.erase(bufferId);
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
		{
		std::lock_guard lock{mMutex};
		mNumDequeued--;
		}
		#endif
		}

		bool BLASTBufferQueue::syncNextTransaction(
		std::function<void(SurfaceComposerClient::Transaction*)> callback,
		bool acquireSingleBuffer) {
		@@ -1162,116 +1144,6 @@ public:
		producerControlledByApp, output);
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
		status_t disconnect(int api, DisconnectMode mode) override {
		sp<BLASTBufferQueue> bbq = mBLASTBufferQueue.promote();
		if (!bbq) {
		return BufferQueueProducer::disconnect(api, mode);
		}

		std::lock_guard lock{bbq->mMutex};
		if (status_t status = BufferQueueProducer::disconnect(api, mode); status != OK) {
		return status;
		}

		// We need to reset dequeued and acquired counts because BufferQueueProducer::disconnect
		// calls BufferQueueCore::freeAllBuffersLocked which frees all dequeued and acquired
		// buffers. We don't reset mNumFrameAvailable because these buffers are still available
		// in BufferItemConsumer.
		bbq->mNumDequeued = 0;
		bbq->mNumAcquired = 0;
		// SurfaceFlinger sends release callbacks for buffers that have been acquired after a
		// disconnect. We set disconnectedAfterAcquired to true so that we can ignore any stale
		// releases that come in after the producer is disconnected. Otherwise, releaseBuffer will
		// decrement mNumAcquired for a buffer that was acquired before we reset mNumAcquired to
		// zero.
		for (auto& [releaseId, bufferItem] : bbq->mSubmitted) {
		bufferItem.disconnectedAfterAcquired = true;
		}

		return OK;
		}

		status_t setAsyncMode(bool asyncMode) override {
		if (status_t status = BufferQueueProducer::setAsyncMode(asyncMode); status != OK) {
		return status;
		}

		sp<BLASTBufferQueue> bbq = mBLASTBufferQueue.promote();
		if (!bbq) {
		return OK;
		}

		{
		std::lock_guard lock{bbq->mMutex};
		bbq->mAsyncMode = asyncMode;
		}

		return OK;
		}

		status_t setSharedBufferMode(bool sharedBufferMode) override {
		if (status_t status = BufferQueueProducer::setSharedBufferMode(sharedBufferMode);
		status != OK) {
		return status;
		}

		sp<BLASTBufferQueue> bbq = mBLASTBufferQueue.promote();
		if (!bbq) {
		return OK;
		}

		{
		std::lock_guard lock{bbq->mMutex};
		bbq->mSharedBufferMode = sharedBufferMode;
		}

		return OK;
		}

		status_t detachBuffer(int slot) override {
		if (status_t status = BufferQueueProducer::detachBuffer(slot); status != OK) {
		return status;
		}

		sp<BLASTBufferQueue> bbq = mBLASTBufferQueue.promote();
		if (!bbq) {
		return OK;
		}

		{
		std::lock_guard lock{bbq->mMutex};
		bbq->mNumDequeued--;
		}

		return OK;
		}

		status_t dequeueBuffer(int* outSlot, sp<Fence>* outFence, uint32_t width, uint32_t height,
		PixelFormat format, uint64_t usage, uint64_t* outBufferAge,
		FrameEventHistoryDelta* outTimestamps) override {
		sp<BLASTBufferQueue> bbq = mBLASTBufferQueue.promote();
		if (!bbq) {
		return BufferQueueProducer::dequeueBuffer(outSlot, outFence, width, height, format,
		usage, outBufferAge, outTimestamps);
		}

		{
		std::lock_guard lock{bbq->mMutex};
		bbq->mNumDequeued++;
		}

		status_t status =
		BufferQueueProducer::dequeueBuffer(outSlot, outFence, width, height, format, usage,
		outBufferAge, outTimestamps);
		if (status < 0) {
		std::lock_guard lock{bbq->mMutex};
		bbq->mNumDequeued--;
		}
		return status;
		}
		#endif

		// We want to resize the frame history when changing the size of the buffer queue
		status_t setMaxDequeuedBufferCount(int maxDequeuedBufferCount) override {
		int maxBufferCount;
		@@ -1294,13 +1166,6 @@ public:
		bbq->resizeFrameEventHistory(newFrameHistorySize);
		}

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
		{
		std::lock_guard lock{bbq->mMutex};
		bbq->mMaxDequeuedBuffers = maxDequeuedBufferCount;
		}
		#endif

		return OK;
		}

libs/gui/include/gui/BLASTBufferQueue.h

+1 −17

Original line number	Diff line number	Diff line
		@@ -187,15 +187,6 @@ private:
		// BufferQueue internally allows 1 more than
		// the max to be acquired
		int32_t mMaxAcquiredBuffers GUARDED_BY(mMutex) = 1;
		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
		int32_t mMaxDequeuedBuffers GUARDED_BY(mMutex) = 1;
		static constexpr int32_t kMaxBufferCount = BufferQueueDefs::NUM_BUFFER_SLOTS;

		bool mAsyncMode GUARDED_BY(mMutex) = false;
		bool mSharedBufferMode GUARDED_BY(mMutex) = false;

		int32_t mNumDequeued GUARDED_BY(mMutex) = 0;
		#endif
		int32_t mNumFrameAvailable GUARDED_BY(mMutex) = 0;
		int32_t mNumAcquired GUARDED_BY(mMutex) = 0;

		@@ -204,16 +195,9 @@ private:
		// latch stale buffers and that we don't wait on barriers from an old producer.
		uint32_t mProducerId = 0;

		class BLASTBufferItem : public BufferItem {
		public:
		// True if BBQBufferQueueProducer is disconnected after the buffer is acquried but
		// before it is released.
		bool disconnectedAfterAcquired{false};
		};

		// Keep a reference to the submitted buffers so we can release when surfaceflinger drops the
		// buffer or the buffer has been presented and a new buffer is ready to be presented.
		std::unordered_map<ReleaseCallbackId, BLASTBufferItem, ReleaseBufferCallbackIdHash> mSubmitted
		std::unordered_map<ReleaseCallbackId, BufferItem, ReleaseBufferCallbackIdHash> mSubmitted
		GUARDED_BY(mMutex);

		// Keep a queue of the released buffers instead of immediately releasing