BufferQueueProducer.cpp revision bc8c1928e1dbdaf6a2820f6e426c96ed61284043
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 mCore->mFreeSlots.insert(*outSlot); 513 mCore->clearBufferSlotLocked(*outSlot); 514 BQ_LOGE("dequeueBuffer: createGraphicBuffer failed"); 515 return error; 516 } 517 518 if (mCore->mIsAbandoned) { 519 mCore->mFreeSlots.insert(*outSlot); 520 mCore->clearBufferSlotLocked(*outSlot); 521 BQ_LOGE("dequeueBuffer: BufferQueue has been abandoned"); 522 return NO_INIT; 523 } 524 525 VALIDATE_CONSISTENCY(); 526 } // Autolock scope 527 } 528 529 if (attachedByConsumer) { 530 returnFlags |= BUFFER_NEEDS_REALLOCATION; 531 } 532 533 if (eglFence != EGL_NO_SYNC_KHR) { 534 EGLint result = eglClientWaitSyncKHR(eglDisplay, eglFence, 0, 535 1000000000); 536 // If something goes wrong, log the error, but return the buffer without 537 // synchronizing access to it. It's too late at this point to abort the 538 // dequeue operation. 539 if (result == EGL_FALSE) { 540 BQ_LOGE("dequeueBuffer: error %#x waiting for fence", 541 eglGetError()); 542 } else if (result == EGL_TIMEOUT_EXPIRED_KHR) { 543 BQ_LOGE("dequeueBuffer: timeout waiting for fence"); 544 } 545 eglDestroySyncKHR(eglDisplay, eglFence); 546 } 547 548 BQ_LOGV("dequeueBuffer: returning slot=%d/%" PRIu64 " buf=%p flags=%#x", 549 *outSlot, 550 mSlots[*outSlot].mFrameNumber, 551 mSlots[*outSlot].mGraphicBuffer->handle, returnFlags); 552 553 return returnFlags; 554} 555 556status_t BufferQueueProducer::detachBuffer(int slot) { 557 ATRACE_CALL(); 558 ATRACE_BUFFER_INDEX(slot); 559 BQ_LOGV("detachBuffer: slot %d", slot); 560 561 sp<IConsumerListener> listener; 562 { 563 Mutex::Autolock lock(mCore->mMutex); 564 565 if (mCore->mIsAbandoned) { 566 BQ_LOGE("detachBuffer: BufferQueue has been abandoned"); 567 return NO_INIT; 568 } 569 570 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 571 BQ_LOGE("detachBuffer: BufferQueue has no connected producer"); 572 return NO_INIT; 573 } 574 575 if (mCore->mSharedBufferMode || mCore->mSharedBufferSlot == slot) { 576 BQ_LOGE("detachBuffer: cannot detach a buffer in shared buffer mode"); 577 return BAD_VALUE; 578 } 579 580 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 581 BQ_LOGE("detachBuffer: slot index %d out of range [0, %d)", 582 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 583 return BAD_VALUE; 584 } else if (!mSlots[slot].mBufferState.isDequeued()) { 585 BQ_LOGE("detachBuffer: slot %d is not owned by the producer " 586 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 587 return BAD_VALUE; 588 } else if (!mSlots[slot].mRequestBufferCalled) { 589 BQ_LOGE("detachBuffer: buffer in slot %d has not been requested", 590 slot); 591 return BAD_VALUE; 592 } 593 594 mSlots[slot].mBufferState.detachProducer(); 595 mCore->mActiveBuffers.erase(slot); 596 mCore->mFreeSlots.insert(slot); 597 mCore->clearBufferSlotLocked(slot); 598 mCore->mDequeueCondition.broadcast(); 599 VALIDATE_CONSISTENCY(); 600 listener = mCore->mConsumerListener; 601 } 602 603 if (listener != NULL) { 604 listener->onBuffersReleased(); 605 } 606 607 return NO_ERROR; 608} 609 610status_t BufferQueueProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer, 611 sp<Fence>* outFence) { 612 ATRACE_CALL(); 613 614 if (outBuffer == NULL) { 615 BQ_LOGE("detachNextBuffer: outBuffer must not be NULL"); 616 return BAD_VALUE; 617 } else if (outFence == NULL) { 618 BQ_LOGE("detachNextBuffer: outFence must not be NULL"); 619 return BAD_VALUE; 620 } 621 622 Mutex::Autolock lock(mCore->mMutex); 623 624 if (mCore->mIsAbandoned) { 625 BQ_LOGE("detachNextBuffer: BufferQueue has been abandoned"); 626 return NO_INIT; 627 } 628 629 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 630 BQ_LOGE("detachNextBuffer: BufferQueue has no connected producer"); 631 return NO_INIT; 632 } 633 634 if (mCore->mSharedBufferMode) { 635 BQ_LOGE("detachNextBuffer: cannot detach a buffer in shared buffer " 636 "mode"); 637 return BAD_VALUE; 638 } 639 640 mCore->waitWhileAllocatingLocked(); 641 642 if (mCore->mFreeBuffers.empty()) { 643 return NO_MEMORY; 644 } 645 646 int found = mCore->mFreeBuffers.front(); 647 mCore->mFreeBuffers.remove(found); 648 mCore->mFreeSlots.insert(found); 649 650 BQ_LOGV("detachNextBuffer detached slot %d", found); 651 652 *outBuffer = mSlots[found].mGraphicBuffer; 653 *outFence = mSlots[found].mFence; 654 mCore->clearBufferSlotLocked(found); 655 VALIDATE_CONSISTENCY(); 656 657 return NO_ERROR; 658} 659 660status_t BufferQueueProducer::attachBuffer(int* outSlot, 661 const sp<android::GraphicBuffer>& buffer) { 662 ATRACE_CALL(); 663 664 if (outSlot == NULL) { 665 BQ_LOGE("attachBuffer: outSlot must not be NULL"); 666 return BAD_VALUE; 667 } else if (buffer == NULL) { 668 BQ_LOGE("attachBuffer: cannot attach NULL buffer"); 669 return BAD_VALUE; 670 } 671 672 Mutex::Autolock lock(mCore->mMutex); 673 674 if (mCore->mIsAbandoned) { 675 BQ_LOGE("attachBuffer: BufferQueue has been abandoned"); 676 return NO_INIT; 677 } 678 679 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 680 BQ_LOGE("attachBuffer: BufferQueue has no connected producer"); 681 return NO_INIT; 682 } 683 684 if (mCore->mSharedBufferMode) { 685 BQ_LOGE("attachBuffer: cannot attach a buffer in shared buffer mode"); 686 return BAD_VALUE; 687 } 688 689 if (buffer->getGenerationNumber() != mCore->mGenerationNumber) { 690 BQ_LOGE("attachBuffer: generation number mismatch [buffer %u] " 691 "[queue %u]", buffer->getGenerationNumber(), 692 mCore->mGenerationNumber); 693 return BAD_VALUE; 694 } 695 696 mCore->waitWhileAllocatingLocked(); 697 698 status_t returnFlags = NO_ERROR; 699 int found; 700 status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Attach, &found); 701 if (status != NO_ERROR) { 702 return status; 703 } 704 705 // This should not happen 706 if (found == BufferQueueCore::INVALID_BUFFER_SLOT) { 707 BQ_LOGE("attachBuffer: no available buffer slots"); 708 return -EBUSY; 709 } 710 711 *outSlot = found; 712 ATRACE_BUFFER_INDEX(*outSlot); 713 BQ_LOGV("attachBuffer: returning slot %d flags=%#x", 714 *outSlot, returnFlags); 715 716 mSlots[*outSlot].mGraphicBuffer = buffer; 717 mSlots[*outSlot].mBufferState.attachProducer(); 718 mSlots[*outSlot].mEglFence = EGL_NO_SYNC_KHR; 719 mSlots[*outSlot].mFence = Fence::NO_FENCE; 720 mSlots[*outSlot].mRequestBufferCalled = true; 721 mSlots[*outSlot].mAcquireCalled = false; 722 mCore->mActiveBuffers.insert(found); 723 VALIDATE_CONSISTENCY(); 724 725 return returnFlags; 726} 727 728status_t BufferQueueProducer::queueBuffer(int slot, 729 const QueueBufferInput &input, QueueBufferOutput *output) { 730 ATRACE_CALL(); 731 ATRACE_BUFFER_INDEX(slot); 732 733 int64_t timestamp; 734 bool isAutoTimestamp; 735 android_dataspace dataSpace; 736 Rect crop(Rect::EMPTY_RECT); 737 int scalingMode; 738 uint32_t transform; 739 uint32_t stickyTransform; 740 sp<Fence> fence; 741 input.deflate(×tamp, &isAutoTimestamp, &dataSpace, &crop, &scalingMode, 742 &transform, &fence, &stickyTransform); 743 Region surfaceDamage = input.getSurfaceDamage(); 744 745 if (fence == NULL) { 746 BQ_LOGE("queueBuffer: fence is NULL"); 747 return BAD_VALUE; 748 } 749 750 switch (scalingMode) { 751 case NATIVE_WINDOW_SCALING_MODE_FREEZE: 752 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW: 753 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP: 754 case NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP: 755 break; 756 default: 757 BQ_LOGE("queueBuffer: unknown scaling mode %d", scalingMode); 758 return BAD_VALUE; 759 } 760 761 sp<IConsumerListener> frameAvailableListener; 762 sp<IConsumerListener> frameReplacedListener; 763 int callbackTicket = 0; 764 BufferItem item; 765 { // Autolock scope 766 Mutex::Autolock lock(mCore->mMutex); 767 768 if (mCore->mIsAbandoned) { 769 BQ_LOGE("queueBuffer: BufferQueue has been abandoned"); 770 return NO_INIT; 771 } 772 773 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 774 BQ_LOGE("queueBuffer: BufferQueue has no connected producer"); 775 return NO_INIT; 776 } 777 778 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 779 BQ_LOGE("queueBuffer: slot index %d out of range [0, %d)", 780 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 781 return BAD_VALUE; 782 } else if (!mSlots[slot].mBufferState.isDequeued()) { 783 BQ_LOGE("queueBuffer: slot %d is not owned by the producer " 784 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 785 return BAD_VALUE; 786 } else if (!mSlots[slot].mRequestBufferCalled) { 787 BQ_LOGE("queueBuffer: slot %d was queued without requesting " 788 "a buffer", slot); 789 return BAD_VALUE; 790 } 791 792 // If shared buffer mode has just been enabled, cache the slot of the 793 // first buffer that is queued and mark it as the shared buffer. 794 if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == 795 BufferQueueCore::INVALID_BUFFER_SLOT) { 796 mCore->mSharedBufferSlot = slot; 797 mSlots[slot].mBufferState.mShared = true; 798 } 799 800 BQ_LOGV("queueBuffer: slot=%d/%" PRIu64 " time=%" PRIu64 " dataSpace=%d" 801 " crop=[%d,%d,%d,%d] transform=%#x scale=%s", 802 slot, mCore->mFrameCounter + 1, timestamp, dataSpace, 803 crop.left, crop.top, crop.right, crop.bottom, transform, 804 BufferItem::scalingModeName(static_cast<uint32_t>(scalingMode))); 805 806 const sp<GraphicBuffer>& graphicBuffer(mSlots[slot].mGraphicBuffer); 807 Rect bufferRect(graphicBuffer->getWidth(), graphicBuffer->getHeight()); 808 Rect croppedRect(Rect::EMPTY_RECT); 809 crop.intersect(bufferRect, &croppedRect); 810 if (croppedRect != crop) { 811 BQ_LOGE("queueBuffer: crop rect is not contained within the " 812 "buffer in slot %d", slot); 813 return BAD_VALUE; 814 } 815 816 // Override UNKNOWN dataspace with consumer default 817 if (dataSpace == HAL_DATASPACE_UNKNOWN) { 818 dataSpace = mCore->mDefaultBufferDataSpace; 819 } 820 821 mSlots[slot].mFence = fence; 822 mSlots[slot].mBufferState.queue(); 823 824 ++mCore->mFrameCounter; 825 mSlots[slot].mFrameNumber = mCore->mFrameCounter; 826 827 item.mAcquireCalled = mSlots[slot].mAcquireCalled; 828 item.mGraphicBuffer = mSlots[slot].mGraphicBuffer; 829 item.mCrop = crop; 830 item.mTransform = transform & 831 ~static_cast<uint32_t>(NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY); 832 item.mTransformToDisplayInverse = 833 (transform & NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) != 0; 834 item.mScalingMode = static_cast<uint32_t>(scalingMode); 835 item.mTimestamp = timestamp; 836 item.mIsAutoTimestamp = isAutoTimestamp; 837 item.mDataSpace = dataSpace; 838 item.mFrameNumber = mCore->mFrameCounter; 839 item.mSlot = slot; 840 item.mFence = fence; 841 item.mIsDroppable = mCore->mAsyncMode || 842 mCore->mDequeueBufferCannotBlock || 843 (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == slot); 844 item.mSurfaceDamage = surfaceDamage; 845 item.mQueuedBuffer = true; 846 item.mAutoRefresh = mCore->mSharedBufferMode && mCore->mAutoRefresh; 847 848 mStickyTransform = stickyTransform; 849 850 // Cache the shared buffer data so that the BufferItem can be recreated. 851 if (mCore->mSharedBufferMode) { 852 mCore->mSharedBufferCache.crop = crop; 853 mCore->mSharedBufferCache.transform = transform; 854 mCore->mSharedBufferCache.scalingMode = static_cast<uint32_t>( 855 scalingMode); 856 mCore->mSharedBufferCache.dataspace = dataSpace; 857 } 858 859 if (mCore->mQueue.empty()) { 860 // When the queue is empty, we can ignore mDequeueBufferCannotBlock 861 // and simply queue this buffer 862 mCore->mQueue.push_back(item); 863 frameAvailableListener = mCore->mConsumerListener; 864 } else { 865 // When the queue is not empty, we need to look at the last buffer 866 // in the queue to see if we need to replace it 867 const BufferItem& last = mCore->mQueue.itemAt( 868 mCore->mQueue.size() - 1); 869 if (last.mIsDroppable) { 870 871 if (!last.mIsStale) { 872 mSlots[last.mSlot].mBufferState.freeQueued(); 873 874 // After leaving shared buffer mode, the shared buffer will 875 // still be around. Mark it as no longer shared if this 876 // operation causes it to be free. 877 if (!mCore->mSharedBufferMode && 878 mSlots[last.mSlot].mBufferState.isFree()) { 879 mSlots[last.mSlot].mBufferState.mShared = false; 880 } 881 // Don't put the shared buffer on the free list. 882 if (!mSlots[last.mSlot].mBufferState.isShared()) { 883 mCore->mActiveBuffers.erase(last.mSlot); 884 mCore->mFreeBuffers.push_back(last.mSlot); 885 } 886 } 887 888 // Overwrite the droppable buffer with the incoming one 889 mCore->mQueue.editItemAt(mCore->mQueue.size() - 1) = item; 890 frameReplacedListener = mCore->mConsumerListener; 891 } else { 892 mCore->mQueue.push_back(item); 893 frameAvailableListener = mCore->mConsumerListener; 894 } 895 } 896 897 mCore->mBufferHasBeenQueued = true; 898 mCore->mDequeueCondition.broadcast(); 899 mCore->mLastQueuedSlot = slot; 900 901 output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight, 902 mCore->mTransformHint, 903 static_cast<uint32_t>(mCore->mQueue.size()), 904 mCore->mFrameCounter + 1); 905 906 ATRACE_INT(mCore->mConsumerName.string(), mCore->mQueue.size()); 907 mCore->mOccupancyTracker.registerOccupancyChange(mCore->mQueue.size()); 908 909 // Take a ticket for the callback functions 910 callbackTicket = mNextCallbackTicket++; 911 912 VALIDATE_CONSISTENCY(); 913 } // Autolock scope 914 915 // Don't send the GraphicBuffer through the callback, and don't send 916 // the slot number, since the consumer shouldn't need it 917 item.mGraphicBuffer.clear(); 918 item.mSlot = BufferItem::INVALID_BUFFER_SLOT; 919 920 // Call back without the main BufferQueue lock held, but with the callback 921 // lock held so we can ensure that callbacks occur in order 922 { 923 Mutex::Autolock lock(mCallbackMutex); 924 while (callbackTicket != mCurrentCallbackTicket) { 925 mCallbackCondition.wait(mCallbackMutex); 926 } 927 928 if (frameAvailableListener != NULL) { 929 frameAvailableListener->onFrameAvailable(item); 930 } else if (frameReplacedListener != NULL) { 931 frameReplacedListener->onFrameReplaced(item); 932 } 933 934 ++mCurrentCallbackTicket; 935 mCallbackCondition.broadcast(); 936 } 937 938 // Wait without lock held 939 if (mCore->mConnectedApi == NATIVE_WINDOW_API_EGL) { 940 // Waiting here allows for two full buffers to be queued but not a 941 // third. In the event that frames take varying time, this makes a 942 // small trade-off in favor of latency rather than throughput. 943 mLastQueueBufferFence->waitForever("Throttling EGL Production"); 944 } 945 mLastQueueBufferFence = fence; 946 mLastQueuedCrop = item.mCrop; 947 mLastQueuedTransform = item.mTransform; 948 949 return NO_ERROR; 950} 951 952status_t BufferQueueProducer::cancelBuffer(int slot, const sp<Fence>& fence) { 953 ATRACE_CALL(); 954 BQ_LOGV("cancelBuffer: slot %d", slot); 955 Mutex::Autolock lock(mCore->mMutex); 956 957 if (mCore->mIsAbandoned) { 958 BQ_LOGE("cancelBuffer: BufferQueue has been abandoned"); 959 return NO_INIT; 960 } 961 962 if (mCore->mConnectedApi == BufferQueueCore::NO_CONNECTED_API) { 963 BQ_LOGE("cancelBuffer: BufferQueue has no connected producer"); 964 return NO_INIT; 965 } 966 967 if (mCore->mSharedBufferMode) { 968 BQ_LOGE("cancelBuffer: cannot cancel a buffer in shared buffer mode"); 969 return BAD_VALUE; 970 } 971 972 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) { 973 BQ_LOGE("cancelBuffer: slot index %d out of range [0, %d)", 974 slot, BufferQueueDefs::NUM_BUFFER_SLOTS); 975 return BAD_VALUE; 976 } else if (!mSlots[slot].mBufferState.isDequeued()) { 977 BQ_LOGE("cancelBuffer: slot %d is not owned by the producer " 978 "(state = %s)", slot, mSlots[slot].mBufferState.string()); 979 return BAD_VALUE; 980 } else if (fence == NULL) { 981 BQ_LOGE("cancelBuffer: fence is NULL"); 982 return BAD_VALUE; 983 } 984 985 mSlots[slot].mBufferState.cancel(); 986 987 // After leaving shared buffer mode, the shared buffer will still be around. 988 // Mark it as no longer shared if this operation causes it to be free. 989 if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) { 990 mSlots[slot].mBufferState.mShared = false; 991 } 992 993 // Don't put the shared buffer on the free list. 994 if (!mSlots[slot].mBufferState.isShared()) { 995 mCore->mActiveBuffers.erase(slot); 996 mCore->mFreeBuffers.push_back(slot); 997 } 998 999 mSlots[slot].mFence = fence; 1000 mCore->mDequeueCondition.broadcast(); 1001 VALIDATE_CONSISTENCY(); 1002 1003 return NO_ERROR; 1004} 1005 1006int BufferQueueProducer::query(int what, int *outValue) { 1007 ATRACE_CALL(); 1008 Mutex::Autolock lock(mCore->mMutex); 1009 1010 if (outValue == NULL) { 1011 BQ_LOGE("query: outValue was NULL"); 1012 return BAD_VALUE; 1013 } 1014 1015 if (mCore->mIsAbandoned) { 1016 BQ_LOGE("query: BufferQueue has been abandoned"); 1017 return NO_INIT; 1018 } 1019 1020 int value; 1021 switch (what) { 1022 case NATIVE_WINDOW_WIDTH: 1023 value = static_cast<int32_t>(mCore->mDefaultWidth); 1024 break; 1025 case NATIVE_WINDOW_HEIGHT: 1026 value = static_cast<int32_t>(mCore->mDefaultHeight); 1027 break; 1028 case NATIVE_WINDOW_FORMAT: 1029 value = static_cast<int32_t>(mCore->mDefaultBufferFormat); 1030 break; 1031 case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS: 1032 value = mCore->getMinUndequeuedBufferCountLocked(); 1033 break; 1034 case NATIVE_WINDOW_STICKY_TRANSFORM: 1035 value = static_cast<int32_t>(mStickyTransform); 1036 break; 1037 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: 1038 value = (mCore->mQueue.size() > 1); 1039 break; 1040 case NATIVE_WINDOW_CONSUMER_USAGE_BITS: 1041 value = static_cast<int32_t>(mCore->mConsumerUsageBits); 1042 break; 1043 case NATIVE_WINDOW_DEFAULT_DATASPACE: 1044 value = static_cast<int32_t>(mCore->mDefaultBufferDataSpace); 1045 break; 1046 case NATIVE_WINDOW_BUFFER_AGE: 1047 if (mCore->mBufferAge > INT32_MAX) { 1048 value = 0; 1049 } else { 1050 value = static_cast<int32_t>(mCore->mBufferAge); 1051 } 1052 break; 1053 default: 1054 return BAD_VALUE; 1055 } 1056 1057 BQ_LOGV("query: %d? %d", what, value); 1058 *outValue = value; 1059 return NO_ERROR; 1060} 1061 1062status_t BufferQueueProducer::connect(const sp<IProducerListener>& listener, 1063 int api, bool producerControlledByApp, QueueBufferOutput *output) { 1064 ATRACE_CALL(); 1065 Mutex::Autolock lock(mCore->mMutex); 1066 mConsumerName = mCore->mConsumerName; 1067 BQ_LOGV("connect: api=%d producerControlledByApp=%s", api, 1068 producerControlledByApp ? "true" : "false"); 1069 1070 if (mCore->mIsAbandoned) { 1071 BQ_LOGE("connect: BufferQueue has been abandoned"); 1072 return NO_INIT; 1073 } 1074 1075 if (mCore->mConsumerListener == NULL) { 1076 BQ_LOGE("connect: BufferQueue has no consumer"); 1077 return NO_INIT; 1078 } 1079 1080 if (output == NULL) { 1081 BQ_LOGE("connect: output was NULL"); 1082 return BAD_VALUE; 1083 } 1084 1085 if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) { 1086 BQ_LOGE("connect: already connected (cur=%d req=%d)", 1087 mCore->mConnectedApi, api); 1088 return BAD_VALUE; 1089 } 1090 1091 int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode, 1092 mDequeueTimeout < 0 ? 1093 mCore->mConsumerControlledByApp && producerControlledByApp : false, 1094 mCore->mMaxBufferCount) - 1095 mCore->getMaxBufferCountLocked(); 1096 if (!mCore->adjustAvailableSlotsLocked(delta)) { 1097 BQ_LOGE("connect: BufferQueue failed to adjust the number of available " 1098 "slots. Delta = %d", delta); 1099 return BAD_VALUE; 1100 } 1101 1102 int status = NO_ERROR; 1103 switch (api) { 1104 case NATIVE_WINDOW_API_EGL: 1105 case NATIVE_WINDOW_API_CPU: 1106 case NATIVE_WINDOW_API_MEDIA: 1107 case NATIVE_WINDOW_API_CAMERA: 1108 mCore->mConnectedApi = api; 1109 output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight, 1110 mCore->mTransformHint, 1111 static_cast<uint32_t>(mCore->mQueue.size()), 1112 mCore->mFrameCounter + 1); 1113 1114 // Set up a death notification so that we can disconnect 1115 // automatically if the remote producer dies 1116 if (listener != NULL && 1117 IInterface::asBinder(listener)->remoteBinder() != NULL) { 1118 status = IInterface::asBinder(listener)->linkToDeath( 1119 static_cast<IBinder::DeathRecipient*>(this)); 1120 if (status != NO_ERROR) { 1121 BQ_LOGE("connect: linkToDeath failed: %s (%d)", 1122 strerror(-status), status); 1123 } 1124 } 1125 mCore->mConnectedProducerListener = listener; 1126 break; 1127 default: 1128 BQ_LOGE("connect: unknown API %d", api); 1129 status = BAD_VALUE; 1130 break; 1131 } 1132 1133 mCore->mBufferHasBeenQueued = false; 1134 mCore->mDequeueBufferCannotBlock = false; 1135 if (mDequeueTimeout < 0) { 1136 mCore->mDequeueBufferCannotBlock = 1137 mCore->mConsumerControlledByApp && producerControlledByApp; 1138 } 1139 1140 mCore->mAllowAllocation = true; 1141 VALIDATE_CONSISTENCY(); 1142 return status; 1143} 1144 1145status_t BufferQueueProducer::disconnect(int api) { 1146 ATRACE_CALL(); 1147 BQ_LOGV("disconnect: api %d", api); 1148 1149 int status = NO_ERROR; 1150 sp<IConsumerListener> listener; 1151 { // Autolock scope 1152 Mutex::Autolock lock(mCore->mMutex); 1153 mCore->waitWhileAllocatingLocked(); 1154 1155 if (mCore->mIsAbandoned) { 1156 // It's not really an error to disconnect after the surface has 1157 // been abandoned; it should just be a no-op. 1158 return NO_ERROR; 1159 } 1160 1161 if (api == BufferQueueCore::CURRENTLY_CONNECTED_API) { 1162 api = mCore->mConnectedApi; 1163 // If we're asked to disconnect the currently connected api but 1164 // nobody is connected, it's not really an error. 1165 if (api == BufferQueueCore::NO_CONNECTED_API) { 1166 return NO_ERROR; 1167 } 1168 } 1169 1170 switch (api) { 1171 case NATIVE_WINDOW_API_EGL: 1172 case NATIVE_WINDOW_API_CPU: 1173 case NATIVE_WINDOW_API_MEDIA: 1174 case NATIVE_WINDOW_API_CAMERA: 1175 if (mCore->mConnectedApi == api) { 1176 mCore->freeAllBuffersLocked(); 1177 1178 // Remove our death notification callback if we have one 1179 if (mCore->mConnectedProducerListener != NULL) { 1180 sp<IBinder> token = 1181 IInterface::asBinder(mCore->mConnectedProducerListener); 1182 // This can fail if we're here because of the death 1183 // notification, but we just ignore it 1184 token->unlinkToDeath( 1185 static_cast<IBinder::DeathRecipient*>(this)); 1186 } 1187 mCore->mSharedBufferSlot = 1188 BufferQueueCore::INVALID_BUFFER_SLOT; 1189 mCore->mConnectedProducerListener = NULL; 1190 mCore->mConnectedApi = BufferQueueCore::NO_CONNECTED_API; 1191 mCore->mSidebandStream.clear(); 1192 mCore->mDequeueCondition.broadcast(); 1193 listener = mCore->mConsumerListener; 1194 } else if (mCore->mConnectedApi != BufferQueueCore::NO_CONNECTED_API) { 1195 BQ_LOGE("disconnect: still connected to another API " 1196 "(cur=%d req=%d)", mCore->mConnectedApi, api); 1197 status = BAD_VALUE; 1198 } 1199 break; 1200 default: 1201 BQ_LOGE("disconnect: unknown API %d", api); 1202 status = BAD_VALUE; 1203 break; 1204 } 1205 } // Autolock scope 1206 1207 // Call back without lock held 1208 if (listener != NULL) { 1209 listener->onBuffersReleased(); 1210 } 1211 1212 return status; 1213} 1214 1215status_t BufferQueueProducer::setSidebandStream(const sp<NativeHandle>& stream) { 1216 sp<IConsumerListener> listener; 1217 { // Autolock scope 1218 Mutex::Autolock _l(mCore->mMutex); 1219 mCore->mSidebandStream = stream; 1220 listener = mCore->mConsumerListener; 1221 } // Autolock scope 1222 1223 if (listener != NULL) { 1224 listener->onSidebandStreamChanged(); 1225 } 1226 return NO_ERROR; 1227} 1228 1229void BufferQueueProducer::allocateBuffers(uint32_t width, uint32_t height, 1230 PixelFormat format, uint32_t usage) { 1231 ATRACE_CALL(); 1232 while (true) { 1233 size_t newBufferCount = 0; 1234 uint32_t allocWidth = 0; 1235 uint32_t allocHeight = 0; 1236 PixelFormat allocFormat = PIXEL_FORMAT_UNKNOWN; 1237 uint32_t allocUsage = 0; 1238 { // Autolock scope 1239 Mutex::Autolock lock(mCore->mMutex); 1240 mCore->waitWhileAllocatingLocked(); 1241 1242 if (!mCore->mAllowAllocation) { 1243 BQ_LOGE("allocateBuffers: allocation is not allowed for this " 1244 "BufferQueue"); 1245 return; 1246 } 1247 1248 newBufferCount = mCore->mFreeSlots.size(); 1249 if (newBufferCount == 0) { 1250 return; 1251 } 1252 1253 allocWidth = width > 0 ? width : mCore->mDefaultWidth; 1254 allocHeight = height > 0 ? height : mCore->mDefaultHeight; 1255 allocFormat = format != 0 ? format : mCore->mDefaultBufferFormat; 1256 allocUsage = usage | mCore->mConsumerUsageBits; 1257 1258 mCore->mIsAllocating = true; 1259 } // Autolock scope 1260 1261 Vector<sp<GraphicBuffer>> buffers; 1262 for (size_t i = 0; i < newBufferCount; ++i) { 1263 status_t result = NO_ERROR; 1264 sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer( 1265 allocWidth, allocHeight, allocFormat, allocUsage, &result)); 1266 if (result != NO_ERROR) { 1267 BQ_LOGE("allocateBuffers: failed to allocate buffer (%u x %u, format" 1268 " %u, usage %u)", width, height, format, usage); 1269 Mutex::Autolock lock(mCore->mMutex); 1270 mCore->mIsAllocating = false; 1271 mCore->mIsAllocatingCondition.broadcast(); 1272 return; 1273 } 1274 buffers.push_back(graphicBuffer); 1275 } 1276 1277 { // Autolock scope 1278 Mutex::Autolock lock(mCore->mMutex); 1279 uint32_t checkWidth = width > 0 ? width : mCore->mDefaultWidth; 1280 uint32_t checkHeight = height > 0 ? height : mCore->mDefaultHeight; 1281 PixelFormat checkFormat = format != 0 ? 1282 format : mCore->mDefaultBufferFormat; 1283 uint32_t checkUsage = usage | mCore->mConsumerUsageBits; 1284 if (checkWidth != allocWidth || checkHeight != allocHeight || 1285 checkFormat != allocFormat || checkUsage != allocUsage) { 1286 // Something changed while we released the lock. Retry. 1287 BQ_LOGV("allocateBuffers: size/format/usage changed while allocating. Retrying."); 1288 mCore->mIsAllocating = false; 1289 mCore->mIsAllocatingCondition.broadcast(); 1290 continue; 1291 } 1292 1293 for (size_t i = 0; i < newBufferCount; ++i) { 1294 if (mCore->mFreeSlots.empty()) { 1295 BQ_LOGV("allocateBuffers: a slot was occupied while " 1296 "allocating. Dropping allocated buffer."); 1297 continue; 1298 } 1299 auto slot = mCore->mFreeSlots.begin(); 1300 mCore->clearBufferSlotLocked(*slot); // Clean up the slot first 1301 mSlots[*slot].mGraphicBuffer = buffers[i]; 1302 mSlots[*slot].mFence = Fence::NO_FENCE; 1303 1304 // freeBufferLocked puts this slot on the free slots list. Since 1305 // we then attached a buffer, move the slot to free buffer list. 1306 mCore->mFreeBuffers.push_front(*slot); 1307 1308 BQ_LOGV("allocateBuffers: allocated a new buffer in slot %d", 1309 *slot); 1310 1311 // Make sure the erase is done after all uses of the slot 1312 // iterator since it will be invalid after this point. 1313 mCore->mFreeSlots.erase(slot); 1314 } 1315 1316 mCore->mIsAllocating = false; 1317 mCore->mIsAllocatingCondition.broadcast(); 1318 VALIDATE_CONSISTENCY(); 1319 } // Autolock scope 1320 } 1321} 1322 1323status_t BufferQueueProducer::allowAllocation(bool allow) { 1324 ATRACE_CALL(); 1325 BQ_LOGV("allowAllocation: %s", allow ? "true" : "false"); 1326 1327 Mutex::Autolock lock(mCore->mMutex); 1328 mCore->mAllowAllocation = allow; 1329 return NO_ERROR; 1330} 1331 1332status_t BufferQueueProducer::setGenerationNumber(uint32_t generationNumber) { 1333 ATRACE_CALL(); 1334 BQ_LOGV("setGenerationNumber: %u", generationNumber); 1335 1336 Mutex::Autolock lock(mCore->mMutex); 1337 mCore->mGenerationNumber = generationNumber; 1338 return NO_ERROR; 1339} 1340 1341String8 BufferQueueProducer::getConsumerName() const { 1342 ATRACE_CALL(); 1343 BQ_LOGV("getConsumerName: %s", mConsumerName.string()); 1344 return mConsumerName; 1345} 1346 1347status_t BufferQueueProducer::setSharedBufferMode(bool sharedBufferMode) { 1348 ATRACE_CALL(); 1349 BQ_LOGV("setSharedBufferMode: %d", sharedBufferMode); 1350 1351 Mutex::Autolock lock(mCore->mMutex); 1352 if (!sharedBufferMode) { 1353 mCore->mSharedBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT; 1354 } 1355 mCore->mSharedBufferMode = sharedBufferMode; 1356 return NO_ERROR; 1357} 1358 1359status_t BufferQueueProducer::setAutoRefresh(bool autoRefresh) { 1360 ATRACE_CALL(); 1361 BQ_LOGV("setAutoRefresh: %d", autoRefresh); 1362 1363 Mutex::Autolock lock(mCore->mMutex); 1364 1365 mCore->mAutoRefresh = autoRefresh; 1366 return NO_ERROR; 1367} 1368 1369status_t BufferQueueProducer::setDequeueTimeout(nsecs_t timeout) { 1370 ATRACE_CALL(); 1371 BQ_LOGV("setDequeueTimeout: %" PRId64, timeout); 1372 1373 Mutex::Autolock lock(mCore->mMutex); 1374 int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode, false, 1375 mCore->mMaxBufferCount) - mCore->getMaxBufferCountLocked(); 1376 if (!mCore->adjustAvailableSlotsLocked(delta)) { 1377 BQ_LOGE("setDequeueTimeout: BufferQueue failed to adjust the number of " 1378 "available slots. Delta = %d", delta); 1379 return BAD_VALUE; 1380 } 1381 1382 mDequeueTimeout = timeout; 1383 mCore->mDequeueBufferCannotBlock = false; 1384 1385 VALIDATE_CONSISTENCY(); 1386 return NO_ERROR; 1387} 1388 1389status_t BufferQueueProducer::getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer, 1390 sp<Fence>* outFence, float outTransformMatrix[16]) { 1391 ATRACE_CALL(); 1392 BQ_LOGV("getLastQueuedBuffer"); 1393 1394 Mutex::Autolock lock(mCore->mMutex); 1395 if (mCore->mLastQueuedSlot == BufferItem::INVALID_BUFFER_SLOT) { 1396 *outBuffer = nullptr; 1397 *outFence = Fence::NO_FENCE; 1398 return NO_ERROR; 1399 } 1400 1401 *outBuffer = mSlots[mCore->mLastQueuedSlot].mGraphicBuffer; 1402 *outFence = mLastQueueBufferFence; 1403 1404 // Currently only SurfaceFlinger internally ever changes 1405 // GLConsumer's filtering mode, so we just use 'true' here as 1406 // this is slightly specialized for the current client of this API, 1407 // which does want filtering. 1408 GLConsumer::computeTransformMatrix(outTransformMatrix, 1409 mSlots[mCore->mLastQueuedSlot].mGraphicBuffer, mLastQueuedCrop, 1410 mLastQueuedTransform, true /* filter */); 1411 1412 return NO_ERROR; 1413} 1414 1415bool BufferQueueProducer::getFrameTimestamps(uint64_t frameNumber, 1416 FrameTimestamps* outTimestamps) const { 1417 ATRACE_CALL(); 1418 BQ_LOGV("getFrameTimestamps, %" PRIu64, frameNumber); 1419 sp<IConsumerListener> listener; 1420 1421 { 1422 Mutex::Autolock lock(mCore->mMutex); 1423 listener = mCore->mConsumerListener; 1424 } 1425 if (listener != NULL) { 1426 return listener->getFrameTimestamps(frameNumber, outTimestamps); 1427 } 1428 return false; 1429} 1430 1431void BufferQueueProducer::binderDied(const wp<android::IBinder>& /* who */) { 1432 // If we're here, it means that a producer we were connected to died. 1433 // We're guaranteed that we are still connected to it because we remove 1434 // this callback upon disconnect. It's therefore safe to read mConnectedApi 1435 // without synchronization here. 1436 int api = mCore->mConnectedApi; 1437 disconnect(api); 1438} 1439 1440status_t BufferQueueProducer::getUniqueId(uint64_t* outId) const { 1441 BQ_LOGV("getUniqueId"); 1442 1443 *outId = mCore->mUniqueId; 1444 return NO_ERROR; 1445} 1446 1447} // namespace android 1448