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 46 namespace android { 47 48 class BufferItem; 49 class IConsumerListener; 50 class IGraphicBufferAlloc; 51 class IProducerListener; 52 53 class BufferQueueCore : public virtual RefBase { 54 55 friend class BufferQueueProducer; 56 friend class BufferQueueConsumer; 57 58 public: 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 78 private: 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