Merge "BQ: Modify consumer buffer count interfaces"

    sp<GLConsumer> glc = new GLConsumer(consumer, name,

            GL_TEXTURE_EXTERNAL_OES, false, true);

    glc->setDefaultBufferSize(w, h);

    glc->setDefaultMaxBufferCount(3);

    producer->setMaxDequeuedBufferCount(2);

    glc->setConsumerUsageBits(GRALLOC_USAGE_HW_COMPOSER);

    sp<ANativeWindow> anw = new Surface(producer);

    // is 1x1.

    virtual status_t setDefaultBufferSize(uint32_t width, uint32_t height);

    // setDefaultMaxBufferCount sets the default value for the maximum buffer

    // count (the initial default is 2). If the producer has requested a

    // buffer count using setBufferCount, the default buffer count will only

    // take effect if the producer sets the count back to zero.

    //

    // The count must be between 2 and NUM_BUFFER_SLOTS, inclusive.

    virtual status_t setDefaultMaxBufferCount(int bufferCount);

    // disableAsyncBuffer disables the extra buffer used in async mode

    // (when both producer and consumer have set their "isControlledByApp"

    // flag) and has dequeueBuffer() return WOULD_BLOCK instead.

    //

    // This can only be called before connect().

    virtual status_t disableAsyncBuffer();

    // see IGraphicBufferConsumer::setMaxBufferCount

    virtual status_t setMaxBufferCount(int bufferCount);

    // setMaxAcquiredBufferCount sets the maximum number of buffers that can

    // be acquired by the consumer at one time (default 1).  This call will

    // connected, mDequeueCondition must be broadcast.

    int getMaxBufferCountLocked(bool async) const;

    // setDefaultMaxBufferCountLocked sets the maximum number of buffer slots

    // that will be used if the producer does not override the buffer slot

    // count. The count must be between 2 and NUM_BUFFER_SLOTS, inclusive. The

    // initial default is 2.

    status_t setDefaultMaxBufferCountLocked(int count);

    // freeBufferLocked frees the GraphicBuffer and sync resources for the

    // given slot.

    void freeBufferLocked(int slot);

    // synchronous mode.

    mutable Condition mDequeueCondition;

    // mUseAsyncBuffer indicates whether an extra buffer is used in async mode

    // to prevent dequeueBuffer from blocking.

    bool mUseAsyncBuffer;

    // mDequeueBufferCannotBlock indicates whether dequeueBuffer is allowed to

    // block. This flag is set during connect when both the producer and

    // consumer are controlled by the application.

    // is specified.

    android_dataspace mDefaultBufferDataSpace;

    // mDefaultMaxBufferCount is the default limit on the number of buffers that

    // will be allocated at one time. This default limit is set by the consumer.

    // The limit (as opposed to the default limit) may be overriden by the

    // producer.

    int mDefaultMaxBufferCount;

    // mMaxBufferCount is the limit on the number of buffers that will be

    // allocated at one time. This limit can be set by the consumer.

    int mMaxBufferCount;

    // mMaxAcquiredBufferCount is the number of buffers that the consumer may

    // acquire at one time. It defaults to 1, and can be changed by the consumer

    // 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).

    // union fence.

    void setReleaseFence(const sp<Fence>& fence);

    // setDefaultMaxBufferCount sets the default limit on the maximum number

    // of buffers that will be allocated at one time. The image producer may

    // override the limit.

    status_t setDefaultMaxBufferCount(int bufferCount);

    // getTransformMatrix retrieves the 4x4 texture coordinate transform matrix

    // associated with the texture image set by the most recent call to

    // updateTexImage.

    status_t setDefaultBufferDataSpace(android_dataspace defaultDataSpace);

    status_t setConsumerUsageBits(uint32_t usage);

    status_t setTransformHint(uint32_t hint);

    status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers);

    // detachFromContext detaches the GLConsumer from the calling thread's

    // current OpenGL ES context.  This context must be the same as the context

    // * BAD_VALUE - either w or h was zero

    virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h) = 0;

    // setDefaultMaxBufferCount sets the default value for the maximum buffer

    // count (the initial default is 2). If the producer has requested a

    // buffer count using setBufferCount, the default buffer count will only

    // take effect if the producer sets the count back to zero.

    // setMaxBufferCount sets the maximum value for the number of buffers used

    // in the buffer queue (the initial default is NUM_BUFFER_SLOTS). If a call

    // to setMaxAcquiredBufferCount (by the consumer), or a call to setAsyncMode

    // or setMaxDequeuedBufferCount (by the producer), would cause this value to

    // be exceeded then that call will fail. This call will fail if a producer

    // is connected to the BufferQueue.

    //

    // The count must be between 2 and NUM_BUFFER_SLOTS, inclusive.

    // The count must be between 1 and NUM_BUFFER_SLOTS, inclusive. The count

    // cannot be less than maxAcquiredBufferCount.

    //

    // Return of a value other than NO_ERROR means an error has occurred:

    // * BAD_VALUE - bufferCount was out of range (see above).

    virtual status_t setDefaultMaxBufferCount(int bufferCount) = 0;

    // disableAsyncBuffer disables the extra buffer used in async mode

    // (when both producer and consumer have set their "isControlledByApp"

    // flag) and has dequeueBuffer() return WOULD_BLOCK instead.

    //

    // This can only be called before consumerConnect().

    //

    // Return of a value other than NO_ERROR means an error has occurred:

    // * INVALID_OPERATION - attempting to call this after consumerConnect.

    virtual status_t disableAsyncBuffer() = 0;

    // * INVALID_OPERATION - attempting to call this after a producer connected.

    virtual status_t setMaxBufferCount(int bufferCount) = 0;

    // setMaxAcquiredBufferCount sets the maximum number of buffers that can

    // be acquired by the consumer at one time (default 1).  This call will

    // fail if a producer is connected to the BufferQueue.

    //

    // maxAcquiredBuffers must be (inclusive) between 1 and MAX_MAX_ACQUIRED_BUFFERS.

    // maxAcquiredBuffers must be (inclusive) between 1 and

    // MAX_MAX_ACQUIRED_BUFFERS. It also cannot cause the maxBufferCount value

    // to be exceeded.

    //

    // Return of a value other than NO_ERROR means an error has occurred:

    // * BAD_VALUE - maxAcquiredBuffers was out of range (see above).