ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge "BufferQueue no longer hardcodes buffer counts"

Browse Source
This commit is contained in:
Mathias Agopian 2012-04-09 17:35:00 -07:00 committed by Android (Google) Code Review
commit d5caca1d0d
3 changed files with 30 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
include/gui/BufferQueue.h
View File

@ -35,10 +35,6 @@ namespace android {
class BufferQueue : public BnSurfaceTexture {
public:
enum { MIN_UNDEQUEUED_BUFFERS = 2 };
enum {
MIN_ASYNC_BUFFER_SLOTS = MIN_UNDEQUEUED_BUFFERS + 1,
MIN_SYNC_BUFFER_SLOTS = MIN_UNDEQUEUED_BUFFERS
};
enum { NUM_BUFFER_SLOTS = 32 };
enum { NO_CONNECTED_API = 0 };
enum { INVALID_BUFFER_SLOT = -1 };
@ -99,7 +95,8 @@ public:
// by producers and consumers.
// allowSynchronousMode specifies whether or not synchronous mode can be
// enabled.
BufferQueue(bool allowSynchronousMode = true);
// bufferCount sets the minimum number of undequeued buffers for this queue
BufferQueue( bool allowSynchronousMode = true, int bufferCount = MIN_UNDEQUEUED_BUFFERS);
virtual ~BufferQueue();
virtual int query(int what, int* value);
@ -402,6 +399,18 @@ private:
// in requestBuffers() if a format of zero is specified.
uint32_t mPixelFormat;
// mMinUndequeuedBuffers is a constraint on the number of buffers
// not dequeued at any time
int mMinUndequeuedBuffers;
// mMinAsyncBufferSlots is a constraint on the minimum mBufferCount
// when this BufferQueue is in asynchronous mode
int mMinAsyncBufferSlots;
// mMinSyncBufferSlots is a constraint on the minimum mBufferCount
// when this BufferQueue is in synchronous mode
int mMinSyncBufferSlots;
// mBufferCount is the number of buffer slots that the client and server
// must maintain. It defaults to MIN_ASYNC_BUFFER_SLOTS and can be changed
// by calling setBufferCount or setBufferCountServer

1
include/gui/SurfaceTextureClient.h
View File

@ -104,7 +104,6 @@ protected:
virtual int lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds);
virtual int unlockAndPost();
enum { MIN_UNDEQUEUED_BUFFERS = BufferQueue::MIN_UNDEQUEUED_BUFFERS };
enum { NUM_BUFFER_SLOTS = BufferQueue::NUM_BUFFER_SLOTS };
enum { DEFAULT_FORMAT = PIXEL_FORMAT_RGBA_8888 };

26
libs/gui/BufferQueue.cpp
View File

@ -69,13 +69,16 @@ static int32_t createProcessUniqueId() {
return android_atomic_inc(&globalCounter);
}
BufferQueue::BufferQueue( bool allowSynchronousMode ) :
BufferQueue::BufferQueue( bool allowSynchronousMode, int bufferCount ) :
mDefaultWidth(1),
mDefaultHeight(1),
mPixelFormat(PIXEL_FORMAT_RGBA_8888),
mBufferCount(MIN_ASYNC_BUFFER_SLOTS),
mMinUndequeuedBuffers(bufferCount),
mMinAsyncBufferSlots(bufferCount + 1),
mMinSyncBufferSlots(bufferCount),
mBufferCount(mMinAsyncBufferSlots),
mClientBufferCount(0),
mServerBufferCount(MIN_ASYNC_BUFFER_SLOTS),
mServerBufferCount(mMinAsyncBufferSlots),
mSynchronousMode(false),
mAllowSynchronousMode(allowSynchronousMode),
mConnectedApi(NO_CONNECTED_API),
@ -92,6 +95,9 @@ BufferQueue::BufferQueue( bool allowSynchronousMode ) :
ST_LOGV("BufferQueue");
sp<ISurfaceComposer> composer(ComposerService::getComposerService());
mGraphicBufferAlloc = composer->createGraphicBufferAlloc();
if (mGraphicBufferAlloc == 0) {
ST_LOGE("createGraphicBufferAlloc() failed in BufferQueue()");
}
}
BufferQueue::~BufferQueue() {
@ -186,7 +192,7 @@ status_t BufferQueue::setBufferCount(int bufferCount) {
}
const int minBufferSlots = mSynchronousMode ?
MIN_SYNC_BUFFER_SLOTS : MIN_ASYNC_BUFFER_SLOTS;
mMinSyncBufferSlots : mMinAsyncBufferSlots;
if (bufferCount == 0) {
mClientBufferCount = 0;
bufferCount = (mServerBufferCount >= minBufferSlots) ?
@ -241,7 +247,7 @@ int BufferQueue::query(int what, int* outValue)
break;
case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:
value = mSynchronousMode ?
(MIN_UNDEQUEUED_BUFFERS-1) : MIN_UNDEQUEUED_BUFFERS;
(mMinUndequeuedBuffers-1) : mMinUndequeuedBuffers;
break;
default:
return BAD_VALUE;
@ -317,7 +323,7 @@ status_t BufferQueue::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h,
// wait on mDequeueCondition.
const int minBufferCountNeeded = mSynchronousMode ?
MIN_SYNC_BUFFER_SLOTS : MIN_ASYNC_BUFFER_SLOTS;
mMinSyncBufferSlots : mMinAsyncBufferSlots;
const bool numberOfBuffersNeedsToChange = !mClientBufferCount &&
((mServerBufferCount != mBufferCount) ||
@ -384,15 +390,15 @@ status_t BufferQueue::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h,
// See whether a buffer has been queued since the last
// setBufferCount so we know whether to perform the
// MIN_UNDEQUEUED_BUFFERS check below.
// mMinUndequeuedBuffers check below.
if (mBufferHasBeenQueued) {
// make sure the client is not trying to dequeue more buffers
// than allowed.
const int avail = mBufferCount - (dequeuedCount+1);
if (avail < (MIN_UNDEQUEUED_BUFFERS-int(mSynchronousMode))) {
ST_LOGE("dequeueBuffer: MIN_UNDEQUEUED_BUFFERS=%d exceeded "
if (avail < (mMinUndequeuedBuffers-int(mSynchronousMode))) {
ST_LOGE("dequeueBuffer: mMinUndequeuedBuffers=%d exceeded "
"(dequeued=%d)",
MIN_UNDEQUEUED_BUFFERS-int(mSynchronousMode),
mMinUndequeuedBuffers-int(mSynchronousMode),
dequeuedCount);
return -EBUSY;
}