Merge "Add a BufferItem parameter to onFrameAvailable" into lmp-mr1-dev

    // The default value of mBuf, used to indicate this doesn't correspond to a slot.

    enum { INVALID_BUFFER_SLOT = -1 };

    BufferItem();

    ~BufferItem();

    operator IGraphicBufferConsumer::BufferItem() const;

    static const char* scalingModeName(uint32_t scalingMode);

    public:

        ProxyConsumerListener(const wp<ConsumerListener>& consumerListener);

        virtual ~ProxyConsumerListener();

        virtual void onFrameAvailable();

        virtual void onFrameAvailable(const android::BufferItem& item);

        virtual void onBuffersReleased();

        virtual void onSidebandStreamChanged();

    private:

    // since the previous buffer might have already been acquired.

    sp<Fence> mLastQueueBufferFence;

    // Take-a-ticket system for ensuring that onFrame* callbacks are called in

    // the order that frames are queued. While the BufferQueue lock

    // (mCore->mMutex) is held, a ticket is retained by the producer. After

    // dropping the BufferQueue lock, the producer must wait on the condition

    // variable until the current callback ticket matches its retained ticket.

    Mutex mCallbackMutex;

    int mNextCallbackTicket; // Protected by mCore->mMutex

    int mCurrentCallbackTicket; // Protected by mCallbackMutex

    Condition mCallbackCondition;

}; // class BufferQueueProducer

} // namespace android

        //

        // This is called without any lock held and can be called concurrently

        // by multiple threads.

        virtual void onFrameAvailable() = 0;

        virtual void onFrameAvailable(const BufferItem& item) = 0;

    };

    virtual ~ConsumerBase();

    // the ConsumerBase implementation must be called from the derived class.

    // The ConsumerBase version of onSidebandStreamChanged does nothing and can

    // be overriden by derived classes if they want the notification.

    virtual void onFrameAvailable();

    virtual void onFrameAvailable(const BufferItem& item);

    virtual void onBuffersReleased();

    virtual void onSidebandStreamChanged();

namespace android {

// ----------------------------------------------------------------------------

class BufferItem;

// ConsumerListener is the interface through which the BufferQueue notifies

// the consumer of events that the consumer may wish to react to.  Because

// the consumer will generally have a mutex that is locked during calls from

    // frame becomes available for consumption. This means that frames that

    // are queued while in asynchronous mode only trigger the callback if no

    // previous frames are pending. Frames queued while in synchronous mode

    // always trigger the callback.

    // always trigger the callback. The item passed to the callback will contain

    // all of the information about the queued frame except for its

    // GraphicBuffer pointer, which will always be null.

    //

    // This is called without any lock held and can be called concurrently

    // by multiple threads.

    virtual void onFrameAvailable(const BufferItem& item) = 0; /* Asynchronous */

    // onFrameReplaced is called from queueBuffer if the frame being queued is

    // replacing an existing slot in the queue. Any call to queueBuffer that

    // doesn't call onFrameAvailable will call this callback instead. The item

    // passed to the callback will contain all of the information about the

    // queued frame except for its GraphicBuffer pointer, which will always be

    // null.

    //

    // This is called without any lock held and can be called concurrently

    // by multiple threads.

    virtual void onFrameAvailable() = 0; /* Asynchronous */

    virtual void onFrameReplaced(const BufferItem& item) {} /* Asynchronous */

    // onBuffersReleased is called to notify the buffer consumer that the

    // BufferQueue has released its references to one or more GraphicBuffers