Merge "BQ: Get rid of setBufferCount" (e60fff5d) · Commits · e / os / platform_frameworks_native

include/gui/BufferQueueCore.h

+7 −7

Original line number	Diff line number	Diff line
		@@ -192,13 +192,6 @@ private:
		// a buffer attached
		std::list<int> mFreeBuffers;

		// mOverrideMaxBufferCount is the limit on the number of buffers that will
		// be allocated at one time. This value is set by the producer by calling
		// setBufferCount. The default is 0, which means that the producer doesn't
		// care about the number of buffers in the pool. In that case,
		// mDefaultMaxBufferCount is used as the limit.
		int mOverrideMaxBufferCount;

		// mDequeueCondition is a condition variable used for dequeueBuffer in
		// synchronous mode.
		mutable Condition mDequeueCondition;
		@@ -247,6 +240,13 @@ private:
		// via setMaxDequeuedBufferCount.
		int mMaxDequeuedBufferCount;

		// mOverrideMaxBufferCount defaults to false and is set to true once the
		// producer has called setMaxDequeuedBufferCount or setAsyncMode. Once it is
		// set mDefaultMaxBufferCount is ignored and the max buffer count is
		// calculated based on mMaxAcquiredBufferCount, mMaxDequeuedBufferCount, and
		// mAsyncMode.
		bool mOverrideMaxBufferCount;

		// mBufferHasBeenQueued is true once a buffer has been queued. It is reset
		// when something causes all buffers to be freed (e.g., changing the buffer
		// count).

include/gui/BufferQueueProducer.h

+0 −17

Original line number	Diff line number	Diff line
		@@ -39,23 +39,6 @@ public:
		// flags indicating that previously-returned buffers are no longer valid.
		virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* buf);

		// setBufferCount updates the number of available buffer slots. If this
		// method succeeds, buffer slots will be both unallocated and owned by
		// the BufferQueue object (i.e. they are not owned by the producer or
		// consumer).
		//
		// This will fail if the producer has dequeued any buffers, or if
		// bufferCount is invalid. bufferCount must generally be a value
		// between the minimum undequeued buffer count (exclusive) and NUM_BUFFER_SLOTS
		// (inclusive). It may also be set to zero (the default) to indicate
		// that the producer does not wish to set a value. The minimum value
		// can be obtained by calling query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
		// ...).
		//
		// This may only be called by the producer. The consumer will be told
		// to discard buffers through the onBuffersReleased callback.
		virtual status_t setBufferCount(int bufferCount);

		// see IGraphicsBufferProducer::setMaxDequeuedBufferCount
		virtual status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers);

include/gui/IGraphicBufferProducer.h

+0 −22

Original line number	Diff line number	Diff line
		@@ -80,28 +80,6 @@ public:
		// * buffer specified by the slot is not dequeued
		virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* buf) = 0;

		// setBufferCount sets the number of buffer slots available. Calling this
		// will also cause all buffer slots to be emptied. The caller should empty
		// its mirrored copy of the buffer slots when calling this method.
		//
		// This function should not be called when there are any dequeued buffer
		// slots, doing so will result in a BAD_VALUE error returned.
		//
		// The buffer count should be at most NUM_BUFFER_SLOTS (inclusive), but at least
		// the minimum undequeued buffer count (exclusive). The minimum value
		// can be obtained by calling query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS).
		// In particular the range is (minUndequeudBuffers, NUM_BUFFER_SLOTS].
		//
		// The buffer count may also be set to 0 (the default), to indicate that
		// the producer does not wish to set a value.
		//
		// Return of a value other than NO_ERROR means an error has occurred:
		// * NO_INIT - the buffer queue has been abandoned.
		// * BAD_VALUE - one of the below conditions occurred:
		// * bufferCount was out of range (see above)
		// * client has one or more buffers dequeued
		virtual status_t setBufferCount(int bufferCount) = 0;

		// setMaxDequeuedBufferCount sets the maximum number of buffers that can be
		// dequeued by the producer at one time. If this method succeeds, buffer
		// slots will be both unallocated and owned by the BufferQueue object (i.e.

libs/gui/BufferQueueCore.cpp

+6 −4

