Merge "Add interface for controlling single buffer auto refresh" into nyc-dev

    // previous frame

    Region mSurfaceDamage;

    // Indicates that the BufferQueue is in single buffer mode

    bool mSingleBufferMode;

    // Indicates that the consumer should acquire the next frame as soon as it

    // can and not wait for a frame to become available. This is only relevant

    // in single buffer mode.

    bool mAutoRefresh;

    // Indicates that this buffer was queued by the producer. When in single

    // buffer mode acquire() can return a BufferItem that wasn't in the queue.

    // consumer and producer to access the same buffer simultaneously.

    bool mSingleBufferMode;

    // When single buffer mode is enabled, this indicates whether the consumer

    // should acquire buffers even if BufferQueue doesn't indicate that they are

    // available.

    bool mAutoRefresh;

    // When single buffer mode is enabled, this tracks which slot contains the

    // shared buffer.

    int mSingleBufferSlot;

    // See IGraphicBufferProducer::setSingleBufferMode

    virtual status_t setSingleBufferMode(bool singleBufferMode) override;

    // See IGraphicBufferProducer::setAutoRefresh

    virtual status_t setAutoRefresh(bool autoRefresh) override;

    // See IGraphicBufferProducer::setDequeueTimeout

    virtual status_t setDequeueTimeout(nsecs_t timeout) override;

    // the producer and consumer to simultaneously access the same buffer.

    virtual status_t setSingleBufferMode(bool singleBufferMode) = 0;

    // Used to enable/disable auto-refresh.

    //

    // Auto refresh has no effect outside of single buffer mode. In single

    // buffer mode, when enabled, it indicates to the consumer that it should

    // attempt to acquire buffers even if it is not aware of any being

    // available.

    virtual status_t setAutoRefresh(bool autoRefresh) = 0;

    // Sets how long dequeueBuffer will wait for a buffer to become available

    // before returning an error (TIMED_OUT).

    //

    int dispatchSetBuffersDataSpace(va_list args);

    int dispatchSetSurfaceDamage(va_list args);

    int dispatchSetSingleBufferMode(va_list args);

    int dispatchSetAutoRefresh(va_list args);

protected:

    virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);

    virtual int setMaxDequeuedBufferCount(int maxDequeuedBuffers);

    virtual int setAsyncMode(bool async);

    virtual int setSingleBufferMode(bool singleBufferMode);

    virtual int setAutoRefresh(bool autoRefresh);

    virtual int lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds);

    virtual int unlockAndPost();

    // Stores the current generation number. See setGenerationNumber and

    // IGraphicBufferProducer::setGenerationNumber for more information.

    uint32_t mGenerationNumber;

    // Caches the values that have been passed to the producer.

    bool mSingleBufferMode;

    bool mAutoRefresh;

    // If in single buffer mode and auto refresh is enabled, store the shared

    // buffer slot and return it for all calls to queue/dequeue without going

    // over Binder.

    int mSharedBufferSlot;

    // This is true if the shared buffer has already been queued/canceled. It's

    // used to prevent a mismatch between the number of queue/dequeue calls.

    bool mSharedBufferHasBeenQueued;

};

}; // namespace android