BufferQueueProducer.cpp revision 907e94d3da1215328fe3a5020cd5005e42499eba
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#include <inttypes.h> 18 19#define LOG_TAG "BufferQueueProducer" 20#define ATRACE_TAG ATRACE_TAG_GRAPHICS 21//#define LOG_NDEBUG 0 22 23#if DEBUG_ONLY_CODE 24#define VALIDATE_CONSISTENCY() do { mCore->validateConsistencyLocked(); } while (0) 25#else 26#define VALIDATE_CONSISTENCY() 27#endif 28 29#define EGL_EGLEXT_PROTOTYPES 30 31#include <gui/BufferItem.h> 32#include <gui/BufferQueueCore.h> 33#include <gui/BufferQueueProducer.h> 34#include <gui/GLConsumer.h> 35#include <gui/IConsumerListener.h> 36#include <gui/IGraphicBufferAlloc.h> 37#include <gui/IProducerListener.h> 38 39#include <utils/Log.h> 40#include <utils/Trace.h> 41 42namespace android { 43 44BufferQueueProducer::BufferQueueProducer(const sp<BufferQueueCore>& core) : 45 mCore(core), 46 mSlots(core->mSlots), 47 mConsumerName(), 48 mStickyTransform(0), 49 mLastQueueBufferFence(Fence::NO_FENCE), 50 mCallbackMutex(), 51 mNextCallbackTicket(0), 52 mCurrentCallbackTicket(0), 53 mCallbackCondition(), 54 mDequeueTimeout(-1) {} 55 56BufferQueueProducer::~BufferQueueProducer() {} 57 58status_t BufferQueueProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) { 59 ATRACE_CALL(); 60 BQ_LOGV("requestBuffer: slot %d", slot); 61 Mutex::Autolock lock(mCore->mMutex); 62 63 if (mCore->mIsAbandoned) { 64 BQ_LOGE("requestBuffer: BufferQueue has been abandoned"); 65 return NO_INIT; 66 } 67 68 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 69 BQ_LOGE("requestBuffer: BufferQueue has no connected producer"); 70 return NO_INIT; 71 } 72 73 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 74 BQ_LOGE("requestBuffer: slot index %d out of range [0, %d)", 75 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 76 return BAD_VALUE; 77 } else if (!mSlots[slot].mBufferState.isDequeued()) { 78 BQ_LOGE("requestBuffer: slot %d is not owned by the producer " 79 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 80 return BAD_VALUE; 81 } 82 83 mSlots[slot].mRequestBufferCalled = true; 84 *buf = mSlots[slot].mGraphicBuffer; 85 return NO_ERROR; 86} 87 88status_t BufferQueueProducer::setMaxDequeuedBufferCount( 89 int maxDequeuedBuffers) { 90 ATRACE_CALL(); 91 BQ_LOGV("setMaxDequeuedBufferCount: maxDequeuedBuffers = %d", 92 maxDequeuedBuffers); 93 94 sp<IConsumerListener> listener; 95 { // Autolock scope 96 Mutex::Autolock lock(mCore->mMutex); 97 mCore->waitWhileAllocatingLocked(); 98 99 if (mCore->mIsAbandoned) { 100 BQ_LOGE("setMaxDequeuedBufferCount: BufferQueue has been " 101 "abandoned"); 102 return NO_INIT; 103 } 104 105 if (maxDequeuedBuffers == mCore->mMaxDequeuedBufferCount) { 106 return NO_ERROR; 107 } 108 109 // The new maxDequeuedBuffer count should not be violated by the number 110 // of currently dequeued buffers 111 int dequeuedCount = 0; 112 for (int s : mCore->mActiveBuffers) { 113 if (mSlots[s].mBufferState.isDequeued()) { 114 dequeuedCount++; 115 } 116 } 117 if (dequeuedCount > maxDequeuedBuffers) { 118 BQ_LOGE("setMaxDequeuedBufferCount: the requested maxDequeuedBuffer" 119 "count (%d) exceeds the current dequeued buffer count (%d)", 120 maxDequeuedBuffers, dequeuedCount); 121 return BAD_VALUE; 122 } 123 124 int bufferCount = mCore->getMinUndequeuedBufferCountLocked(); 125 bufferCount += maxDequeuedBuffers; 126 127 if (bufferCount > BufferQueueDefs::NUM_BUFFER_SLOTS) { 128 BQ_LOGE("setMaxDequeuedBufferCount: bufferCount %d too large " 129 "(max %d)", bufferCount, BufferQueueDefs::NUM_BUFFER_SLOTS); 130 return BAD_VALUE; 131 } 132 133 const int minBufferSlots = mCore->getMinMaxBufferCountLocked(); 134 if (bufferCount < minBufferSlots) { 135 BQ_LOGE("setMaxDequeuedBufferCount: requested buffer count %d is " 136 "less than minimum %d", bufferCount, minBufferSlots); 137 return BAD_VALUE; 138 } 139 140 if (bufferCount > mCore->mMaxBufferCount) { 141 BQ_LOGE("setMaxDequeuedBufferCount: %d dequeued buffers would " 142 "exceed the maxBufferCount (%d) (maxAcquired %d async %d " 143 "mDequeuedBufferCannotBlock %d)", maxDequeuedBuffers, 144 mCore->mMaxBufferCount, mCore->mMaxAcquiredBufferCount, 145 mCore->mAsyncMode, mCore->mDequeueBufferCannotBlock); 146 return BAD_VALUE; 147 } 148 149 int delta = maxDequeuedBuffers - mCore->mMaxDequeuedBufferCount; 150 if (!mCore->adjustAvailableSlotsLocked(delta)) { 151 return BAD_VALUE; 152 } 153 mCore->mMaxDequeuedBufferCount = maxDequeuedBuffers; 154 VALIDATE_CONSISTENCY(); 155 if (delta < 0) { 156 listener = mCore->mConsumerListener; 157 } 158 mCore->mDequeueCondition.broadcast(); 159 } // Autolock scope 160 161 // Call back without lock held 162 if (listener != NULL) { 163 listener->onBuffersReleased(); 164 } 165 166 return NO_ERROR; 167} 168 169status_t BufferQueueProducer::setAsyncMode(bool async) { 170 ATRACE_CALL(); 171 BQ_LOGV("setAsyncMode: async = %d", async); 172 173 sp<IConsumerListener> listener; 174 { // Autolock scope 175 Mutex::Autolock lock(mCore->mMutex); 176 mCore->waitWhileAllocatingLocked(); 177 178 if (mCore->mIsAbandoned) { 179 BQ_LOGE("setAsyncMode: BufferQueue has been abandoned"); 180 return NO_INIT; 181 } 182 183 if (async == mCore->mAsyncMode) { 184 return NO_ERROR; 185 } 186 187 if ((mCore->mMaxAcquiredBufferCount + mCore->mMaxDequeuedBufferCount + 188 (async || mCore->mDequeueBufferCannotBlock ? 1 : 0)) > 189 mCore->mMaxBufferCount) { 190 BQ_LOGE("setAsyncMode(%d): this call would cause the " 191 "maxBufferCount (%d) to be exceeded (maxAcquired %d " 192 "maxDequeued %d mDequeueBufferCannotBlock %d)", async, 193 mCore->mMaxBufferCount, mCore->mMaxAcquiredBufferCount, 194 mCore->mMaxDequeuedBufferCount, 195 mCore->mDequeueBufferCannotBlock); 196 return BAD_VALUE; 197 } 198 199 int delta = mCore->getMaxBufferCountLocked(async, 200 mCore->mDequeueBufferCannotBlock, mCore->mMaxBufferCount) 201 - mCore->getMaxBufferCountLocked(); 202 203 if (!mCore->adjustAvailableSlotsLocked(delta)) { 204 BQ_LOGE("setAsyncMode: BufferQueue failed to adjust the number of " 205 "available slots. Delta = %d", delta); 206 return BAD_VALUE; 207 } 208 mCore->mAsyncMode = async; 209 VALIDATE_CONSISTENCY(); 210 mCore->mDequeueCondition.broadcast(); 211 if (delta < 0) { 212 listener = mCore->mConsumerListener; 213 } 214 } // Autolock scope 215 216 // Call back without lock held 217 if (listener != NULL) { 218 listener->onBuffersReleased(); 219 } 220 return NO_ERROR; 221} 222 223int BufferQueueProducer::getFreeBufferLocked() const { 224 if (mCore->mFreeBuffers.empty()) { 225 return BufferQueueCore::INVALID_BUFFER_SLOT; 226 } 227 int slot = mCore->mFreeBuffers.front(); 228 mCore->mFreeBuffers.pop_front(); 229 return slot; 230} 231 232int BufferQueueProducer::getFreeSlotLocked() const { 233 if (mCore->mFreeSlots.empty()) { 234 return BufferQueueCore::INVALID_BUFFER_SLOT; 235 } 236 int slot = *(mCore->mFreeSlots.begin()); 237 mCore->mFreeSlots.erase(slot); 238 return slot; 239} 240 241status_t BufferQueueProducer::waitForFreeSlotThenRelock(FreeSlotCaller caller, 242 int* found) const { 243 auto callerString = (caller == FreeSlotCaller::Dequeue) ? 244 "dequeueBuffer" : "attachBuffer"; 245 bool tryAgain = true; 246 while (tryAgain) { 247 if (mCore->mIsAbandoned) { 248 BQ_LOGE("%s: BufferQueue has been abandoned", callerString); 249 return NO_INIT; 250 } 251 252 int dequeuedCount = 0; 253 int acquiredCount = 0; 254 for (int s : mCore->mActiveBuffers) { 255 if (mSlots[s].mBufferState.isDequeued()) { 256 ++dequeuedCount; 257 } 258 if (mSlots[s].mBufferState.isAcquired()) { 259 ++acquiredCount; 260 } 261 } 262 263 // Producers are not allowed to dequeue more than 264 // mMaxDequeuedBufferCount buffers. 265 // This check is only done if a buffer has already been queued 266 if (mCore->mBufferHasBeenQueued && 267 dequeuedCount >= mCore->mMaxDequeuedBufferCount) { 268 BQ_LOGE("%s: attempting to exceed the max dequeued buffer count " 269 "(%d)", callerString, mCore->mMaxDequeuedBufferCount); 270 return INVALID_OPERATION; 271 } 272 273 *found = BufferQueueCore::INVALID_BUFFER_SLOT; 274 275 // If we disconnect and reconnect quickly, we can be in a state where 276 // our slots are empty but we have many buffers in the queue. This can 277 // cause us to run out of memory if we outrun the consumer. Wait here if 278 // it looks like we have too many buffers queued up. 279 const int maxBufferCount = mCore->getMaxBufferCountLocked(); 280 bool tooManyBuffers = mCore->mQueue.size() 281 > static_cast<size_t>(maxBufferCount); 282 if (tooManyBuffers) { 283 BQ_LOGV("%s: queue size is %zu, waiting", callerString, 284 mCore->mQueue.size()); 285 } else { 286 // If in shared buffer mode and a shared buffer exists, always 287 // return it. 288 if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot != 289 BufferQueueCore::INVALID_BUFFER_SLOT) { 290 *found = mCore->mSharedBufferSlot; 291 } else { 292 if (caller == FreeSlotCaller::Dequeue) { 293 // If we're calling this from dequeue, prefer free buffers 294 int slot = getFreeBufferLocked(); 295 if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) { 296 *found = slot; 297 } else if (mCore->mAllowAllocation) { 298 *found = getFreeSlotLocked(); 299 } 300 } else { 301 // If we're calling this from attach, prefer free slots 302 int slot = getFreeSlotLocked(); 303 if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) { 304 *found = slot; 305 } else { 306 *found = getFreeBufferLocked(); 307 } 308 } 309 } 310 } 311 312 // If no buffer is found, or if the queue has too many buffers 313 // outstanding, wait for a buffer to be acquired or released, or for the 314 // max buffer count to change. 315 tryAgain = (*found == BufferQueueCore::INVALID_BUFFER_SLOT) || 316 tooManyBuffers; 317 if (tryAgain) { 318 // Return an error if we're in non-blocking mode (producer and 319 // consumer are controlled by the application). 320 // However, the consumer is allowed to briefly acquire an extra 321 // buffer (which could cause us to have to wait here), which is 322 // okay, since it is only used to implement an atomic acquire + 323 // release (e.g., in GLConsumer::updateTexImage()) 324 if ((mCore->mDequeueBufferCannotBlock || mCore->mAsyncMode) && 325 (acquiredCount <= mCore->mMaxAcquiredBufferCount)) { 326 return WOULD_BLOCK; 327 } 328 if (mDequeueTimeout >= 0) { 329 status_t result = mCore->mDequeueCondition.waitRelative( 330 mCore->mMutex, mDequeueTimeout); 331 if (result == TIMED_OUT) { 332 return result; 333 } 334 } else { 335 mCore->mDequeueCondition.wait(mCore->mMutex); 336 } 337 } 338 } // while (tryAgain) 339 340 return NO_ERROR; 341} 342 343status_t BufferQueueProducer::dequeueBuffer(int *outSlot, 344 sp<android::Fence> *outFence, uint32_t width, uint32_t height, 345 PixelFormat format, uint32_t usage) { 346 ATRACE_CALL(); 347 { // Autolock scope 348 Mutex::Autolock lock(mCore->mMutex); 349 mConsumerName = mCore->mConsumerName; 350 351 if (mCore->mIsAbandoned) { 352 BQ_LOGE("dequeueBuffer: BufferQueue has been abandoned"); 353 return NO_INIT; 354 } 355 356 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 357 BQ_LOGE("dequeueBuffer: BufferQueue has no connected producer"); 358 return NO_INIT; 359 } 360 } // Autolock scope 361 362 BQ_LOGV("dequeueBuffer: w=%u h=%u format=%#x, usage=%#x", width, height, 363 format, usage); 364 365 if ((width && !height) || (!width && height)) { 366 BQ_LOGE("dequeueBuffer: invalid size: w=%u h=%u", width, height); 367 return BAD_VALUE; 368 } 369 370 status_t returnFlags = NO_ERROR; 371 EGLDisplay eglDisplay = EGL_NO_DISPLAY; 372 EGLSyncKHR eglFence = EGL_NO_SYNC_KHR; 373 bool attachedByConsumer = false; 374 375 { // Autolock scope 376 Mutex::Autolock lock(mCore->mMutex); 377 mCore->waitWhileAllocatingLocked(); 378 379 if (format == 0) { 380 format = mCore->mDefaultBufferFormat; 381 } 382 383 // Enable the usage bits the consumer requested 384 usage |= mCore->mConsumerUsageBits; 385 386 const bool useDefaultSize = !width && !height; 387 if (useDefaultSize) { 388 width = mCore->mDefaultWidth; 389 height = mCore->mDefaultHeight; 390 } 391 392 int found = BufferItem::INVALID_BUFFER_SLOT; 393 while (found == BufferItem::INVALID_BUFFER_SLOT) { 394 status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Dequeue, 395 &found); 396 if (status != NO_ERROR) { 397 return status; 398 } 399 400 // This should not happen 401 if (found == BufferQueueCore::INVALID_BUFFER_SLOT) { 402 BQ_LOGE("dequeueBuffer: no available buffer slots"); 403 return -EBUSY; 404 } 405 406 const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer); 407 408 // If we are not allowed to allocate new buffers, 409 // waitForFreeSlotThenRelock must have returned a slot containing a 410 // buffer. If this buffer would require reallocation to meet the 411 // requested attributes, we free it and attempt to get another one. 412 if (!mCore->mAllowAllocation) { 413 if (buffer->needsReallocation(width, height, format, usage)) { 414 if (mCore->mSharedBufferSlot == found) { 415 BQ_LOGE("dequeueBuffer: cannot re-allocate a shared" 416 "buffer"); 417 return BAD_VALUE; 418 } 419 mCore->mFreeSlots.insert(found); 420 mCore->clearBufferSlotLocked(found); 421 found = BufferItem::INVALID_BUFFER_SLOT; 422 continue; 423 } 424 } 425 } 426 427 const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer); 428 if (mCore->mSharedBufferSlot == found && 429 buffer->needsReallocation(width, height, format, usage)) { 430 BQ_LOGE("dequeueBuffer: cannot re-allocate a shared" 431 "buffer"); 432 433 return BAD_VALUE; 434 } 435 436 if (mCore->mSharedBufferSlot != found) { 437 mCore->mActiveBuffers.insert(found); 438 } 439 *outSlot = found; 440 ATRACE_BUFFER_INDEX(found); 441 442 attachedByConsumer = mSlots[found].mNeedsReallocation; 443 mSlots[found].mNeedsReallocation = false; 444 445 mSlots[found].mBufferState.dequeue(); 446 447 if ((buffer == NULL) || 448 buffer->needsReallocation(width, height, format, usage)) 449 { 450 mSlots[found].mAcquireCalled = false; 451 mSlots[found].mGraphicBuffer = NULL; 452 mSlots[found].mRequestBufferCalled = false; 453 mSlots[found].mEglDisplay = EGL_NO_DISPLAY; 454 mSlots[found].mEglFence = EGL_NO_SYNC_KHR; 455 mSlots[found].mFence = Fence::NO_FENCE; 456 mCore->mBufferAge = 0; 457 mCore->mIsAllocating = true; 458 459 returnFlags |= BUFFER_NEEDS_REALLOCATION; 460 } else { 461 // We add 1 because that will be the frame number when this buffer 462 // is queued 463 mCore->mBufferAge = 464 mCore->mFrameCounter + 1 - mSlots[found].mFrameNumber; 465 } 466 467 BQ_LOGV("dequeueBuffer: setting buffer age to %" PRIu64, 468 mCore->mBufferAge); 469 470 if (CC_UNLIKELY(mSlots[found].mFence == NULL)) { 471 BQ_LOGE("dequeueBuffer: about to return a NULL fence - " 472 "slot=%d w=%d h=%d format=%u", 473 found, buffer->width, buffer->height, buffer->format); 474 } 475 476 eglDisplay = mSlots[found].mEglDisplay; 477 eglFence = mSlots[found].mEglFence; 478 // Don't return a fence in shared buffer mode, except for the first 479 // frame. 480 *outFence = (mCore->mSharedBufferMode && 481 mCore->mSharedBufferSlot == found) ? 482 Fence::NO_FENCE : mSlots[found].mFence; 483 mSlots[found].mEglFence = EGL_NO_SYNC_KHR; 484 mSlots[found].mFence = Fence::NO_FENCE; 485 486 // If shared buffer mode has just been enabled, cache the slot of the 487 // first buffer that is dequeued and mark it as the shared buffer. 488 if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == 489 BufferQueueCore::INVALID_BUFFER_SLOT) { 490 mCore->mSharedBufferSlot = found; 491 mSlots[found].mBufferState.mShared = true; 492 } 493 } // Autolock scope 494 495 if (returnFlags & BUFFER_NEEDS_REALLOCATION) { 496 status_t error; 497 BQ_LOGV("dequeueBuffer: allocating a new buffer for slot %d", *outSlot); 498 sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer( 499 width, height, format, usage, &error)); 500 { // Autolock scope 501 Mutex::Autolock lock(mCore->mMutex); 502 503 if (graphicBuffer != NULL && !mCore->mIsAbandoned) { 504 graphicBuffer->setGenerationNumber(mCore->mGenerationNumber); 505 mSlots[*outSlot].mGraphicBuffer = graphicBuffer; 506 } 507 508 mCore->mIsAllocating = false; 509 mCore->mIsAllocatingCondition.broadcast(); 510 511 if (graphicBuffer == NULL) { 512 BQ_LOGE("dequeueBuffer: createGraphicBuffer failed"); 513 return error; 514 } 515 516 if (mCore->mIsAbandoned) { 517 BQ_LOGE("dequeueBuffer: BufferQueue has been abandoned"); 518 return NO_INIT; 519 } 520 521 VALIDATE_CONSISTENCY(); 522 } // Autolock scope 523 } 524 525 if (attachedByConsumer) { 526 returnFlags |= BUFFER_NEEDS_REALLOCATION; 527 } 528 529 if (eglFence != EGL_NO_SYNC_KHR) { 530 EGLint result = eglClientWaitSyncKHR(eglDisplay, eglFence, 0, 531 1000000000); 532 // If something goes wrong, log the error, but return the buffer without 533 // synchronizing access to it. It's too late at this point to abort the 534 // dequeue operation. 535 if (result == EGL_FALSE) { 536 BQ_LOGE("dequeueBuffer: error %#x waiting for fence", 537 eglGetError()); 538 } else if (result == EGL_TIMEOUT_EXPIRED_KHR) { 539 BQ_LOGE("dequeueBuffer: timeout waiting for fence"); 540 } 541 eglDestroySyncKHR(eglDisplay, eglFence); 542 } 543 544 BQ_LOGV("dequeueBuffer: returning slot=%d/%" PRIu64 " buf=%p flags=%#x", 545 *outSlot, 546 mSlots[*outSlot].mFrameNumber, 547 mSlots[*outSlot].mGraphicBuffer->handle, returnFlags); 548 549 return returnFlags; 550} 551 552status_t BufferQueueProducer::detachBuffer(int slot) { 553 ATRACE_CALL(); 554 ATRACE_BUFFER_INDEX(slot); 555 BQ_LOGV("detachBuffer: slot %d", slot); 556 Mutex::Autolock lock(mCore->mMutex); 557 558 if (mCore->mIsAbandoned) { 559 BQ_LOGE("detachBuffer: BufferQueue has been abandoned"); 560 return NO_INIT; 561 } 562 563 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 564 BQ_LOGE("detachBuffer: BufferQueue has no connected producer"); 565 return NO_INIT; 566 } 567 568 if (mCore->mSharedBufferMode || mCore->mSharedBufferSlot == slot) { 569 BQ_LOGE("detachBuffer: cannot detach a buffer in shared buffer mode"); 570 return BAD_VALUE; 571 } 572 573 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 574 BQ_LOGE("detachBuffer: slot index %d out of range [0, %d)", 575 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 576 return BAD_VALUE; 577 } else if (!mSlots[slot].mBufferState.isDequeued()) { 578 BQ_LOGE("detachBuffer: slot %d is not owned by the producer " 579 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 580 return BAD_VALUE; 581 } else if (!mSlots[slot].mRequestBufferCalled) { 582 BQ_LOGE("detachBuffer: buffer in slot %d has not been requested", 583 slot); 584 return BAD_VALUE; 585 } 586 587 mSlots[slot].mBufferState.detachProducer(); 588 mCore->mActiveBuffers.erase(slot); 589 mCore->mFreeSlots.insert(slot); 590 mCore->clearBufferSlotLocked(slot); 591 mCore->mDequeueCondition.broadcast(); 592 VALIDATE_CONSISTENCY(); 593 594 return NO_ERROR; 595} 596 597status_t BufferQueueProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 598 sp<Fence>* outFence) { 599 ATRACE_CALL(); 600 601 if (outBuffer == NULL) { 602 BQ_LOGE("detachNextBuffer: outBuffer must not be NULL"); 603 return BAD_VALUE; 604 } else if (outFence == NULL) { 605 BQ_LOGE("detachNextBuffer: outFence must not be NULL"); 606 return BAD_VALUE; 607 } 608 609 Mutex::Autolock lock(mCore->mMutex); 610 611 if (mCore->mIsAbandoned) { 612 BQ_LOGE("detachNextBuffer: BufferQueue has been abandoned"); 613 return NO_INIT; 614 } 615 616 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 617 BQ_LOGE("detachNextBuffer: BufferQueue has no connected producer"); 618 return NO_INIT; 619 } 620 621 if (mCore->mSharedBufferMode) { 622 BQ_LOGE("detachNextBuffer: cannot detach a buffer in shared buffer " 623 "mode"); 624 return BAD_VALUE; 625 } 626 627 mCore->waitWhileAllocatingLocked(); 628 629 if (mCore->mFreeBuffers.empty()) { 630 return NO_MEMORY; 631 } 632 633 int found = mCore->mFreeBuffers.front(); 634 mCore->mFreeBuffers.remove(found); 635 mCore->mFreeSlots.insert(found); 636 637 BQ_LOGV("detachNextBuffer detached slot %d", found); 638 639 *outBuffer = mSlots[found].mGraphicBuffer; 640 *outFence = mSlots[found].mFence; 641 mCore->clearBufferSlotLocked(found); 642 VALIDATE_CONSISTENCY(); 643 644 return NO_ERROR; 645} 646 647status_t BufferQueueProducer::attachBuffer(int* outSlot, 648 const sp<android::GraphicBuffer>& buffer) { 649 ATRACE_CALL(); 650 651 if (outSlot == NULL) { 652 BQ_LOGE("attachBuffer: outSlot must not be NULL"); 653 return BAD_VALUE; 654 } else if (buffer == NULL) { 655 BQ_LOGE("attachBuffer: cannot attach NULL buffer"); 656 return BAD_VALUE; 657 } 658 659 Mutex::Autolock lock(mCore->mMutex); 660 661 if (mCore->mIsAbandoned) { 662 BQ_LOGE("attachBuffer: BufferQueue has been abandoned"); 663 return NO_INIT; 664 } 665 666 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 667 BQ_LOGE("attachBuffer: BufferQueue has no connected producer"); 668 return NO_INIT; 669 } 670 671 if (mCore->mSharedBufferMode) { 672 BQ_LOGE("attachBuffer: cannot attach a buffer in shared buffer mode"); 673 return BAD_VALUE; 674 } 675 676 if (buffer->getGenerationNumber() != mCore->mGenerationNumber) { 677 BQ_LOGE("attachBuffer: generation number mismatch [buffer %u] " 678 "[queue %u]", buffer->getGenerationNumber(), 679 mCore->mGenerationNumber); 680 return BAD_VALUE; 681 } 682 683 mCore->waitWhileAllocatingLocked(); 684 685 status_t returnFlags = NO_ERROR; 686 int found; 687 status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Attach, &found); 688 if (status != NO_ERROR) { 689 return status; 690 } 691 692 // This should not happen 693 if (found == BufferQueueCore::INVALID_BUFFER_SLOT) { 694 BQ_LOGE("attachBuffer: no available buffer slots"); 695 return -EBUSY; 696 } 697 698 *outSlot = found; 699 ATRACE_BUFFER_INDEX(*outSlot); 700 BQ_LOGV("attachBuffer: returning slot %d flags=%#x", 701 *outSlot, returnFlags); 702 703 mSlots[*outSlot].mGraphicBuffer = buffer; 704 mSlots[*outSlot].mBufferState.attachProducer(); 705 mSlots[*outSlot].mEglFence = EGL_NO_SYNC_KHR; 706 mSlots[*outSlot].mFence = Fence::NO_FENCE; 707 mSlots[*outSlot].mRequestBufferCalled = true; 708 mSlots[*outSlot].mAcquireCalled = false; 709 mCore->mActiveBuffers.insert(found); 710 VALIDATE_CONSISTENCY(); 711 712 return returnFlags; 713} 714 715status_t BufferQueueProducer::queueBuffer(int slot, 716 const QueueBufferInput &input, QueueBufferOutput *output) { 717 ATRACE_CALL(); 718 ATRACE_BUFFER_INDEX(slot); 719 720 int64_t timestamp; 721 bool isAutoTimestamp; 722 android_dataspace dataSpace; 723 Rect crop(Rect::EMPTY_RECT); 724 int scalingMode; 725 uint32_t transform; 726 uint32_t stickyTransform; 727 sp<Fence> fence; 728 input.deflate(×tamp, &isAutoTimestamp, &dataSpace, &crop, &scalingMode, 729 &transform, &fence, &stickyTransform); 730 Region surfaceDamage = input.getSurfaceDamage(); 731 732 if (fence == NULL) { 733 BQ_LOGE("queueBuffer: fence is NULL"); 734 return BAD_VALUE; 735 } 736 737 switch (scalingMode) { 738 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 739 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 740 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 741 case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP: 742 break; 743 default: 744 BQ_LOGE("queueBuffer: unknown scaling mode %d", scalingMode); 745 return BAD_VALUE; 746 } 747 748 sp<IConsumerListener> frameAvailableListener; 749 sp<IConsumerListener> frameReplacedListener; 750 int callbackTicket = 0; 751 BufferItem item; 752 { // Autolock scope 753 Mutex::Autolock lock(mCore->mMutex); 754 755 if (mCore->mIsAbandoned) { 756 BQ_LOGE("queueBuffer: BufferQueue has been abandoned"); 757 return NO_INIT; 758 } 759 760 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 761 BQ_LOGE("queueBuffer: BufferQueue has no connected producer"); 762 return NO_INIT; 763 } 764 765 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 766 BQ_LOGE("queueBuffer: slot index %d out of range [0, %d)", 767 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 768 return BAD_VALUE; 769 } else if (!mSlots[slot].mBufferState.isDequeued()) { 770 BQ_LOGE("queueBuffer: slot %d is not owned by the producer " 771 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 772 return BAD_VALUE; 773 } else if (!mSlots[slot].mRequestBufferCalled) { 774 BQ_LOGE("queueBuffer: slot %d was queued without requesting " 775 "a buffer", slot); 776 return BAD_VALUE; 777 } 778 779 // If shared buffer mode has just been enabled, cache the slot of the 780 // first buffer that is queued and mark it as the shared buffer. 781 if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == 782 BufferQueueCore::INVALID_BUFFER_SLOT) { 783 mCore->mSharedBufferSlot = slot; 784 mSlots[slot].mBufferState.mShared = true; 785 } 786 787 BQ_LOGV("queueBuffer: slot=%d/%" PRIu64 " time=%" PRIu64 " dataSpace=%d" 788 " crop=[%d,%d,%d,%d] transform=%#x scale=%s", 789 slot, mCore->mFrameCounter + 1, timestamp, dataSpace, 790 crop.left, crop.top, crop.right, crop.bottom, transform, 791 BufferItem::scalingModeName(static_cast<uint32_t>(scalingMode))); 792 793 const sp<GraphicBuffer>& graphicBuffer(mSlots[slot].mGraphicBuffer); 794 Rect bufferRect(graphicBuffer->getWidth(), graphicBuffer->getHeight()); 795 Rect croppedRect(Rect::EMPTY_RECT); 796 crop.intersect(bufferRect, &croppedRect); 797 if (croppedRect != crop) { 798 BQ_LOGE("queueBuffer: crop rect is not contained within the " 799 "buffer in slot %d", slot); 800 return BAD_VALUE; 801 } 802 803 // Override UNKNOWN dataspace with consumer default 804 if (dataSpace == HAL_DATASPACE_UNKNOWN) { 805 dataSpace = mCore->mDefaultBufferDataSpace; 806 } 807 808 mSlots[slot].mFence = fence; 809 mSlots[slot].mBufferState.queue(); 810 811 ++mCore->mFrameCounter; 812 mSlots[slot].mFrameNumber = mCore->mFrameCounter; 813 814 item.mAcquireCalled = mSlots[slot].mAcquireCalled; 815 item.mGraphicBuffer = mSlots[slot].mGraphicBuffer; 816 item.mCrop = crop; 817 item.mTransform = transform & 818 ~static_cast<uint32_t>(NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY); 819 item.mTransformToDisplayInverse = 820 (transform & NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) != 0; 821 item.mScalingMode = static_cast<uint32_t>(scalingMode); 822 item.mTimestamp = timestamp; 823 item.mIsAutoTimestamp = isAutoTimestamp; 824 item.mDataSpace = dataSpace; 825 item.mFrameNumber = mCore->mFrameCounter; 826 item.mSlot = slot; 827 item.mFence = fence; 828 item.mIsDroppable = mCore->mAsyncMode || 829 mCore->mDequeueBufferCannotBlock || 830 (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == slot); 831 item.mSurfaceDamage = surfaceDamage; 832 item.mQueuedBuffer = true; 833 item.mAutoRefresh = mCore->mSharedBufferMode && mCore->mAutoRefresh; 834 835 mStickyTransform = stickyTransform; 836 837 // Cache the shared buffer data so that the BufferItem can be recreated. 838 if (mCore->mSharedBufferMode) { 839 mCore->mSharedBufferCache.crop = crop; 840 mCore->mSharedBufferCache.transform = transform; 841 mCore->mSharedBufferCache.scalingMode = static_cast<uint32_t>( 842 scalingMode); 843 mCore->mSharedBufferCache.dataspace = dataSpace; 844 } 845 846 if (mCore->mQueue.empty()) { 847 // When the queue is empty, we can ignore mDequeueBufferCannotBlock 848 // and simply queue this buffer 849 mCore->mQueue.push_back(item); 850 frameAvailableListener = mCore->mConsumerListener; 851 } else { 852 // When the queue is not empty, we need to look at the last buffer 853 // in the queue to see if we need to replace it 854 const BufferItem& last = mCore->mQueue.itemAt( 855 mCore->mQueue.size() - 1); 856 if (last.mIsDroppable) { 857 858 if (!last.mIsStale) { 859 mSlots[last.mSlot].mBufferState.freeQueued(); 860 861 // After leaving shared buffer mode, the shared buffer will 862 // still be around. Mark it as no longer shared if this 863 // operation causes it to be free. 864 if (!mCore->mSharedBufferMode && 865 mSlots[last.mSlot].mBufferState.isFree()) { 866 mSlots[last.mSlot].mBufferState.mShared = false; 867 } 868 // Don't put the shared buffer on the free list. 869 if (!mSlots[last.mSlot].mBufferState.isShared()) { 870 mCore->mActiveBuffers.erase(last.mSlot); 871 mCore->mFreeBuffers.push_back(last.mSlot); 872 } 873 } 874 875 // Overwrite the droppable buffer with the incoming one 876 mCore->mQueue.editItemAt(mCore->mQueue.size() - 1) = item; 877 frameReplacedListener = mCore->mConsumerListener; 878 } else { 879 mCore->mQueue.push_back(item); 880 frameAvailableListener = mCore->mConsumerListener; 881 } 882 } 883 884 mCore->mBufferHasBeenQueued = true; 885 mCore->mDequeueCondition.broadcast(); 886 mCore->mLastQueuedSlot = slot; 887 888 output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight, 889 mCore->mTransformHint, 890 static_cast<uint32_t>(mCore->mQueue.size())); 891 892 ATRACE_INT(mCore->mConsumerName.string(), mCore->mQueue.size()); 893 mCore->mOccupancyTracker.registerOccupancyChange(mCore->mQueue.size()); 894 895 // Take a ticket for the callback functions 896 callbackTicket = mNextCallbackTicket++; 897 898 VALIDATE_CONSISTENCY(); 899 } // Autolock scope 900 901 // Don't send the GraphicBuffer through the callback, and don't send 902 // the slot number, since the consumer shouldn't need it 903 item.mGraphicBuffer.clear(); 904 item.mSlot = BufferItem::INVALID_BUFFER_SLOT; 905 906 // Call back without the main BufferQueue lock held, but with the callback 907 // lock held so we can ensure that callbacks occur in order 908 { 909 Mutex::Autolock lock(mCallbackMutex); 910 while (callbackTicket != mCurrentCallbackTicket) { 911 mCallbackCondition.wait(mCallbackMutex); 912 } 913 914 if (frameAvailableListener != NULL) { 915 frameAvailableListener->onFrameAvailable(item); 916 } else if (frameReplacedListener != NULL) { 917 frameReplacedListener->onFrameReplaced(item); 918 } 919 920 ++mCurrentCallbackTicket; 921 mCallbackCondition.broadcast(); 922 } 923 924 // Wait without lock held 925 if (mCore->mConnectedApi == NATIVE_WINDOW_API_EGL) { 926 // Waiting here allows for two full buffers to be queued but not a 927 // third. In the event that frames take varying time, this makes a 928 // small trade-off in favor of latency rather than throughput. 929 mLastQueueBufferFence->waitForever("Throttling EGL Production"); 930 } 931 mLastQueueBufferFence = fence; 932 mLastQueuedCrop = item.mCrop; 933 mLastQueuedTransform = item.mTransform; 934 935 return NO_ERROR; 936} 937 938status_t BufferQueueProducer::cancelBuffer(int slot, const sp<Fence>& fence) { 939 ATRACE_CALL(); 940 BQ_LOGV("cancelBuffer: slot %d", slot); 941 Mutex::Autolock lock(mCore->mMutex); 942 943 if (mCore->mIsAbandoned) { 944 BQ_LOGE("cancelBuffer: BufferQueue has been abandoned"); 945 return NO_INIT; 946 } 947 948 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 949 BQ_LOGE("cancelBuffer: BufferQueue has no connected producer"); 950 return NO_INIT; 951 } 952 953 if (mCore->mSharedBufferMode) { 954 BQ_LOGE("cancelBuffer: cannot cancel a buffer in shared buffer mode"); 955 return BAD_VALUE; 956 } 957 958 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 959 BQ_LOGE("cancelBuffer: slot index %d out of range [0, %d)", 960 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 961 return BAD_VALUE; 962 } else if (!mSlots[slot].mBufferState.isDequeued()) { 963 BQ_LOGE("cancelBuffer: slot %d is not owned by the producer " 964 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 965 return BAD_VALUE; 966 } else if (fence == NULL) { 967 BQ_LOGE("cancelBuffer: fence is NULL"); 968 return BAD_VALUE; 969 } 970 971 mSlots[slot].mBufferState.cancel(); 972 973 // After leaving shared buffer mode, the shared buffer will still be around. 974 // Mark it as no longer shared if this operation causes it to be free. 975 if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) { 976 mSlots[slot].mBufferState.mShared = false; 977 } 978 979 // Don't put the shared buffer on the free list. 980 if (!mSlots[slot].mBufferState.isShared()) { 981 mCore->mActiveBuffers.erase(slot); 982 mCore->mFreeBuffers.push_back(slot); 983 } 984 985 mSlots[slot].mFence = fence; 986 mCore->mDequeueCondition.broadcast(); 987 VALIDATE_CONSISTENCY(); 988 989 return NO_ERROR; 990} 991 992int BufferQueueProducer::query(int what, int *outValue) { 993 ATRACE_CALL(); 994 Mutex::Autolock lock(mCore->mMutex); 995 996 if (outValue == NULL) { 997 BQ_LOGE("query: outValue was NULL"); 998 return BAD_VALUE; 999 } 1000 1001 if (mCore->mIsAbandoned) { 1002 BQ_LOGE("query: BufferQueue has been abandoned"); 1003 return NO_INIT; 1004 } 1005 1006 int value; 1007 switch (what) { 1008 case NATIVE_WINDOW_WIDTH: 1009 value = static_cast<int32_t>(mCore->mDefaultWidth); 1010 break; 1011 case NATIVE_WINDOW_HEIGHT: 1012 value = static_cast<int32_t>(mCore->mDefaultHeight); 1013 break; 1014 case NATIVE_WINDOW_FORMAT: 1015 value = static_cast<int32_t>(mCore->mDefaultBufferFormat); 1016 break; 1017 case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS: 1018 value = mCore->getMinUndequeuedBufferCountLocked(); 1019 break; 1020 case NATIVE_WINDOW_STICKY_TRANSFORM: 1021 value = static_cast<int32_t>(mStickyTransform); 1022 break; 1023 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: 1024 value = (mCore->mQueue.size() > 1); 1025 break; 1026 case NATIVE_WINDOW_CONSUMER_USAGE_BITS: 1027 value = static_cast<int32_t>(mCore->mConsumerUsageBits); 1028 break; 1029 case NATIVE_WINDOW_DEFAULT_DATASPACE: 1030 value = static_cast<int32_t>(mCore->mDefaultBufferDataSpace); 1031 break; 1032 case NATIVE_WINDOW_BUFFER_AGE: 1033 if (mCore->mBufferAge > INT32_MAX) { 1034 value = 0; 1035 } else { 1036 value = static_cast<int32_t>(mCore->mBufferAge); 1037 } 1038 break; 1039 default: 1040 return BAD_VALUE; 1041 } 1042 1043 BQ_LOGV("query: %d? %d", what, value); 1044 *outValue = value; 1045 return NO_ERROR; 1046} 1047 1048status_t BufferQueueProducer::connect(const sp<IProducerListener>& listener, 1049 int api, bool producerControlledByApp, QueueBufferOutput *output) { 1050 ATRACE_CALL(); 1051 Mutex::Autolock lock(mCore->mMutex); 1052 mConsumerName = mCore->mConsumerName; 1053 BQ_LOGV("connect: api=%d producerControlledByApp=%s", api, 1054 producerControlledByApp ? "true" : "false"); 1055 1056 if (mCore->mIsAbandoned) { 1057 BQ_LOGE("connect: BufferQueue has been abandoned"); 1058 return NO_INIT; 1059 } 1060 1061 if (mCore->mConsumerListener == NULL) { 1062 BQ_LOGE("connect: BufferQueue has no consumer"); 1063 return NO_INIT; 1064 } 1065 1066 if (output == NULL) { 1067 BQ_LOGE("connect: output was NULL"); 1068 return BAD_VALUE; 1069 } 1070 1071 if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) { 1072 BQ_LOGE("connect: already connected (cur=%d req=%d)", 1073 mCore->mConnectedApi, api); 1074 return BAD_VALUE; 1075 } 1076 1077 int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode, 1078 mDequeueTimeout < 0 ? 1079 mCore->mConsumerControlledByApp && producerControlledByApp : false, 1080 mCore->mMaxBufferCount) - 1081 mCore->getMaxBufferCountLocked(); 1082 if (!mCore->adjustAvailableSlotsLocked(delta)) { 1083 BQ_LOGE("connect: BufferQueue failed to adjust the number of available " 1084 "slots. Delta = %d", delta); 1085 return BAD_VALUE; 1086 } 1087 1088 int status = NO_ERROR; 1089 switch (api) { 1090 case NATIVE_WINDOW_API_EGL: 1091 case NATIVE_WINDOW_API_CPU: 1092 case NATIVE_WINDOW_API_MEDIA: 1093 case NATIVE_WINDOW_API_CAMERA: 1094 mCore->mConnectedApi = api; 1095 output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight, 1096 mCore->mTransformHint, 1097 static_cast<uint32_t>(mCore->mQueue.size())); 1098 1099 // Set up a death notification so that we can disconnect 1100 // automatically if the remote producer dies 1101 if (listener != NULL && 1102 IInterface::asBinder(listener)->remoteBinder() != NULL) { 1103 status = IInterface::asBinder(listener)->linkToDeath( 1104 static_cast<IBinder::DeathRecipient*>(this)); 1105 if (status != NO_ERROR) { 1106 BQ_LOGE("connect: linkToDeath failed: %s (%d)", 1107 strerror(-status), status); 1108 } 1109 } 1110 mCore->mConnectedProducerListener = listener; 1111 break; 1112 default: 1113 BQ_LOGE("connect: unknown API %d", api); 1114 status = BAD_VALUE; 1115 break; 1116 } 1117 1118 mCore->mBufferHasBeenQueued = false; 1119 mCore->mDequeueBufferCannotBlock = false; 1120 if (mDequeueTimeout < 0) { 1121 mCore->mDequeueBufferCannotBlock = 1122 mCore->mConsumerControlledByApp && producerControlledByApp; 1123 } 1124 1125 mCore->mAllowAllocation = true; 1126 VALIDATE_CONSISTENCY(); 1127 return status; 1128} 1129 1130status_t BufferQueueProducer::disconnect(int api) { 1131 ATRACE_CALL(); 1132 BQ_LOGV("disconnect: api %d", api); 1133 1134 int status = NO_ERROR; 1135 sp<IConsumerListener> listener; 1136 { // Autolock scope 1137 Mutex::Autolock lock(mCore->mMutex); 1138 mCore->waitWhileAllocatingLocked(); 1139 1140 if (mCore->mIsAbandoned) { 1141 // It's not really an error to disconnect after the surface has 1142 // been abandoned; it should just be a no-op. 1143 return NO_ERROR; 1144 } 1145 1146 if (api == BufferQueueCore::CURRENTLY_CONNECTED_API) { 1147 api = mCore->mConnectedApi; 1148 // If we're asked to disconnect the currently connected api but 1149 // nobody is connected, it's not really an error. 1150 if (api == BufferQueueCore::NO_CONNECTED_API) { 1151 return NO_ERROR; 1152 } 1153 } 1154 1155 switch (api) { 1156 case NATIVE_WINDOW_API_EGL: 1157 case NATIVE_WINDOW_API_CPU: 1158 case NATIVE_WINDOW_API_MEDIA: 1159 case NATIVE_WINDOW_API_CAMERA: 1160 if (mCore->mConnectedApi == api) { 1161 mCore->freeAllBuffersLocked(); 1162 1163 // Remove our death notification callback if we have one 1164 if (mCore->mConnectedProducerListener != NULL) { 1165 sp<IBinder> token = 1166 IInterface::asBinder(mCore->mConnectedProducerListener); 1167 // This can fail if we're here because of the death 1168 // notification, but we just ignore it 1169 token->unlinkToDeath( 1170 static_cast<IBinder::DeathRecipient*>(this)); 1171 } 1172 mCore->mSharedBufferSlot = 1173 BufferQueueCore::INVALID_BUFFER_SLOT; 1174 mCore->mConnectedProducerListener = NULL; 1175 mCore->mConnectedApi = BufferQueueCore::NO_CONNECTED_API; 1176 mCore->mSidebandStream.clear(); 1177 mCore->mDequeueCondition.broadcast(); 1178 listener = mCore->mConsumerListener; 1179 } else if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) { 1180 BQ_LOGE("disconnect: still connected to another API " 1181 "(cur=%d req=%d)", mCore->mConnectedApi, api); 1182 status = BAD_VALUE; 1183 } 1184 break; 1185 default: 1186 BQ_LOGE("disconnect: unknown API %d", api); 1187 status = BAD_VALUE; 1188 break; 1189 } 1190 } // Autolock scope 1191 1192 // Call back without lock held 1193 if (listener != NULL) { 1194 listener->onBuffersReleased(); 1195 } 1196 1197 return status; 1198} 1199 1200status_t BufferQueueProducer::setSidebandStream(const sp<NativeHandle>& stream) { 1201 sp<IConsumerListener> listener; 1202 { // Autolock scope 1203 Mutex::Autolock _l(mCore->mMutex); 1204 mCore->mSidebandStream = stream; 1205 listener = mCore->mConsumerListener; 1206 } // Autolock scope 1207 1208 if (listener != NULL) { 1209 listener->onSidebandStreamChanged(); 1210 } 1211 return NO_ERROR; 1212} 1213 1214void BufferQueueProducer::allocateBuffers(uint32_t width, uint32_t height, 1215 PixelFormat format, uint32_t usage) { 1216 ATRACE_CALL(); 1217 while (true) { 1218 size_t newBufferCount = 0; 1219 uint32_t allocWidth = 0; 1220 uint32_t allocHeight = 0; 1221 PixelFormat allocFormat = PIXEL_FORMAT_UNKNOWN; 1222 uint32_t allocUsage = 0; 1223 { // Autolock scope 1224 Mutex::Autolock lock(mCore->mMutex); 1225 mCore->waitWhileAllocatingLocked(); 1226 1227 if (!mCore->mAllowAllocation) { 1228 BQ_LOGE("allocateBuffers: allocation is not allowed for this " 1229 "BufferQueue"); 1230 return; 1231 } 1232 1233 newBufferCount = mCore->mFreeSlots.size(); 1234 if (newBufferCount == 0) { 1235 return; 1236 } 1237 1238 allocWidth = width > 0 ? width : mCore->mDefaultWidth; 1239 allocHeight = height > 0 ? height : mCore->mDefaultHeight; 1240 allocFormat = format != 0 ? format : mCore->mDefaultBufferFormat; 1241 allocUsage = usage | mCore->mConsumerUsageBits; 1242 1243 mCore->mIsAllocating = true; 1244 } // Autolock scope 1245 1246 Vector<sp<GraphicBuffer>> buffers; 1247 for (size_t i = 0; i < newBufferCount; ++i) { 1248 status_t result = NO_ERROR; 1249 sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer( 1250 allocWidth, allocHeight, allocFormat, allocUsage, &result)); 1251 if (result != NO_ERROR) { 1252 BQ_LOGE("allocateBuffers: failed to allocate buffer (%u x %u, format" 1253 " %u, usage %u)", width, height, format, usage); 1254 Mutex::Autolock lock(mCore->mMutex); 1255 mCore->mIsAllocating = false; 1256 mCore->mIsAllocatingCondition.broadcast(); 1257 return; 1258 } 1259 buffers.push_back(graphicBuffer); 1260 } 1261 1262 { // Autolock scope 1263 Mutex::Autolock lock(mCore->mMutex); 1264 uint32_t checkWidth = width > 0 ? width : mCore->mDefaultWidth; 1265 uint32_t checkHeight = height > 0 ? height : mCore->mDefaultHeight; 1266 PixelFormat checkFormat = format != 0 ? 1267 format : mCore->mDefaultBufferFormat; 1268 uint32_t checkUsage = usage | mCore->mConsumerUsageBits; 1269 if (checkWidth != allocWidth || checkHeight != allocHeight || 1270 checkFormat != allocFormat || checkUsage != allocUsage) { 1271 // Something changed while we released the lock. Retry. 1272 BQ_LOGV("allocateBuffers: size/format/usage changed while allocating. Retrying."); 1273 mCore->mIsAllocating = false; 1274 mCore->mIsAllocatingCondition.broadcast(); 1275 continue; 1276 } 1277 1278 for (size_t i = 0; i < newBufferCount; ++i) { 1279 if (mCore->mFreeSlots.empty()) { 1280 BQ_LOGV("allocateBuffers: a slot was occupied while " 1281 "allocating. Dropping allocated buffer."); 1282 continue; 1283 } 1284 auto slot = mCore->mFreeSlots.begin(); 1285 mCore->clearBufferSlotLocked(*slot); // Clean up the slot first 1286 mSlots[*slot].mGraphicBuffer = buffers[i]; 1287 mSlots[*slot].mFence = Fence::NO_FENCE; 1288 1289 // freeBufferLocked puts this slot on the free slots list. Since 1290 // we then attached a buffer, move the slot to free buffer list. 1291 mCore->mFreeBuffers.push_front(*slot); 1292 1293 BQ_LOGV("allocateBuffers: allocated a new buffer in slot %d", 1294 *slot); 1295 1296 // Make sure the erase is done after all uses of the slot 1297 // iterator since it will be invalid after this point. 1298 mCore->mFreeSlots.erase(slot); 1299 } 1300 1301 mCore->mIsAllocating = false; 1302 mCore->mIsAllocatingCondition.broadcast(); 1303 VALIDATE_CONSISTENCY(); 1304 } // Autolock scope 1305 } 1306} 1307 1308status_t BufferQueueProducer::allowAllocation(bool allow) { 1309 ATRACE_CALL(); 1310 BQ_LOGV("allowAllocation: %s", allow ? "true" : "false"); 1311 1312 Mutex::Autolock lock(mCore->mMutex); 1313 mCore->mAllowAllocation = allow; 1314 return NO_ERROR; 1315} 1316 1317status_t BufferQueueProducer::setGenerationNumber(uint32_t generationNumber) { 1318 ATRACE_CALL(); 1319 BQ_LOGV("setGenerationNumber: %u", generationNumber); 1320 1321 Mutex::Autolock lock(mCore->mMutex); 1322 mCore->mGenerationNumber = generationNumber; 1323 return NO_ERROR; 1324} 1325 1326String8 BufferQueueProducer::getConsumerName() const { 1327 ATRACE_CALL(); 1328 BQ_LOGV("getConsumerName: %s", mConsumerName.string()); 1329 return mConsumerName; 1330} 1331 1332uint64_t BufferQueueProducer::getNextFrameNumber() const { 1333 ATRACE_CALL(); 1334 1335 Mutex::Autolock lock(mCore->mMutex); 1336 uint64_t nextFrameNumber = mCore->mFrameCounter + 1; 1337 return nextFrameNumber; 1338} 1339 1340status_t BufferQueueProducer::setSharedBufferMode(bool sharedBufferMode) { 1341 ATRACE_CALL(); 1342 BQ_LOGV("setSharedBufferMode: %d", sharedBufferMode); 1343 1344 Mutex::Autolock lock(mCore->mMutex); 1345 if (!sharedBufferMode) { 1346 mCore->mSharedBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT; 1347 } 1348 mCore->mSharedBufferMode = sharedBufferMode; 1349 return NO_ERROR; 1350} 1351 1352status_t BufferQueueProducer::setAutoRefresh(bool autoRefresh) { 1353 ATRACE_CALL(); 1354 BQ_LOGV("setAutoRefresh: %d", autoRefresh); 1355 1356 Mutex::Autolock lock(mCore->mMutex); 1357 1358 mCore->mAutoRefresh = autoRefresh; 1359 return NO_ERROR; 1360} 1361 1362status_t BufferQueueProducer::setDequeueTimeout(nsecs_t timeout) { 1363 ATRACE_CALL(); 1364 BQ_LOGV("setDequeueTimeout: %" PRId64, timeout); 1365 1366 Mutex::Autolock lock(mCore->mMutex); 1367 int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode, false, 1368 mCore->mMaxBufferCount) - mCore->getMaxBufferCountLocked(); 1369 if (!mCore->adjustAvailableSlotsLocked(delta)) { 1370 BQ_LOGE("setDequeueTimeout: BufferQueue failed to adjust the number of " 1371 "available slots. Delta = %d", delta); 1372 return BAD_VALUE; 1373 } 1374 1375 mDequeueTimeout = timeout; 1376 mCore->mDequeueBufferCannotBlock = false; 1377 1378 VALIDATE_CONSISTENCY(); 1379 return NO_ERROR; 1380} 1381 1382status_t BufferQueueProducer::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer, 1383 sp<Fence>* outFence, float outTransformMatrix[16]) { 1384 ATRACE_CALL(); 1385 BQ_LOGV("getLastQueuedBuffer"); 1386 1387 Mutex::Autolock lock(mCore->mMutex); 1388 if (mCore->mLastQueuedSlot == BufferItem::INVALID_BUFFER_SLOT) { 1389 *outBuffer = nullptr; 1390 *outFence = Fence::NO_FENCE; 1391 return NO_ERROR; 1392 } 1393 1394 *outBuffer = mSlots[mCore->mLastQueuedSlot].mGraphicBuffer; 1395 *outFence = mLastQueueBufferFence; 1396 1397 // Currently only SurfaceFlinger internally ever changes 1398 // GLConsumer's filtering mode, so we just use 'true' here as 1399 // this is slightly specialized for the current client of this API, 1400 // which does want filtering. 1401 GLConsumer::computeTransformMatrix(outTransformMatrix, 1402 mSlots[mCore->mLastQueuedSlot].mGraphicBuffer, mLastQueuedCrop, 1403 mLastQueuedTransform, true /* filter */); 1404 1405 return NO_ERROR; 1406} 1407 1408void BufferQueueProducer::binderDied(const wp<android::IBinder>& /* who */) { 1409 // If we're here, it means that a producer we were connected to died. 1410 // We're guaranteed that we are still connected to it because we remove 1411 // this callback upon disconnect. It's therefore safe to read mConnectedApi 1412 // without synchronization here. 1413 int api = mCore->mConnectedApi; 1414 disconnect(api); 1415} 1416 1417} // namespace android 1418