Original line number	Diff line number	Diff line
		@@ -55,7 +55,6 @@ BufferQueueCore::BufferQueueCore(const sp<IGraphicBufferAlloc>& allocator) :
		mQueue(),
		mFreeSlots(),
		mFreeBuffers(),
		mOverrideMaxBufferCount(0),
		mDequeueCondition(),
		mUseAsyncBuffer(true),
		mDequeueBufferCannotBlock(false),
		@@ -66,6 +65,7 @@ BufferQueueCore::BufferQueueCore(const sp<IGraphicBufferAlloc>& allocator) :
		mDefaultMaxBufferCount(2),
		mMaxAcquiredBufferCount(1),
		mMaxDequeuedBufferCount(1),
		mOverrideMaxBufferCount(false),
		mBufferHasBeenQueued(false),
		mFrameCounter(0),
		mTransformHint(0),
		@@ -164,9 +164,11 @@ int BufferQueueCore::getMaxBufferCountLocked(bool async) const {
		int minMaxBufferCount = getMinMaxBufferCountLocked(async);

		int maxBufferCount = max(mDefaultMaxBufferCount, minMaxBufferCount);
		if (mOverrideMaxBufferCount != 0) {
		assert(mOverrideMaxBufferCount >= minMaxBufferCount);
		maxBufferCount = mOverrideMaxBufferCount;
		if (mOverrideMaxBufferCount) {
		int bufferCount = mMaxAcquiredBufferCount + mMaxDequeuedBufferCount +
		(async ? 1 : 0);
		assert(bufferCount >= minMaxBufferCount);
		maxBufferCount = bufferCount;
		}

		// Any buffers that are dequeued by the producer or sitting in the queue

libs/gui/BufferQueueProducer.cpp

+9 −105

Original line number	Diff line number	Diff line
		@@ -72,66 +72,6 @@ status_t BufferQueueProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
		return NO_ERROR;
		}

		status_t BufferQueueProducer::setBufferCount(int bufferCount) {
		ATRACE_CALL();
		BQ_LOGV("setBufferCount: count = %d", bufferCount);

		sp<IConsumerListener> listener;
		{ // Autolock scope
		Mutex::Autolock lock(mCore->mMutex);
		mCore->waitWhileAllocatingLocked();

		if (mCore->mIsAbandoned) {
		BQ_LOGE("setBufferCount: BufferQueue has been abandoned");
		return NO_INIT;
		}

		if (bufferCount > BufferQueueDefs::NUM_BUFFER_SLOTS) {
		BQ_LOGE("setBufferCount: bufferCount %d too large (max %d)",
		bufferCount, BufferQueueDefs::NUM_BUFFER_SLOTS);
		return BAD_VALUE;
		}

		// There must be no dequeued buffers when changing the buffer count.
		for (int s = 0; s < BufferQueueDefs::NUM_BUFFER_SLOTS; ++s) {
		if (mSlots[s].mBufferState == BufferSlot::DEQUEUED) {
		BQ_LOGE("setBufferCount: buffer owned by producer");
		return BAD_VALUE;
		}
		}

		if (bufferCount == 0) {
		mCore->mOverrideMaxBufferCount = 0;
		mCore->mDequeueCondition.broadcast();
		return NO_ERROR;
		}

		const int minBufferSlots = mCore->getMinMaxBufferCountLocked(false);
		if (bufferCount < minBufferSlots) {
		BQ_LOGE("setBufferCount: requested buffer count %d is less than "
		"minimum %d", bufferCount, minBufferSlots);
		return BAD_VALUE;
		}

		// Here we are guaranteed that the producer doesn't have any dequeued
		// buffers and will release all of its buffer references. We don't
		// clear the queue, however, so that currently queued buffers still
		// get displayed.
		mCore->freeAllBuffersLocked();
		mCore->mMaxDequeuedBufferCount = bufferCount - minBufferSlots + 1;
		mCore->mOverrideMaxBufferCount = bufferCount;
		mCore->mDequeueCondition.broadcast();
		listener = mCore->mConsumerListener;
		} // Autolock scope

		// Call back without lock held
		if (listener != NULL) {
		listener->onBuffersReleased();
		}

		return NO_ERROR;
		}

		status_t BufferQueueProducer::setMaxDequeuedBufferCount(
		int maxDequeuedBuffers) {
		ATRACE_CALL();
		@@ -181,7 +121,7 @@ status_t BufferQueueProducer::setMaxDequeuedBufferCount(
		// get displayed.
		mCore->freeAllBuffersLocked();
		mCore->mMaxDequeuedBufferCount = maxDequeuedBuffers;
		mCore->mOverrideMaxBufferCount = bufferCount;
		mCore->mOverrideMaxBufferCount = true;
		mCore->mDequeueCondition.broadcast();
		listener = mCore->mConsumerListener;
		} // Autolock scope
		@@ -217,6 +157,7 @@ status_t BufferQueueProducer::setAsyncMode(bool async) {
		}

		mCore->mAsyncMode = async;
		mCore->mOverrideMaxBufferCount = true;
		mCore->mDequeueCondition.broadcast();
		listener = mCore->mConsumerListener;
		} // Autolock scope
		@@ -238,16 +179,6 @@ status_t BufferQueueProducer::waitForFreeSlotThenRelock(const char* caller,
		}

		const int maxBufferCount = mCore->getMaxBufferCountLocked(async);
		if (async && mCore->mOverrideMaxBufferCount) {
		// FIXME: Some drivers are manually setting the buffer count
		// (which they shouldn't), so we do this extra test here to
		// handle that case. This is TEMPORARY until we get this fixed.
		if (mCore->mOverrideMaxBufferCount < maxBufferCount) {
		BQ_LOGE("%s: async mode is invalid with buffer count override",
		caller);
		return BAD_VALUE;
		}
		}

		// Free up any buffers that are in slots beyond the max buffer count
		for (int s = maxBufferCount; s < BufferQueueDefs::NUM_BUFFER_SLOTS; ++s) {
		@@ -273,33 +204,16 @@ status_t BufferQueueProducer::waitForFreeSlotThenRelock(const char* caller,
		}
		}

		// Producers are not allowed to dequeue more than one buffer if they
		// did not set a buffer count
		if (!mCore->mOverrideMaxBufferCount && dequeuedCount) {
		BQ_LOGE("%s: can't dequeue multiple buffers without setting the "
		"buffer count", caller);
		// Producers are not allowed to dequeue more than
		// mMaxDequeuedBufferCount buffers.
		// This check is only done if a buffer has already been queued
		if (mCore->mBufferHasBeenQueued &&
		dequeuedCount >= mCore->mMaxDequeuedBufferCount) {
		BQ_LOGE("%s: attempting to exceed the max dequeued buffer count "
		"(%d)", caller, mCore->mMaxDequeuedBufferCount);
		return INVALID_OPERATION;
		}

		// See whether a buffer has been queued since the last
		// setBufferCount so we know whether to perform the min undequeued
		// buffers check below
		if (mCore->mBufferHasBeenQueued) {
		// Make sure the producer is not trying to dequeue more buffers
		// than allowed
		const int newUndequeuedCount =
		maxBufferCount - (dequeuedCount + 1);
		const int minUndequeuedCount =
		mCore->getMinUndequeuedBufferCountLocked(async);
		if (newUndequeuedCount < minUndequeuedCount) {
		BQ_LOGE("%s: min undequeued buffer count (%d) exceeded "
		"(dequeued=%d undequeued=%d)",
		caller, minUndequeuedCount,
		dequeuedCount, newUndequeuedCount);
		return INVALID_OPERATION;
		}
		}

		*found = BufferQueueCore::INVALID_BUFFER_SLOT;

		// If we disconnect and reconnect quickly, we can be in a state where
		@@ -683,16 +597,6 @@ status_t BufferQueueProducer::queueBuffer(int slot,
		}

		const int maxBufferCount = mCore->getMaxBufferCountLocked(async);
		if (async && mCore->mOverrideMaxBufferCount) {
		// FIXME: Some drivers are manually setting the buffer count
		// (which they shouldn't), so we do this extra test here to
		// handle that case. This is TEMPORARY until we get this fixed.
		if (mCore->mOverrideMaxBufferCount < maxBufferCount) {
		BQ_LOGE("queueBuffer: async mode is invalid with "
		"buffer count override");
		return BAD_VALUE;
		}
		}

		if (slot < 0 \|\| slot >= maxBufferCount) {
		BQ_LOGE("queueBuffer: slot index %d out of range [0, %d)",