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 #define LOG_TAG "BufferQueueCore" 18 #define ATRACE_TAG ATRACE_TAG_GRAPHICS 19 //#define LOG_NDEBUG 0 20 21 #define EGL_EGLEXT_PROTOTYPES 22 23 #if DEBUG_ONLY_CODE 24 #define VALIDATE_CONSISTENCY() do { validateConsistencyLocked(); } while (0) 25 #else 26 #define VALIDATE_CONSISTENCY() 27 #endif 28 29 #include <inttypes.h> 30 31 #include <cutils/properties.h> 32 #include <cutils/atomic.h> 33 34 #include <gui/BufferItem.h> 35 #include <gui/BufferQueueCore.h> 36 #include <gui/IConsumerListener.h> 37 #include <gui/IProducerListener.h> 38 #include <gui/ISurfaceComposer.h> 39 #include <private/gui/ComposerService.h> 40 41 #include <system/window.h> 42 43 namespace android { 44 45 static String8 getUniqueName() { 46 static volatile int32_t counter = 0; 47 return String8::format("unnamed-%d-%d", getpid(), 48 android_atomic_inc(&counter)); 49 } 50 51 static uint64_t getUniqueId() { 52 static std::atomic<uint32_t> counter{0}; 53 static uint64_t id = static_cast<uint64_t>(getpid()) << 32; 54 return id | counter++; 55 } 56 57 BufferQueueCore::BufferQueueCore() : 58 mMutex(), 59 mIsAbandoned(false), 60 mConsumerControlledByApp(false), 61 mConsumerName(getUniqueName()), 62 mConsumerListener(), 63 mConsumerUsageBits(0), 64 mConsumerIsProtected(false), 65 mConnectedApi(NO_CONNECTED_API), 66 mLinkedToDeath(), 67 mConnectedProducerListener(), 68 mSlots(), 69 mQueue(), 70 mFreeSlots(), 71 mFreeBuffers(), 72 mUnusedSlots(), 73 mActiveBuffers(), 74 mDequeueCondition(), 75 mDequeueBufferCannotBlock(false), 76 mDefaultBufferFormat(PIXEL_FORMAT_RGBA_8888), 77 mDefaultWidth(1), 78 mDefaultHeight(1), 79 mDefaultBufferDataSpace(HAL_DATASPACE_UNKNOWN), 80 mMaxBufferCount(BufferQueueDefs::NUM_BUFFER_SLOTS), 81 mMaxAcquiredBufferCount(1), 82 mMaxDequeuedBufferCount(1), 83 mBufferHasBeenQueued(false), 84 mFrameCounter(0), 85 mTransformHint(0), 86 mIsAllocating(false), 87 mIsAllocatingCondition(), 88 mAllowAllocation(true), 89 mBufferAge(0), 90 mGenerationNumber(0), 91 mAsyncMode(false), 92 mSharedBufferMode(false), 93 mAutoRefresh(false), 94 mSharedBufferSlot(INVALID_BUFFER_SLOT), 95 mSharedBufferCache(Rect::INVALID_RECT, 0, NATIVE_WINDOW_SCALING_MODE_FREEZE, 96 HAL_DATASPACE_UNKNOWN), 97 mLastQueuedSlot(INVALID_BUFFER_SLOT), 98 mUniqueId(getUniqueId()) 99 { 100 int numStartingBuffers = getMaxBufferCountLocked(); 101 for (int s = 0; s < numStartingBuffers; s++) { 102 mFreeSlots.insert(s); 103 } 104 for (int s = numStartingBuffers; s < BufferQueueDefs::NUM_BUFFER_SLOTS; 105 s++) { 106 mUnusedSlots.push_front(s); 107 } 108 } 109 110 BufferQueueCore::~BufferQueueCore() {} 111 112 void BufferQueueCore::dumpState(const String8& prefix, String8* outResult) const { 113 Mutex::Autolock lock(mMutex); 114 115 outResult->appendFormat("%s- BufferQueue ", prefix.string()); 116 outResult->appendFormat("mMaxAcquiredBufferCount=%d mMaxDequeuedBufferCount=%d\n", 117 mMaxAcquiredBufferCount, mMaxDequeuedBufferCount); 118 outResult->appendFormat("%s mDequeueBufferCannotBlock=%d mAsyncMode=%d\n", prefix.string(), 119 mDequeueBufferCannotBlock, mAsyncMode); 120 outResult->appendFormat("%s default-size=[%dx%d] default-format=%d ", prefix.string(), 121 mDefaultWidth, mDefaultHeight, mDefaultBufferFormat); 122 outResult->appendFormat("transform-hint=%02x frame-counter=%" PRIu64, mTransformHint, 123 mFrameCounter); 124 125 outResult->appendFormat("\n%sFIFO(%zu):\n", prefix.string(), mQueue.size()); 126 Fifo::const_iterator current(mQueue.begin()); 127 while (current != mQueue.end()) { 128 double timestamp = current->mTimestamp / 1e9; 129 outResult->appendFormat("%s %02d:%p ", prefix.string(), current->mSlot, 130 current->mGraphicBuffer.get()); 131 outResult->appendFormat("crop=[%d,%d,%d,%d] ", current->mCrop.left, current->mCrop.top, 132 current->mCrop.right, current->mCrop.bottom); 133 outResult->appendFormat("xform=0x%02x time=%.4f scale=%s\n", current->mTransform, timestamp, 134 BufferItem::scalingModeName(current->mScalingMode)); 135 ++current; 136 } 137 138 outResult->appendFormat("%sSlots:\n", prefix.string()); 139 for (int s : mActiveBuffers) { 140 const sp<GraphicBuffer>& buffer(mSlots[s].mGraphicBuffer); 141 // A dequeued buffer might be null if it's still being allocated 142 if (buffer.get()) { 143 outResult->appendFormat("%s %s[%02d:%p] ", prefix.string(), 144 (mSlots[s].mBufferState.isAcquired()) ? ">" : " ", s, 145 buffer.get()); 146 outResult->appendFormat("state=%-8s %p frame=%" PRIu64, mSlots[s].mBufferState.string(), 147 buffer->handle, mSlots[s].mFrameNumber); 148 outResult->appendFormat(" [%4ux%4u:%4u,%3X]\n", buffer->width, buffer->height, 149 buffer->stride, buffer->format); 150 } else { 151 outResult->appendFormat("%s [%02d:%p] ", prefix.string(), s, buffer.get()); 152 outResult->appendFormat("state=%-8s frame=%" PRIu64 "\n", 153 mSlots[s].mBufferState.string(), mSlots[s].mFrameNumber); 154 } 155 } 156 for (int s : mFreeBuffers) { 157 const sp<GraphicBuffer>& buffer(mSlots[s].mGraphicBuffer); 158 outResult->appendFormat("%s [%02d:%p] ", prefix.string(), s, buffer.get()); 159 outResult->appendFormat("state=%-8s %p frame=%" PRIu64, mSlots[s].mBufferState.string(), 160 buffer->handle, mSlots[s].mFrameNumber); 161 outResult->appendFormat(" [%4ux%4u:%4u,%3X]\n", buffer->width, buffer->height, 162 buffer->stride, buffer->format); 163 } 164 165 for (int s : mFreeSlots) { 166 const sp<GraphicBuffer>& buffer(mSlots[s].mGraphicBuffer); 167 outResult->appendFormat("%s [%02d:%p] state=%-8s\n", prefix.string(), s, buffer.get(), 168 mSlots[s].mBufferState.string()); 169 } 170 } 171 172 int BufferQueueCore::getMinUndequeuedBufferCountLocked() const { 173 // If dequeueBuffer is allowed to error out, we don't have to add an 174 // extra buffer. 175 if (mAsyncMode || mDequeueBufferCannotBlock) { 176 return mMaxAcquiredBufferCount + 1; 177 } 178 179 return mMaxAcquiredBufferCount; 180 } 181 182 int BufferQueueCore::getMinMaxBufferCountLocked() const { 183 return getMinUndequeuedBufferCountLocked() + 1; 184 } 185 186 int BufferQueueCore::getMaxBufferCountLocked(bool asyncMode, 187 bool dequeueBufferCannotBlock, int maxBufferCount) const { 188 int maxCount = mMaxAcquiredBufferCount + mMaxDequeuedBufferCount + 189 ((asyncMode || dequeueBufferCannotBlock) ? 1 : 0); 190 maxCount = std::min(maxBufferCount, maxCount); 191 return maxCount; 192 } 193 194 int BufferQueueCore::getMaxBufferCountLocked() const { 195 int maxBufferCount = mMaxAcquiredBufferCount + mMaxDequeuedBufferCount + 196 ((mAsyncMode || mDequeueBufferCannotBlock) ? 1 : 0); 197 198 // limit maxBufferCount by mMaxBufferCount always 199 maxBufferCount = std::min(mMaxBufferCount, maxBufferCount); 200 201 return maxBufferCount; 202 } 203 204 void BufferQueueCore::clearBufferSlotLocked(int slot) { 205 BQ_LOGV("clearBufferSlotLocked: slot %d", slot); 206 207 mSlots[slot].mGraphicBuffer.clear(); 208 mSlots[slot].mBufferState.reset(); 209 mSlots[slot].mRequestBufferCalled = false; 210 mSlots[slot].mFrameNumber = 0; 211 mSlots[slot].mAcquireCalled = false; 212 mSlots[slot].mNeedsReallocation = true; 213 214 // Destroy fence as BufferQueue now takes ownership 215 if (mSlots[slot].mEglFence != EGL_NO_SYNC_KHR) { 216 eglDestroySyncKHR(mSlots[slot].mEglDisplay, mSlots[slot].mEglFence); 217 mSlots[slot].mEglFence = EGL_NO_SYNC_KHR; 218 } 219 mSlots[slot].mFence = Fence::NO_FENCE; 220 mSlots[slot].mEglDisplay = EGL_NO_DISPLAY; 221 222 if (mLastQueuedSlot == slot) { 223 mLastQueuedSlot = INVALID_BUFFER_SLOT; 224 } 225 } 226 227 void BufferQueueCore::freeAllBuffersLocked() { 228 for (int s : mFreeSlots) { 229 clearBufferSlotLocked(s); 230 } 231 232 for (int s : mFreeBuffers) { 233 mFreeSlots.insert(s); 234 clearBufferSlotLocked(s); 235 } 236 mFreeBuffers.clear(); 237 238 for (int s : mActiveBuffers) { 239 mFreeSlots.insert(s); 240 clearBufferSlotLocked(s); 241 } 242 mActiveBuffers.clear(); 243 244 for (auto& b : mQueue) { 245 b.mIsStale = true; 246 247 // We set this to false to force the BufferQueue to resend the buffer 248 // handle upon acquire, since if we're here due to a producer 249 // disconnect, the consumer will have been told to purge its cache of 250 // slot-to-buffer-handle mappings and will not be able to otherwise 251 // obtain a valid buffer handle. 252 b.mAcquireCalled = false; 253 } 254 255 VALIDATE_CONSISTENCY(); 256 } 257 258 void BufferQueueCore::discardFreeBuffersLocked() { 259 for (int s : mFreeBuffers) { 260 mFreeSlots.insert(s); 261 clearBufferSlotLocked(s); 262 } 263 mFreeBuffers.clear(); 264 265 VALIDATE_CONSISTENCY(); 266 } 267 268 bool BufferQueueCore::adjustAvailableSlotsLocked(int delta) { 269 if (delta >= 0) { 270 // If we're going to fail, do so before modifying anything 271 if (delta > static_cast<int>(mUnusedSlots.size())) { 272 return false; 273 } 274 while (delta > 0) { 275 if (mUnusedSlots.empty()) { 276 return false; 277 } 278 int slot = mUnusedSlots.back(); 279 mUnusedSlots.pop_back(); 280 mFreeSlots.insert(slot); 281 delta--; 282 } 283 } else { 284 // If we're going to fail, do so before modifying anything 285 if (-delta > static_cast<int>(mFreeSlots.size() + 286 mFreeBuffers.size())) { 287 return false; 288 } 289 while (delta < 0) { 290 if (!mFreeSlots.empty()) { 291 auto slot = mFreeSlots.begin(); 292 clearBufferSlotLocked(*slot); 293 mUnusedSlots.push_back(*slot); 294 mFreeSlots.erase(slot); 295 } else if (!mFreeBuffers.empty()) { 296 int slot = mFreeBuffers.back(); 297 clearBufferSlotLocked(slot); 298 mUnusedSlots.push_back(slot); 299 mFreeBuffers.pop_back(); 300 } else { 301 return false; 302 } 303 delta++; 304 } 305 } 306 return true; 307 } 308 309 void BufferQueueCore::waitWhileAllocatingLocked() const { 310 ATRACE_CALL(); 311 while (mIsAllocating) { 312 mIsAllocatingCondition.wait(mMutex); 313 } 314 } 315 316 #if DEBUG_ONLY_CODE 317 void BufferQueueCore::validateConsistencyLocked() const { 318 static const useconds_t PAUSE_TIME = 0; 319 int allocatedSlots = 0; 320 for (int slot = 0; slot < BufferQueueDefs::NUM_BUFFER_SLOTS; ++slot) { 321 bool isInFreeSlots = mFreeSlots.count(slot) != 0; 322 bool isInFreeBuffers = 323 std::find(mFreeBuffers.cbegin(), mFreeBuffers.cend(), slot) != 324 mFreeBuffers.cend(); 325 bool isInActiveBuffers = mActiveBuffers.count(slot) != 0; 326 bool isInUnusedSlots = 327 std::find(mUnusedSlots.cbegin(), mUnusedSlots.cend(), slot) != 328 mUnusedSlots.cend(); 329 330 if (isInFreeSlots || isInFreeBuffers || isInActiveBuffers) { 331 allocatedSlots++; 332 } 333 334 if (isInUnusedSlots) { 335 if (isInFreeSlots) { 336 BQ_LOGE("Slot %d is in mUnusedSlots and in mFreeSlots", slot); 337 usleep(PAUSE_TIME); 338 } 339 if (isInFreeBuffers) { 340 BQ_LOGE("Slot %d is in mUnusedSlots and in mFreeBuffers", slot); 341 usleep(PAUSE_TIME); 342 } 343 if (isInActiveBuffers) { 344 BQ_LOGE("Slot %d is in mUnusedSlots and in mActiveBuffers", 345 slot); 346 usleep(PAUSE_TIME); 347 } 348 if (!mSlots[slot].mBufferState.isFree()) { 349 BQ_LOGE("Slot %d is in mUnusedSlots but is not FREE", slot); 350 usleep(PAUSE_TIME); 351 } 352 if (mSlots[slot].mGraphicBuffer != NULL) { 353 BQ_LOGE("Slot %d is in mUnusedSluts but has an active buffer", 354 slot); 355 usleep(PAUSE_TIME); 356 } 357 } else if (isInFreeSlots) { 358 if (isInUnusedSlots) { 359 BQ_LOGE("Slot %d is in mFreeSlots and in mUnusedSlots", slot); 360 usleep(PAUSE_TIME); 361 } 362 if (isInFreeBuffers) { 363 BQ_LOGE("Slot %d is in mFreeSlots and in mFreeBuffers", slot); 364 usleep(PAUSE_TIME); 365 } 366 if (isInActiveBuffers) { 367 BQ_LOGE("Slot %d is in mFreeSlots and in mActiveBuffers", slot); 368 usleep(PAUSE_TIME); 369 } 370 if (!mSlots[slot].mBufferState.isFree()) { 371 BQ_LOGE("Slot %d is in mFreeSlots but is not FREE", slot); 372 usleep(PAUSE_TIME); 373 } 374 if (mSlots[slot].mGraphicBuffer != NULL) { 375 BQ_LOGE("Slot %d is in mFreeSlots but has a buffer", 376 slot); 377 usleep(PAUSE_TIME); 378 } 379 } else if (isInFreeBuffers) { 380 if (isInUnusedSlots) { 381 BQ_LOGE("Slot %d is in mFreeBuffers and in mUnusedSlots", slot); 382 usleep(PAUSE_TIME); 383 } 384 if (isInFreeSlots) { 385 BQ_LOGE("Slot %d is in mFreeBuffers and in mFreeSlots", slot); 386 usleep(PAUSE_TIME); 387 } 388 if (isInActiveBuffers) { 389 BQ_LOGE("Slot %d is in mFreeBuffers and in mActiveBuffers", 390 slot); 391 usleep(PAUSE_TIME); 392 } 393 if (!mSlots[slot].mBufferState.isFree()) { 394 BQ_LOGE("Slot %d is in mFreeBuffers but is not FREE", slot); 395 usleep(PAUSE_TIME); 396 } 397 if (mSlots[slot].mGraphicBuffer == NULL) { 398 BQ_LOGE("Slot %d is in mFreeBuffers but has no buffer", slot); 399 usleep(PAUSE_TIME); 400 } 401 } else if (isInActiveBuffers) { 402 if (isInUnusedSlots) { 403 BQ_LOGE("Slot %d is in mActiveBuffers and in mUnusedSlots", 404 slot); 405 usleep(PAUSE_TIME); 406 } 407 if (isInFreeSlots) { 408 BQ_LOGE("Slot %d is in mActiveBuffers and in mFreeSlots", slot); 409 usleep(PAUSE_TIME); 410 } 411 if (isInFreeBuffers) { 412 BQ_LOGE("Slot %d is in mActiveBuffers and in mFreeBuffers", 413 slot); 414 usleep(PAUSE_TIME); 415 } 416 if (mSlots[slot].mBufferState.isFree() && 417 !mSlots[slot].mBufferState.isShared()) { 418 BQ_LOGE("Slot %d is in mActiveBuffers but is FREE", slot); 419 usleep(PAUSE_TIME); 420 } 421 if (mSlots[slot].mGraphicBuffer == NULL && !mIsAllocating) { 422 BQ_LOGE("Slot %d is in mActiveBuffers but has no buffer", slot); 423 usleep(PAUSE_TIME); 424 } 425 } else { 426 BQ_LOGE("Slot %d isn't in any of mUnusedSlots, mFreeSlots, " 427 "mFreeBuffers, or mActiveBuffers", slot); 428 usleep(PAUSE_TIME); 429 } 430 } 431 432 if (allocatedSlots != getMaxBufferCountLocked()) { 433 BQ_LOGE("Number of allocated slots is incorrect. Allocated = %d, " 434 "Should be %d (%zu free slots, %zu free buffers, " 435 "%zu activeBuffers, %zu unusedSlots)", allocatedSlots, 436 getMaxBufferCountLocked(), mFreeSlots.size(), 437 mFreeBuffers.size(), mActiveBuffers.size(), 438 mUnusedSlots.size()); 439 } 440 } 441 #endif 442 443 } // namespace android 444
