Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d5caca1d authored by Mathias Agopian's avatar Mathias Agopian Committed by Android (Google) Code Review
Browse files

Merge "BufferQueue no longer hardcodes buffer counts"

parents 3a778713 abe61bfd

include/gui/BufferQueue.h

+14 −5
Original line number Diff line number Diff line
@@ -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

include/gui/SurfaceTextureClient.h

+0 −1
Original line number Diff line number Diff line
@@ -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 };

libs/gui/BufferQueue.cpp

+16 −10
Original line number Diff line number Diff line
@@ -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;

                }