Rename single buffer mode to shared buffer mode

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

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

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

    // in single buffer mode.

    // in shared buffer mode.

    bool mAutoRefresh;

    bool mAutoRefresh;

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

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

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

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

    bool mQueuedBuffer;

    bool mQueuedBuffer;

    // enqueue buffers without blocking.

    // enqueue buffers without blocking.

    bool mAsyncMode;

    bool mAsyncMode;

    // mSingleBufferMode indicates whether or not single buffer mode is enabled.

    // mSharedBufferMode indicates whether or not shared buffer mode is enabled.

    bool mSingleBufferMode;

    bool mSharedBufferMode;

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

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

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

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

    // available.

    // available.

    bool mAutoRefresh;

    bool mAutoRefresh;

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

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

    // shared buffer.

    // shared buffer.

    int mSingleBufferSlot;

    int mSharedBufferSlot;

    // Cached data about the shared buffer in single buffer mode

    // Cached data about the shared buffer in shared buffer mode

    struct SingleBufferCache {

    struct SharedBufferCache {

        SingleBufferCache(Rect _crop, uint32_t _transform, int _scalingMode,

        SharedBufferCache(Rect _crop, uint32_t _transform, int _scalingMode,

                android_dataspace _dataspace)

                android_dataspace _dataspace)

        : crop(_crop),

        : crop(_crop),

          transform(_transform),

          transform(_transform),

        uint32_t transform;

        uint32_t transform;

        uint32_t scalingMode;

        uint32_t scalingMode;

        android_dataspace dataspace;

        android_dataspace dataspace;

    } mSingleBufferCache;

    } mSharedBufferCache;

}; // class BufferQueueCore

}; // class BufferQueueCore

    // See IGraphicBufferProducer::getNextFrameNumber

    // See IGraphicBufferProducer::getNextFrameNumber

    virtual uint64_t getNextFrameNumber() const override;

    virtual uint64_t getNextFrameNumber() const override;

    // See IGraphicBufferProducer::setSingleBufferMode

    // See IGraphicBufferProducer::setSharedBufferMode

    virtual status_t setSingleBufferMode(bool singleBufferMode) override;

    virtual status_t setSharedBufferMode(bool sharedBufferMode) override;

    // See IGraphicBufferProducer::setAutoRefresh

    // See IGraphicBufferProducer::setAutoRefresh

    virtual status_t setAutoRefresh(bool autoRefresh) override;

    virtual status_t setAutoRefresh(bool autoRefresh) override;

    // transitions to FREE when releaseBuffer (or detachBuffer) is called. A

    // transitions to FREE when releaseBuffer (or detachBuffer) is called. A

    // detached buffer can also enter the ACQUIRED state via attachBuffer.

    // detached buffer can also enter the ACQUIRED state via attachBuffer.

    //

    //

    // SHARED indicates that this buffer is being used in single-buffer

    // SHARED indicates that this buffer is being used in shared buffer

    // mode. It can be in any combination of the other states at the same time,

    // mode. It can be in any combination of the other states at the same time,

    // except for FREE (since that excludes being in any other state). It can

    // except for FREE (since that excludes being in any other state). It can

    // also be dequeued, queued, or acquired multiple times.

    // also be dequeued, queued, or acquired multiple times.

    // Returns the number of the next frame which will be dequeued.

    // Returns the number of the next frame which will be dequeued.

    virtual uint64_t getNextFrameNumber() const = 0;

    virtual uint64_t getNextFrameNumber() const = 0;

    // Used to enable/disable single buffer mode.

    // Used to enable/disable shared buffer mode.

    //

    //

    // When single buffer mode is enabled the first buffer that is queued or

    // When shared buffer mode is enabled the first buffer that is queued or

    // dequeued will be cached and returned to all subsequent calls to

    // dequeued will be cached and returned to all subsequent calls to

    // dequeueBuffer and acquireBuffer. This allows the producer and consumer to

    // dequeueBuffer and acquireBuffer. This allows the producer and consumer to

    // simultaneously access the same buffer.

    // simultaneously access the same buffer.

    virtual status_t setSingleBufferMode(bool singleBufferMode) = 0;

    virtual status_t setSharedBufferMode(bool sharedBufferMode) = 0;

    // Used to enable/disable auto-refresh.

    // Used to enable/disable auto-refresh.

    //

    //

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

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

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

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

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

    // available.

    // available.