1/*
2 * Copyright 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_GUI_BUFFERQUEUECORE_H
18#define ANDROID_GUI_BUFFERQUEUECORE_H
19
20#include <gui/BufferQueueDefs.h>
21#include <gui/BufferSlot.h>
22
23#include <utils/Condition.h>
24#include <utils/Mutex.h>
25#include <utils/NativeHandle.h>
26#include <utils/RefBase.h>
27#include <utils/String8.h>
28#include <utils/StrongPointer.h>
29#include <utils/Trace.h>
30#include <utils/Vector.h>
31
32#define BQ_LOGV(x, ...) ALOGV("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
33#define BQ_LOGD(x, ...) ALOGD("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
34#define BQ_LOGI(x, ...) ALOGI("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
35#define BQ_LOGW(x, ...) ALOGW("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
36#define BQ_LOGE(x, ...) ALOGE("[%s] "x, mConsumerName.string(), ##__VA_ARGS__)
37
38#define ATRACE_BUFFER_INDEX(index)                                   \
39    if (ATRACE_ENABLED()) {                                          \
40        char ___traceBuf[1024];                                      \
41        snprintf(___traceBuf, 1024, "%s: %d",                        \
42                mCore->mConsumerName.string(), (index));             \
43        android::ScopedTrace ___bufTracer(ATRACE_TAG, ___traceBuf);  \
44    }
45
46namespace android {
47
48class BufferItem;
49class IConsumerListener;
50class IGraphicBufferAlloc;
51class IProducerListener;
52
53class BufferQueueCore : public virtual RefBase {
54
55    friend class BufferQueueProducer;
56    friend class BufferQueueConsumer;
57
58public:
59    // Used as a placeholder slot number when the value isn't pointing to an
60    // existing buffer.
61    enum { INVALID_BUFFER_SLOT = -1 }; // TODO: Extract from IGBC::BufferItem
62
63    // We reserve two slots in order to guarantee that the producer and
64    // consumer can run asynchronously.
65    enum { MAX_MAX_ACQUIRED_BUFFERS = BufferQueueDefs::NUM_BUFFER_SLOTS - 2 };
66
67    // The default API number used to indicate that no producer is connected
68    enum { NO_CONNECTED_API = 0 };
69
70    typedef Vector<BufferItem> Fifo;
71
72    // BufferQueueCore manages a pool of gralloc memory slots to be used by
73    // producers and consumers. allocator is used to allocate all the needed
74    // gralloc buffers.
75    BufferQueueCore(const sp<IGraphicBufferAlloc>& allocator = NULL);
76    virtual ~BufferQueueCore();
77
78private:
79    // Dump our state in a string
80    void dump(String8& result, const char* prefix) const;
81
82    // getMinUndequeuedBufferCountLocked returns the minimum number of buffers
83    // that must remain in a state other than DEQUEUED. The async parameter
84    // tells whether we're in asynchronous mode.
85    int getMinUndequeuedBufferCountLocked(bool async) const;
86
87    // getMinMaxBufferCountLocked returns the minimum number of buffers allowed
88    // given the current BufferQueue state. The async parameter tells whether
89    // we're in asynchonous mode.
90    int getMinMaxBufferCountLocked(bool async) const;
91
92    // getMaxBufferCountLocked returns the maximum number of buffers that can be
93    // allocated at once. This value depends on the following member variables:
94    //
95    //     mDequeueBufferCannotBlock
96    //     mMaxAcquiredBufferCount
97    //     mDefaultMaxBufferCount
98    //     mOverrideMaxBufferCount
99    //     async parameter
100    //
101    // Any time one of these member variables is changed while a producer is
102    // connected, mDequeueCondition must be broadcast.
103    int getMaxBufferCountLocked(bool async) const;
104
105    // setDefaultMaxBufferCountLocked sets the maximum number of buffer slots
106    // that will be used if the producer does not override the buffer slot
107    // count. The count must be between 2 and NUM_BUFFER_SLOTS, inclusive. The
108    // initial default is 2.
109    status_t setDefaultMaxBufferCountLocked(int count);
110
111    // freeBufferLocked frees the GraphicBuffer and sync resources for the
112    // given slot.
113    void freeBufferLocked(int slot);
114
115    // freeAllBuffersLocked frees the GraphicBuffer and sync resources for
116    // all slots.
117    void freeAllBuffersLocked();
118
119    // stillTracking returns true iff the buffer item is still being tracked
120    // in one of the slots.
121    bool stillTracking(const BufferItem* item) const;
122
123    // waitWhileAllocatingLocked blocks until mIsAllocating is false.
124    void waitWhileAllocatingLocked() const;
125
126    // mAllocator is the connection to SurfaceFlinger that is used to allocate
127    // new GraphicBuffer objects.
128    sp<IGraphicBufferAlloc> mAllocator;
129
130    // mMutex is the mutex used to prevent concurrent access to the member
131    // variables of BufferQueueCore objects. It must be locked whenever any
132    // member variable is accessed.
133    mutable Mutex mMutex;
134
135    // mIsAbandoned indicates that the BufferQueue will no longer be used to
136    // consume image buffers pushed to it using the IGraphicBufferProducer
137    // interface. It is initialized to false, and set to true in the
138    // consumerDisconnect method. A BufferQueue that is abandoned will return
139    // the NO_INIT error from all IGraphicBufferProducer methods capable of
140    // returning an error.
141    bool mIsAbandoned;
142
143    // mConsumerControlledByApp indicates whether the connected consumer is
144    // controlled by the application.
145    bool mConsumerControlledByApp;
146
147    // mConsumerName is a string used to identify the BufferQueue in log
148    // messages. It is set by the IGraphicBufferConsumer::setConsumerName
149    // method.
150    String8 mConsumerName;
151
152    // mConsumerListener is used to notify the connected consumer of
153    // asynchronous events that it may wish to react to. It is initially
154    // set to NULL and is written by consumerConnect and consumerDisconnect.
155    sp<IConsumerListener> mConsumerListener;
156
157    // mConsumerUsageBits contains flags that the consumer wants for
158    // GraphicBuffers.
159    uint32_t mConsumerUsageBits;
160
161    // mConnectedApi indicates the producer API that is currently connected
162    // to this BufferQueue. It defaults to NO_CONNECTED_API, and gets updated
163    // by the connect and disconnect methods.
164    int mConnectedApi;
165
166    // mConnectedProducerToken is used to set a binder death notification on
167    // the producer.
168    sp<IProducerListener> mConnectedProducerListener;
169
170    // mSlots is an array of buffer slots that must be mirrored on the producer
171    // side. This allows buffer ownership to be transferred between the producer
172    // and consumer without sending a GraphicBuffer over Binder. The entire
173    // array is initialized to NULL at construction time, and buffers are
174    // allocated for a slot when requestBuffer is called with that slot's index.
175    BufferQueueDefs::SlotsType mSlots;
176
177    // mQueue is a FIFO of queued buffers used in synchronous mode.
178    Fifo mQueue;
179
180    // mOverrideMaxBufferCount is the limit on the number of buffers that will
181    // be allocated at one time. This value is set by the producer by calling
182    // setBufferCount. The default is 0, which means that the producer doesn't
183    // care about the number of buffers in the pool. In that case,
184    // mDefaultMaxBufferCount is used as the limit.
185    int mOverrideMaxBufferCount;
186
187    // mDequeueCondition is a condition variable used for dequeueBuffer in
188    // synchronous mode.
189    mutable Condition mDequeueCondition;
190
191    // mUseAsyncBuffer indicates whether an extra buffer is used in async mode
192    // to prevent dequeueBuffer from blocking.
193    bool mUseAsyncBuffer;
194
195    // mDequeueBufferCannotBlock indicates whether dequeueBuffer is allowed to
196    // block. This flag is set during connect when both the producer and
197    // consumer are controlled by the application.
198    bool mDequeueBufferCannotBlock;
199
200    // mDefaultBufferFormat can be set so it will override the buffer format
201    // when it isn't specified in dequeueBuffer.
202    uint32_t mDefaultBufferFormat;
203
204    // mDefaultWidth holds the default width of allocated buffers. It is used
205    // in dequeueBuffer if a width and height of 0 are specified.
206    int mDefaultWidth;
207
208    // mDefaultHeight holds the default height of allocated buffers. It is used
209    // in dequeueBuffer if a width and height of 0 are specified.
210    int mDefaultHeight;
211
212    // mDefaultMaxBufferCount is the default limit on the number of buffers that
213    // will be allocated at one time. This default limit is set by the consumer.
214    // The limit (as opposed to the default limit) may be overriden by the
215    // producer.
216    int mDefaultMaxBufferCount;
217
218    // mMaxAcquiredBufferCount is the number of buffers that the consumer may
219    // acquire at one time. It defaults to 1, and can be changed by the consumer
220    // via setMaxAcquiredBufferCount, but this may only be done while no
221    // producer is connected to the BufferQueue. This value is used to derive
222    // the value returned for the MIN_UNDEQUEUED_BUFFERS query to the producer.
223    int mMaxAcquiredBufferCount;
224
225    // mBufferHasBeenQueued is true once a buffer has been queued. It is reset
226    // when something causes all buffers to be freed (e.g., changing the buffer
227    // count).
228    bool mBufferHasBeenQueued;
229
230    // mFrameCounter is the free running counter, incremented on every
231    // successful queueBuffer call and buffer allocation.
232    uint64_t mFrameCounter;
233
234    // mTransformHint is used to optimize for screen rotations.
235    uint32_t mTransformHint;
236
237    // mSidebandStream is a handle to the sideband buffer stream, if any
238    sp<NativeHandle> mSidebandStream;
239
240    // mIsAllocating indicates whether a producer is currently trying to allocate buffers (which
241    // releases mMutex while doing the allocation proper). Producers should not modify any of the
242    // FREE slots while this is true. mIsAllocatingCondition is signaled when this value changes to
243    // false.
244    bool mIsAllocating;
245
246    // mIsAllocatingCondition is a condition variable used by producers to wait until mIsAllocating
247    // becomes false.
248    mutable Condition mIsAllocatingCondition;
249}; // class BufferQueueCore
250
251} // namespace android
252
253#endif
254