{"id":70126,"date":"2026-02-01T15:35:49","date_gmt":"2026-02-01T07:35:49","guid":{"rendered":"https:\/\/www.wsisp.com\/helps\/70126.html"},"modified":"2026-02-01T15:35:49","modified_gmt":"2026-02-01T07:35:49","slug":"%e5%9b%be%e5%83%8f%e6%98%be%e7%a4%ba%e6%a1%86%e6%9e%b6%e5%8d%81%e4%b8%89-bufferqueue%e7%9a%84%e5%b7%a5%e4%bd%9c%e6%b5%81%e7%a8%8b%ef%bc%88%e5%9f%ba%e4%ba%8eandroid-15%e6%ba%90","status":"publish","type":"post","link":"https:\/\/www.wsisp.com\/helps\/70126.html","title":{"rendered":"\u56fe\u50cf\u663e\u793a\u6846\u67b6\u5341\u4e09\u2014\u2014BufferQueue\u7684\u5de5\u4f5c\u6d41\u7a0b\uff08\u57fa\u4e8eAndroid 15\u6e90\u7801\u5206\u6790\uff09"},"content":{"rendered":"<\/p>\n

\u4e00.\u524d\u8a00<\/h2>\n

\u4e66\u63a5\u4e0a\u56de，\u6211\u4eec\u8bf4\u5230\u4e86\u901a\u8fc7acquireNextBufferLocked\u83b7\u53d6\u53ef\u7528\u7684\u7f13\u51b2\u533a，\u8fd9\u91cc\u6211\u4eec\u7ee7\u7eed\u4ece\u8fd9BLASTBufferQueue\u4e2d\u7684onFrameAvailable\u51fd\u6570\u8c03\u7528\u5230acquireNextBufferLocked\u8bf4\u8d77，\u8fd9\u91cc\u6211\u4eec\u5728\u7ee7\u7eed\u8d34\u4e00\u4e0b\u751f\u4ea7\u8005\u6d88\u8d39\u8005\u6a21\u578b\u7684\u7b80\u7565\u6d41\u7a0b\u56fe<\/p>\n

\"\"<\/p>\n

\u6e90\u7801\u4f4d\u7f6e：<\/p>\n

framework\/native\/libs\/gui\/BLASTBufferQueue.cpp<\/p>\n

framework\/native\/include\/gui\/BufferItemConsumer.h<\/p>\n

framework\/native\/libs\/gui\/BufferItemConsumer.cpp<\/p>\n

framework\/native\/libs\/gui\/ConsumerBase.cpp<\/p>\n

framework\/native\/libs\/gui\/BufferQueueConsumer.cpp<\/p>\n<\/p>\n

\u4e8c.\u6d88\u8d39\u8005\u83b7\u53d6\u7f13\u51b2\u533a<\/h2>\n

BLASTBufferQueue::acquireNextBufferLocked<\/h3>\n

\u7ee7\u7eed\u63a5\u4e0a\u9762\u7684acquireNextBufferLocked\u51fd\u6570，\u5728\u524d\u9762\u7684\u6587\u7ae0\u6211\u4eec\u57fa\u672c\u4e86\u89e3\u4e86BufferQueueProducer\u4e0eBufferQueueCore，\u8fd9\u91cc\u6211\u4eec\u6765\u770b\u53e6\u4e00\u4e2a\u91cd\u8981\u7684\u89d2\u8272：BufferQueueConsumer，\u5982\u4e0b\u662f\u4e4b\u524d\u7684acquireNextBufferLocked\u51fd\u6570，\u6211\u4eec\u8d34\u4e00\u4e0b，\u7ee7\u7eed\u8fdb\u884c\u5206\u6790<\/p>\n

\/\/ \u83b7\u53d6\u4e0b\u4e00\u4e2a\u53ef\u7528\u7f13\u51b2\u533a\u7684\u6838\u5fc3\u51fd\u6570
\n\/\/ \u53c2\u6570 transaction: \u53ef\u9009\u7684\u5916\u90e8\u4e8b\u52a1\u5bf9\u8c61\u3002\u5982\u679c\u63d0\u4f9b，\u5219\u4f7f\u7528\u5916\u90e8\u4e8b\u52a1；\u5426\u5219\u521b\u5efa\u672c\u5730\u4e8b\u52a1\u5e76\u7acb\u5373\u5e94\u7528
\nstatus_t BLASTBufferQueue::acquireNextBufferLocked(
\n const std::optional<SurfaceComposerClient::Transaction*> transaction) {
\n \/\/ 1. \u68c0\u67e5\u662f\u5426\u6ee1\u8db3\u83b7\u53d6\u6761\u4ef6：\u6709\u53ef\u7528\u5e27\u4e14\u672a\u8d85\u8fc7\u6700\u5927\u83b7\u53d6\u6570\u91cf\u9650\u5236
\n if (mNumFrameAvailable == 0) {
\n BQA_LOGV("Can't acquire next buffer. No available frames");
\n return BufferQueue::NO_BUFFER_AVAILABLE;
\n }<\/p>\n

\/\/ \u989d\u5916\u68c0\u67e5：\u9632\u6b62\u83b7\u53d6\u8fc7\u591a\u7f13\u51b2\u533a（\u6700\u5927\u83b7\u53d6\u6570+2\u4f5c\u4e3a\u5b89\u5168\u8fb9\u754c）
\n if (mNumAcquired >= (mMaxAcquiredBuffers + 2)) {
\n BQA_LOGV("Can't acquire next buffer. Already acquired max frames %d max:%d + 2",
\n mNumAcquired, mMaxAcquiredBuffers);
\n return BufferQueue::NO_BUFFER_AVAILABLE;
\n }<\/p>\n

\/\/ 2. \u9a8c\u8bc1SurfaceControl\u662f\u5426\u5b58\u5728
\n if (mSurfaceControl == nullptr) {
\n BQA_LOGE("ERROR : surface control is null");
\n return NAME_NOT_FOUND;
\n }<\/p>\n

\/\/ 3. \u4e8b\u52a1\u5904\u7406\u51c6\u5907：\u51b3\u5b9a\u4f7f\u7528\u5916\u90e8\u4e8b\u52a1\u8fd8\u662f\u521b\u5efa\u672c\u5730\u4e8b\u52a1
\n SurfaceComposerClient::Transaction localTransaction;
\n bool applyTransaction = true; \/\/ \u9ed8\u8ba4\u9700\u8981\u7acb\u5373\u5e94\u7528\u4e8b\u52a1
\n SurfaceComposerClient::Transaction* t = &localTransaction;<\/p>\n

if (transaction) {
\n t = *transaction; \/\/ \u4f7f\u7528\u5916\u90e8\u63d0\u4f9b\u7684\u4e8b\u52a1
\n applyTransaction = false; \/\/ \u5916\u90e8\u4e8b\u52a1\u7531\u8c03\u7528\u8005\u8d1f\u8d23\u5e94\u7528
\n }<\/p>\n

BufferItem bufferItem;<\/p>\n

\/\/ 4. \u4eceBufferQueueConsumer\u4e2d\u83b7\u53d6\u7f13\u51b2\u533a
\n status_t status = mBufferItemConsumer->acquireBuffer(&bufferItem, 0 \/* expectedPresent *\/, false);
\n if (status == BufferQueue::NO_BUFFER_AVAILABLE) {
\n BQA_LOGV("Failed to acquire a buffer, err=NO_BUFFER_AVAILABLE");
\n return status;
\n } else if (status != OK) {
\n BQA_LOGE("Failed to acquire a buffer, err=%s", statusToString(status).c_str());
\n return status;
\n }<\/p>\n

\/\/ 5. \u83b7\u53d6\u56fe\u5f62\u7f13\u51b2\u533a\u5f15\u7528\u5e76\u66f4\u65b0\u8ba1\u6570\u5668
\n auto buffer = bufferItem.mGraphicBuffer;
\n mNumFrameAvailable–; \/\/ \u53ef\u7528\u5e27\u6570\u51cf1
\n BBQ_TRACE("frame=%" PRIu64, bufferItem.mFrameNumber);<\/p>\n

\/\/ 6. \u7f13\u51b2\u533a\u6709\u6548\u6027\u68c0\u67e5
\n if (buffer == nullptr) {
\n mBufferItemConsumer->releaseBuffer(bufferItem, Fence::NO_FENCE);
\n BQA_LOGE("Buffer was empty");
\n return BAD_VALUE;
\n }<\/p>\n

\/\/ 7. \u7f13\u51b2\u533a\u62d2\u7edd\u68c0\u67e5：\u5982\u679c\u7f13\u51b2\u533a\u5c3a\u5bf8\u4e0d\u5339\u914d\u5f53\u524d\u9700\u6c42\u5219\u62d2\u7edd
\n if (rejectBuffer(bufferItem)) {
\n BQA_LOGE("rejecting buffer:active_size=%dx%d, requested_size=%dx%d "
\n "buffer{size=%dx%d transform=%d}",
\n mSize.width, mSize.height, mRequestedSize.width, mRequestedSize.height,
\n buffer->getWidth(), buffer->getHeight(), bufferItem.mTransform);
\n mBufferItemConsumer->releaseBuffer(bufferItem, Fence::NO_FENCE);
\n \/\/ \u9012\u5f52\u5c1d\u8bd5\u83b7\u53d6\u4e0b\u4e00\u4e2a\u7f13\u51b2\u533a
\n return acquireNextBufferLocked(transaction);
\n }<\/p>\n

\/\/ 8. \u66f4\u65b0\u83b7\u53d6\u72b6\u6001\u548c\u8bb0\u5f55\u4fe1\u606f
\n mNumAcquired++; \/\/ \u5df2\u83b7\u53d6\u7f13\u51b2\u533a\u8ba1\u6570\u52a01
\n mLastAcquiredFrameNumber = bufferItem.mFrameNumber;
\n ReleaseCallbackId releaseCallbackId(buffer->getId(), mLastAcquiredFrameNumber);
\n mSubmitted[releaseCallbackId] = bufferItem; \/\/ \u8bb0\u5f55\u5df2\u63d0\u4ea4\u7684\u7f13\u51b2\u533a<\/p>\n

\/\/ 9. \u68c0\u67e5\u751f\u4ea7\u8005\u8fde\u63a5\u72b6\u6001
\n bool needsDisconnect = false;
\n mBufferItemConsumer->getConnectionEvents(bufferItem.mFrameNumber, &needsDisconnect);
\n if (needsDisconnect) {
\n t->notifyProducerDisconnect(mSurfaceControl); \/\/ \u901a\u77e5SurfaceFlinger\u751f\u4ea7\u8005\u5df2\u65ad\u5f00
\n }<\/p>\n

\/\/ 10. \u589e\u52a0\u5f15\u7528\u8ba1\u6570，\u786e\u4fdd\u5728\u4e8b\u52a1\u5b8c\u6210\u56de\u8c03\u524dBLASTBufferQueue\u4e0d\u88ab\u9500\u6bc1
\n incStrong((void*)transactionCallbackThunk);<\/p>\n

\/\/ 11. \u66f4\u65b0\u5c3a\u5bf8\u4fe1\u606f：\u53ea\u6709\u5f53\u7f13\u51b2\u533a\u5c3a\u5bf8\u5339\u914d\u8bf7\u6c42\u5c3a\u5bf8\u6216\u975e\u51bb\u7ed3\u7f29\u653e\u6a21\u5f0f\u65f6\u624d\u66f4\u65b0
\n if (mRequestedSize == getBufferSize(bufferItem) ||
\n bufferItem.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE) {
\n mSize = mRequestedSize;
\n }<\/p>\n

\/\/ 12. \u8ba1\u7b97\u88c1\u526a\u533a\u57df\u5e76\u66f4\u65b0\u6700\u540e\u7f13\u51b2\u533a\u4fe1\u606f
\n Rect crop = computeCrop(bufferItem);
\n mLastBufferInfo.update(true \/* hasBuffer *\/, bufferItem.mGraphicBuffer->getWidth(),
\n bufferItem.mGraphicBuffer->getHeight(), bufferItem.mTransform,
\n bufferItem.mScalingMode, crop);<\/p>\n

\/\/ 13. \u51c6\u5907\u7f13\u51b2\u533a\u91ca\u653e\u56de\u8c03\u51fd\u6570
\n auto releaseBufferCallback =
\n std::bind(releaseBufferCallbackThunk, wp<BLASTBufferQueue>(this) \/* callbackContext *\/,
\n std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);<\/p>\n

\/\/ 14. \u590d\u5236\u6805\u680f\u5bf9\u8c61（\u7528\u4e8e\u540c\u6b65）
\n sp<Fence> fence = bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE;<\/p>\n

\/\/ 15. \u67e5\u627e\u51fa\u961f\u65f6\u95f4\u6233（\u7528\u4e8e\u6027\u80fd\u76d1\u63a7）
\n nsecs_t dequeueTime = -1;
\n {
\n std::lock_guard _lock{mTimestampMutex};
\n auto dequeueTimeIt = mDequeueTimestamps.find(buffer->getId());
\n if (dequeueTimeIt != mDequeueTimestamps.end()) {
\n dequeueTime = dequeueTimeIt->second;
\n mDequeueTimestamps.erase(dequeueTimeIt);
\n }
\n }<\/p>\n

\/\/ 16. \u914d\u7f6e\u4e8b\u52a1\u7684\u5404\u9879\u53c2\u6570
\n t->setBuffer(mSurfaceControl, buffer, fence, bufferItem.mFrameNumber, mProducerId,
\n releaseBufferCallback, dequeueTime);
\n t->setDataspace(mSurfaceControl, static_cast<ui::Dataspace>(bufferItem.mDataSpace));
\n t->setHdrMetadata(mSurfaceControl, bufferItem.mHdrMetadata);
\n t->setSurfaceDamageRegion(mSurfaceControl, bufferItem.mSurfaceDamage);
\n t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));<\/p>\n

mSurfaceControlsWithPendingCallback.push(mSurfaceControl);<\/p>\n

\/\/ 17. \u8bbe\u7f6e\u76ee\u6807\u5e27\u548c\u6807\u5fd7
\n if (mUpdateDestinationFrame) {
\n t->setDestinationFrame(mSurfaceControl, Rect(mSize));
\n } else {
\n const bool ignoreDestinationFrame =
\n bufferItem.mScalingMode == NATIVE_WINDOW_SCALING_MODE_FREEZE;
\n t->setFlags(mSurfaceControl,
\n ignoreDestinationFrame ? layer_state_t::eIgnoreDestinationFrame : 0,
\n layer_state_t::eIgnoreDestinationFrame);
\n }<\/p>\n

\/\/ 18. \u8bbe\u7f6e\u5176\u4ed6\u663e\u793a\u5c5e\u6027
\n t->setBufferCrop(mSurfaceControl, crop);
\n t->setTransform(mSurfaceControl, bufferItem.mTransform);
\n t->setTransformToDisplayInverse(mSurfaceControl, bufferItem.mTransformToDisplayInverse);
\n t->setAutoRefresh(mSurfaceControl, bufferItem.mAutoRefresh);
\n if (!bufferItem.mIsAutoTimestamp) {
\n t->setDesiredPresentTime(bufferItem.mTimestamp); \/\/ \u8bbe\u7f6e\u671f\u671b\u663e\u793a\u65f6\u95f4
\n }<\/p>\n

\/\/ 19. \u5904\u7406\u5e27\u65f6\u95f4\u7ebf\u4fe1\u606f：\u6e05\u7406\u8fc7\u65f6\u7684，\u8bbe\u7f6e\u5339\u914d\u7684
\n while (!mPendingFrameTimelines.empty() &&
\n mPendingFrameTimelines.front().first < bufferItem.mFrameNumber) {
\n ATRACE_FORMAT_INSTANT("dropping stale frameNumber: %" PRIu64 " vsyncId: %" PRId64,
\n mPendingFrameTimelines.front().first,
\n mPendingFrameTimelines.front().second.vsyncId);
\n mPendingFrameTimelines.pop();
\n }<\/p>\n

if (!mPendingFrameTimelines.empty() &&
\n mPendingFrameTimelines.front().first == bufferItem.mFrameNumber) {
\n ATRACE_FORMAT_INSTANT("Transaction::setFrameTimelineInfo frameNumber: %" PRIu64
\n " vsyncId: %" PRId64,
\n bufferItem.mFrameNumber,
\n mPendingFrameTimelines.front().second.vsyncId);
\n t->setFrameTimelineInfo(mPendingFrameTimelines.front().second);
\n mPendingFrameTimelines.pop();
\n }<\/p>\n

\/\/ 20. \u5408\u5e76\u6302\u8d77\u7684\u4e8b\u52a1
\n mergePendingTransactions(t, bufferItem.mFrameNumber);<\/p>\n

\/\/ 21. \u5e94\u7528\u4e8b\u52a1\u6216\u8bbe\u7f6e\u5c4f\u969c
\n if (applyTransaction) {
\n \/\/ \u4f7f\u7528\u5e94\u7528\u4ee4\u724c\u5e94\u7528\u4e8b\u52a1（\u5355\u5411\u64cd\u4f5c）
\n t->setApplyToken(mApplyToken).apply(false, true);
\n mAppliedLastTransaction = true;
\n mLastAppliedFrameNumber = bufferItem.mFrameNumber;
\n } else {
\n \/\/ \u8bbe\u7f6e\u7f13\u51b2\u533a\u5c4f\u969c，\u786e\u4fdd\u4e8b\u52a1\u987a\u5e8f
\n t->setBufferHasBarrier(mSurfaceControl, mLastAppliedFrameNumber);
\n mAppliedLastTransaction = false;
\n }<\/p>\n

\/\/ 22. \u8bb0\u5f55\u8be6\u7ec6\u65e5\u5fd7
\n BQA_LOGV("acquireNextBufferLocked size=%dx%d mFrameNumber=%" PRIu64
\n " applyTransaction=%s mTimestamp=%" PRId64 "%s mPendingTransactions.size=%d"
\n " graphicBufferId=%" PRIu64 "%s transform=%d",
\n mSize.width, mSize.height, bufferItem.mFrameNumber, boolToString(applyTransaction),
\n bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp ? "(auto)" : "",
\n static_cast<uint32_t>(mPendingTransactions.size()), bufferItem.mGraphicBuffer->getId(),
\n bufferItem.mAutoRefresh ? " mAutoRefresh" : "", bufferItem.mTransform);<\/p>\n

return OK;
\n} <\/p>\n

\u51fd\u6570\u7684\u6838\u5fc3\u4f5c\u7528\u603b\u7ed3：<\/p>\n

\u8fd9\u4e2a\u51fd\u6570\u662f\u6d88\u8d39\u7aef\u5904\u7406\u7f13\u51b2\u533a\u7684\u5173\u952e\u73af\u8282，\u4e3b\u8981\u5b8c\u6210\u4ee5\u4e0b\u4efb\u52a1：<\/p>\n

1.\u6761\u4ef6\u68c0\u67e5：\u9a8c\u8bc1\u662f\u5426\u6709\u53ef\u7528\u7f13\u51b2\u533a\u4e14\u672a\u8d85\u8fc7\u9650\u5236<\/p>\n

2.\u7f13\u51b2\u533a\u83b7\u53d6：\u4eceBufferQueueConsumer\u4e2d\u5b9e\u9645\u83b7\u53d6\u4e00\u4e2aBufferItem<\/p>\n

3.\u7f13\u51b2\u533a\u9a8c\u8bc1：\u68c0\u67e5\u7f13\u51b2\u533a\u6709\u6548\u6027，\u62d2\u7edd\u4e0d\u7b26\u5408\u6761\u4ef6\u7684\u7f13\u51b2\u533a<\/p>\n

4.\u4e8b\u52a1\u914d\u7f6e：\u5c06\u7f13\u51b2\u533a\u53ca\u5176\u5c5e\u6027（\u5c3a\u5bf8\u3001\u88c1\u526a\u3001\u53d8\u5316\u3001HDR\u5143\u6570\u636e\u7b49）\u8bbe\u7f6e\u5230\u4e8b\u52a1\u4e2d<\/p>\n

5.\u540c\u6b65\u5904\u7406：\u5904\u7406\u73ca\u680f\u540c\u6b65\u548c\u65f6\u95f4\u6233<\/p>\n

6.\u4e8b\u52a1\u63d0\u4ea4：\u6839\u636e\u60c5\u51b5\u7acb\u5373\u5e94\u7528\u4e8b\u52a1\u6216\u51c6\u5907\u5916\u90e8\u4e8b\u52a1<\/p>\n

7.\u72b6\u6001\u8ddf\u8e2a：\u7ef4\u62a4\u7f13\u51b2\u533a\u83b7\u53d6\u72b6\u6001\u548c\u56de\u8c03\u4fe1\u606f<\/p>\n<\/p>\n

\u4e0a\u8ff0\u6211\u4eec\u91cd\u70b9\u5982\u4f55\u4eceBufferQueueConsumer\u4e2d\u83b7\u53d6\u5230\u4e00\u4e2aBufferItem\u7684，\u4e0a\u8ff0\u7684mBufferItemConsumer->acquireBuffer\u662f\u8c03\u7528\u5230BufferItemConsumer\u7684acquireBuffer\u51fd\u6570，\u5982\u4e0b<\/p>\n

<\/h3>\n

BufferItemConsumer::acquireBuffer<\/h3>\n

\u6e90\u4ee3\u7801\u5982\u4e0b：<\/p>\n

\/\/ \u4eceBufferQueue\u4e2d\u83b7\u53d6\u4e00\u4e2a\u5df2\u586b\u5145\u6570\u636e\u7684\u7f13\u51b2\u533a
\n\/\/ \u53c2\u6570：
\n\/\/ item – \u8f93\u51fa\u53c2\u6570，\u7528\u4e8e\u8fd4\u56de\u83b7\u53d6\u5230\u7684\u7f13\u51b2\u533a\u4fe1\u606f
\n\/\/ presentWhen – \u671f\u671b\u7684\u663e\u793a\u65f6\u95f4（\u7528\u4e8e\u7f13\u51b2\u533a\u8c03\u5ea6\u51b3\u7b56）
\n\/\/ waitForFence – \u662f\u5426\u7b49\u5f85\u6805\u680f\u4fe1\u53f7（\u786e\u4fdd\u7f13\u51b2\u533a\u6570\u636e\u5c31\u7eea）
\nstatus_t BufferItemConsumer::acquireBuffer(BufferItem *item,
\n nsecs_t presentWhen, bool waitForFence) {
\n status_t err;<\/p>\n

\/\/ 1. \u53c2\u6570\u6709\u6548\u6027\u68c0\u67e5
\n if (!item) return BAD_VALUE;<\/p>\n

\/\/ 2. \u52a0\u9501\u4fdd\u62a4\u5171\u4eab\u8d44\u6e90（\u7ebf\u7a0b\u5b89\u5168）
\n Mutex::Autolock _l(mMutex);<\/p>\n

\/\/ 3. \u8c03\u7528\u6838\u5fc3\u7684\u83b7\u53d6\u7f13\u51b2\u533a\u65b9\u6cd5（\u52a0\u9501\u7248\u672c）
\n err = acquireBufferLocked(item, presentWhen);
\n if (err != OK) {
\n if (err != NO_BUFFER_AVAILABLE) {
\n \/\/ \u8bb0\u5f55\u975e"\u65e0\u7f13\u51b2\u533a\u53ef\u7528"\u7684\u9519\u8bef
\n BI_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
\n }
\n return err;
\n }<\/p>\n

\/\/ 4. \u6805\u680f\u540c\u6b65\u5904\u7406（\u53ef\u9009）
\n if (waitForFence) {
\n \/\/ \u7b49\u5f85\u6805\u680f\u4fe1\u53f7，\u786e\u4fdd\u751f\u4ea7\u8005\u5df2\u5b8c\u6210\u6570\u636e\u5199\u5165
\n err = item->mFence->waitForever("BufferItemConsumer::acquireBuffer");
\n if (err != OK) {
\n BI_LOGE("Failed to wait for fence of acquired buffer: %s (%d)",
\n strerror(-err), err);
\n return err;
\n }
\n }<\/p>\n

\/\/ 5. \u8bbe\u7f6e\u56fe\u5f62\u7f13\u51b2\u533a\u5f15\u7528
\n item->mGraphicBuffer = mSlots[item->mSlot].mGraphicBuffer;<\/p>\n

return OK;
\n} <\/p>\n

\u4e0a\u8ff0\u4ee3\u7801\u7684\u6838\u5fc3\u4f5c\u7528\u662f\u7f13\u51b2\u533a\u83b7\u53d6<\/p>\n

\u4ece BufferQueue\u7684\u961f\u5217\u4e2d\u53d6\u51fa\u4e00\u4e2a\u751f\u4ea7\u8005\u5df2\u7ecf\u5199\u5165\u6570\u636e\u7684\u7f13\u51b2\u533a，\u7136\u540e\u6211\u4eec\u7ee7\u7eed\u770b\u4e0bacquireBufferLocked\u51fd\u6570\u600e\u4e48\u83b7\u53d6\u7684，\u8fd9\u4e2a\u51fd\u6570\u5176\u5b9e\u5728BufferItemConsumer\u7684\u7236\u7c7bConsumerBase\u4e2d\u5b9e\u73b0\u7684<\/p>\n

<\/h3>\n

ConsumerBase::acquireBufferLocked<\/h3>\n

\u4ee3\u7801\u5982\u4e0b：<\/p>\n

\/\/ ConsumerBase\u7684\u52a0\u9501\u7248\u672c\u7f13\u51b2\u533a\u83b7\u53d6\u65b9\u6cd5
\n\/\/ \u8fd9\u662f\u6d88\u8d39\u8005\u5b9e\u9645\u4eceBufferQueue\u83b7\u53d6\u7f13\u51b2\u533a\u7684\u6838\u5fc3\u5b9e\u73b0
\nstatus_t ConsumerBase::acquireBufferLocked(BufferItem *item,
\n nsecs_t presentWhen, uint64_t maxFrameNumber) {<\/p>\n

\/\/ 1. \u68c0\u67e5\u6d88\u8d39\u8005\u662f\u5426\u5df2\u88ab\u5e9f\u5f03（abandoned）
\n if (mAbandoned) {
\n CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!");
\n return NO_INIT; \/\/ \u8fd4\u56de\u672a\u521d\u59cb\u5316\u9519\u8bef
\n }<\/p>\n

\/\/ 2. \u8c03\u7528\u5e95\u5c42Consumer\u5bf9\u8c61（\u5b9e\u9645\u662fBufferQueueConsumer）\u7684acquireBuffer\u65b9\u6cd5
\n status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
\n if (err != NO_ERROR) {
\n return err; \/\/ \u5982\u679c\u83b7\u53d6\u5931\u8d25，\u76f4\u63a5\u8fd4\u56de\u9519\u8bef
\n }<\/p>\n

\/\/ 3. \u7f13\u51b2\u533a\u69fd\u4f4d\u7ba1\u7406：\u5982\u679c\u83b7\u53d6\u5230\u65b0\u7684GraphicBuffer
\n if (item->mGraphicBuffer != nullptr) {
\n \/\/ \u5982\u679c\u8be5\u69fd\u4f4d\u5df2\u7ecf\u6709\u7f13\u51b2\u533a，\u5148\u91ca\u653e\u65e7\u7684
\n if (mSlots[item->mSlot].mGraphicBuffer != nullptr) {
\n freeBufferLocked(item->mSlot);
\n }
\n \/\/ \u5c06\u65b0\u7f13\u51b2\u533a\u5b58\u50a8\u5230\u5bf9\u5e94\u7684\u69fd\u4f4d\u4e2d
\n mSlots[item->mSlot].mGraphicBuffer = item->mGraphicBuffer;
\n }<\/p>\n

\/\/ 4. \u66f4\u65b0\u69fd\u4f4d\u7684\u5143\u6570\u636e\u4fe1\u606f
\n mSlots[item->mSlot].mFrameNumber = item->mFrameNumber; \/\/ \u5e27\u53f7
\n mSlots[item->mSlot].mFence = item->mFence; \/\/ \u540c\u6b65\u6805\u680f<\/p>\n

\/\/ 5. \u8bb0\u5f55\u8c03\u8bd5\u65e5\u5fd7
\n CB_LOGV("acquireBufferLocked: -> slot=%d\/%" PRIu64,
\n item->mSlot, item->mFrameNumber);<\/p>\n

return OK; \/\/ \u6210\u529f\u8fd4\u56de
\n} <\/p>\n

\u4e0a\u8ff0\u7684\u4ee3\u7801\u5f15\u51fa\u4e86\u6211\u4eec\u7684\u4e3b\u89d2：BufferQueueConsumer，\u5176\u5b9e\u771f\u6b63\u7684\u7f13\u51b2\u533a\u83b7\u53d6\u64cd\u4f5c\u662f\u5728\u4e0a\u8ff0\u7684mConsumer->acquireBuffer\u51fd\u6570，\u6211\u4eec\u7ee7\u7eed\u770bBufferQueueConsumer::acquireBuffer\u51fd\u6570<\/p>\n<\/p>\n

BufferQueueConsumer::acquireBuffer<\/h3>\n

\u6839\u636e\u4e4b\u524d\u7684\u6587\u7ae0\u5206\u6790：<\/p>\n

https:\/\/blog.csdn.net\/gongjdde\/article\/details\/157393485?spm=1001.2014.3001.5501<\/p>\n

\u4e0a\u8ff0\u7684mConsumer\u5176\u5b9e\u5c31\u662fBufferQueueConsumer\u7c7b\u578b，\u6240\u6709\u6211\u4eec\u5c31\u4f1a\u8d70\u5230BufferQueueConsumer\u7684acquireBuffer\u51fd\u6570，\u5982\u4e0b：<\/p>\n

\/\/ BufferQueueConsumer\u83b7\u53d6\u7f13\u51b2\u533a\u7684\u6838\u5fc3\u5b9e\u73b0
\n\/\/ \u8fd9\u662f\u6d88\u8d39\u8005\u5b9e\u9645\u4eceBufferQueue\u961f\u5217\u4e2d\u53d6\u51fa\u7f13\u51b2\u533a\u7684\u6700\u7ec8\u6b65\u9aa4
\nstatus_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
\n nsecs_t expectedPresent, uint64_t maxFrameNumber) {
\n ATRACE_CALL(); \/\/ \u5f00\u59cb\u6027\u80fd\u8ffd\u8e2a<\/p>\n

int numDroppedBuffers = 0; \/\/ \u8bb0\u5f55\u4e22\u5f03\u7684\u7f13\u51b2\u533a\u6570\u91cf
\n sp<IProducerListener> listener; \/\/ \u7528\u4e8e\u7f13\u51b2\u533a\u91ca\u653e\u56de\u8c03\u7684\u76d1\u542c\u5668<\/p>\n

{
\n \/\/ 1. \u52a0\u9501\u4fdd\u62a4BufferQueue\u6838\u5fc3\u72b6\u6001
\n std::unique_lock<std::mutex> lock(mCore->mMutex);<\/p>\n

\/\/ 2. \u68c0\u67e5\u6d88\u8d39\u8005\u5f53\u524d\u5df2\u83b7\u53d6\u7684\u7f13\u51b2\u533a\u6570\u91cf\u662f\u5426\u8d85\u8fc7\u9650\u5236
\n int numAcquiredBuffers = 0;
\n for (int s : mCore->mActiveBuffers) {
\n if (mSlots[s].mBufferState.isAcquired()) {
\n ++numAcquiredBuffers; \/\/ \u7edf\u8ba1\u5f53\u524d\u5df2\u83b7\u53d6\u7684\u7f13\u51b2\u533a\u6570\u91cf
\n }
\n }<\/p>\n

\/\/ \u5141\u8bb8\u4e34\u65f6\u8d85\u8fc7\u6700\u5927\u83b7\u53d6\u6570\u91cf1\u4e2a（\u7528\u4e8e\u7f13\u51b2\u533a\u5207\u6362\u65f6\u7684\u5e73\u6ed1\u8fc7\u6e21）
\n const bool acquireNonDroppableBuffer = mCore->mAllowExtraAcquire &&
\n numAcquiredBuffers == mCore->mMaxAcquiredBufferCount + 1;<\/p>\n

\/\/ \u5982\u679c\u8d85\u8fc7\u9650\u5236\u4e14\u4e0d\u5141\u8bb8\u989d\u5916\u83b7\u53d6，\u8fd4\u56de\u9519\u8bef
\n if (numAcquiredBuffers >= mCore->mMaxAcquiredBufferCount + 1 &&
\n !acquireNonDroppableBuffer) {
\n BQ_LOGE("acquireBuffer: max acquired buffer count reached: %d (max %d)",
\n numAcquiredBuffers, mCore->mMaxAcquiredBufferCount);
\n return INVALID_OPERATION;
\n }<\/p>\n

\/\/ 3. \u68c0\u67e5\u5171\u4eab\u7f13\u51b2\u533a\u6a21\u5f0f\u662f\u5426\u53ef\u7528
\n bool sharedBufferAvailable = mCore->mSharedBufferMode &&
\n mCore->mAutoRefresh && mCore->mSharedBufferSlot !=
\n BufferQueueCore::INVALID_BUFFER_SLOT;<\/p>\n

\/\/ 4. \u68c0\u67e5\u961f\u5217\u662f\u5426\u4e3a\u7a7a（\u5171\u4eab\u7f13\u51b2\u533a\u6a21\u5f0f\u7279\u6b8a\u5904\u7406）
\n if (mCore->mQueue.empty() && !sharedBufferAvailable) {
\n return NO_BUFFER_AVAILABLE; \/\/ \u6ca1\u6709\u53ef\u7528\u7f13\u51b2\u533a
\n }<\/p>\n

\/\/ 5. \u83b7\u53d6\u961f\u5217\u9996\u90e8\u7f13\u51b2\u533a（FIFO\u539f\u5219）
\n BufferQueueCore::Fifo::iterator front(mCore->mQueue.begin());<\/p>\n

\/\/ 6. \u65f6\u95f4\u6233\u76f8\u5173\u7684\u7f13\u51b2\u533a\u8c03\u5ea6\u903b\u8f91
\n \/\/ \u5982\u679c\u6307\u5b9a\u4e86expectedPresent\u65f6\u95f4，\u8fdb\u884c\u667a\u80fd\u7f13\u51b2\u533a\u9009\u62e9
\n if (expectedPresent != 0 && !mCore->mQueue.empty()) {<\/p>\n

\/\/ 7. \u7f13\u51b2\u533a\u4e22\u5f03\u7b56\u7565：\u4e22\u5f03\u8fc7\u65f6\u7684\u7f13\u51b2\u533a
\n while (mCore->mQueue.size() > 1 && !mCore->mQueue[0].mIsAutoTimestamp) {
\n const BufferItem& bufferItem(mCore->mQueue[1]); \/\/ \u67e5\u770b\u4e0b\u4e00\u4e2a\u7f13\u51b2\u533a<\/p>\n

\/\/ \u68c0\u67e5\u4e0b\u4e00\u4e2a\u7f13\u51b2\u533a\u662f\u5426\u5df2\u51c6\u5907\u597d（\u5e27\u53f7\u9650\u5236）
\n if (maxFrameNumber && bufferItem.mFrameNumber > maxFrameNumber) {
\n break; \/\/ \u6d88\u8d39\u8005\u8fd8\u6ca1\u51c6\u5907\u597d\u63a5\u6536\u8fd9\u4e2a\u7f13\u51b2\u533a
\n }<\/p>\n

\/\/ 8. \u65f6\u95f4\u6233\u68c0\u67e5：\u5224\u65ad\u662f\u5426\u5e94\u8be5\u4e22\u5f03\u5f53\u524d\u7f13\u51b2\u533a
\n nsecs_t desiredPresent = bufferItem.mTimestamp;
\n \/\/ \u68c0\u67e5\u65f6\u95f4\u6233\u662f\u5426\u5408\u7406（\u5728\u671f\u671b\u65f6\u95f4\u7684\u5408\u7406\u8303\u56f4\u5185）
\n if (desiredPresent < expectedPresent – MAX_REASONABLE_NSEC ||
\n desiredPresent > expectedPresent) {
\n \/\/ \u65f6\u95f4\u6233\u4e0d\u5408\u7406\u6216\u7f13\u51b2\u533a\u663e\u793a\u65f6\u95f4\u592a\u665a，\u4e0d\u4e22\u5f03
\n BQ_LOGV("acquireBuffer: nodrop desire=%" PRId64 " expect=%"
\n PRId64 " (%" PRId64 ") now=%" PRId64,
\n desiredPresent, expectedPresent,
\n desiredPresent – expectedPresent,
\n systemTime(CLOCK_MONOTONIC));
\n break;
\n }<\/p>\n

BQ_LOGV("acquireBuffer: drop desire=%" PRId64 " expect=%" PRId64
\n " size=%zu",
\n desiredPresent, expectedPresent, mCore->mQueue.size());<\/p>\n

\/\/ 9. \u5b9e\u9645\u4e22\u5f03\u7f13\u51b2\u533a
\n if (!front->mIsStale) {
\n \/\/ \u91ca\u653e\u88ab\u4e22\u5f03\u7f13\u51b2\u533a\u7684\u72b6\u6001
\n mSlots[front->mSlot].mBufferState.freeQueued();<\/p>\n

\/\/ \u5171\u4eab\u7f13\u51b2\u533a\u6a21\u5f0f\u7279\u6b8a\u5904\u7406
\n if (!mCore->mSharedBufferMode &&
\n mSlots[front->mSlot].mBufferState.isFree()) {
\n mSlots[front->mSlot].mBufferState.mShared = false;
\n }<\/p>\n

\/\/ \u975e\u5171\u4eab\u7f13\u51b2\u533a\u6dfb\u52a0\u5230\u7a7a\u95f2\u5217\u8868
\n if (!mSlots[front->mSlot].mBufferState.isShared()) {
\n mCore->mActiveBuffers.erase(front->mSlot);
\n mCore->mFreeBuffers.push_back(front->mSlot);
\n }<\/p>\n

\/\/ \u51c6\u5907\u7f13\u51b2\u533a\u91ca\u653e\u56de\u8c03
\n if (mCore->mBufferReleasedCbEnabled) {
\n listener = mCore->mConnectedProducerListener;
\n }
\n ++numDroppedBuffers; \/\/ \u589e\u52a0\u4e22\u5f03\u8ba1\u6570
\n }<\/p>\n

\/\/ \u4ece\u961f\u5217\u4e2d\u79fb\u9664\u4e22\u5f03\u7684\u7f13\u51b2\u533a
\n mCore->mQueue.erase(front);
\n front = mCore->mQueue.begin(); \/\/ \u66f4\u65b0front\u6307\u5411\u65b0\u7684\u961f\u9996
\n }<\/p>\n

\/\/ 10. \u68c0\u67e5\u5f53\u524d\u961f\u9996\u7f13\u51b2\u533a\u662f\u5426\u53ef\u83b7\u53d6
\n nsecs_t desiredPresent = front->mTimestamp;
\n \/\/ \u5224\u65ad\u7f13\u51b2\u533a\u662f\u5426\u5e94\u8be5\u663e\u793a（\u65f6\u95f4\u6761\u4ef6）
\n bool bufferIsDue = desiredPresent <= expectedPresent ||
\n desiredPresent > expectedPresent + MAX_REASONABLE_NSEC;
\n \/\/ \u68c0\u67e5\u6d88\u8d39\u8005\u662f\u5426\u51c6\u5907\u597d（\u5e27\u53f7\u6761\u4ef6）
\n bool consumerIsReady = maxFrameNumber > 0 ?
\n front->mFrameNumber <= maxFrameNumber : true;<\/p>\n

\/\/ \u5982\u679c\u7f13\u51b2\u533a\u4e0d\u8be5\u73b0\u5728\u663e\u793a\u6216\u6d88\u8d39\u8005\u6ca1\u51c6\u5907\u597d，\u5ef6\u8fdf\u83b7\u53d6
\n if (!bufferIsDue || !consumerIsReady) {
\n BQ_LOGV("acquireBuffer: defer desire=%" PRId64 " expect=%" PRId64
\n " (%" PRId64 ") now=%" PRId64 " frame=%" PRIu64
\n " consumer=%" PRIu64,
\n desiredPresent, expectedPresent,
\n desiredPresent – expectedPresent,
\n systemTime(CLOCK_MONOTONIC),
\n front->mFrameNumber, maxFrameNumber);
\n ATRACE_NAME("PRESENT_LATER");
\n return PRESENT_LATER; \/\/ \u544a\u8bc9\u8c03\u7528\u8005\u7a0d\u540e\u518d\u8bd5
\n }<\/p>\n

BQ_LOGV("acquireBuffer: accept desire=%" PRId64 " expect=%" PRId64 " "
\n "(%" PRId64 ") now=%" PRId64, desiredPresent, expectedPresent,
\n desiredPresent – expectedPresent,
\n systemTime(CLOCK_MONOTONIC));
\n }<\/p>\n

int slot = BufferQueueCore::INVALID_BUFFER_SLOT;<\/p>\n

\/\/ 11. \u5171\u4eab\u7f13\u51b2\u533a\u6a21\u5f0f\u5904\u7406
\n if (sharedBufferAvailable && mCore->mQueue.empty()) {
\n \/\/ \u7b49\u5f85\u7f13\u51b2\u533a\u5206\u914d\u5b8c\u6210
\n mCore->waitWhileAllocatingLocked(lock);<\/p>\n

slot = mCore->mSharedBufferSlot;<\/p>\n

\/\/ \u4ece\u7f13\u5b58\u6570\u636e\u91cd\u65b0\u521b\u5efaBufferItem（\u5171\u4eab\u7f13\u51b2\u533a\u7279\u6b8a\u5904\u7406）
\n outBuffer->mGraphicBuffer = mSlots[slot].mGraphicBuffer;
\n outBuffer->mFence = Fence::NO_FENCE;
\n outBuffer->mFenceTime = FenceTime::NO_FENCE;
\n outBuffer->mCrop = mCore->mSharedBufferCache.crop;
\n outBuffer->mTransform = mCore->mSharedBufferCache.transform &
\n ~static_cast<uint32_t>(
\n NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY);
\n outBuffer->mScalingMode = mCore->mSharedBufferCache.scalingMode;
\n outBuffer->mDataSpace = mCore->mSharedBufferCache.dataspace;
\n outBuffer->mFrameNumber = mCore->mFrameCounter;
\n outBuffer->mSlot = slot;
\n outBuffer->mAcquireCalled = mSlots[slot].mAcquireCalled;
\n outBuffer->mTransformToDisplayInverse =
\n (mCore->mSharedBufferCache.transform &
\n NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) != 0;
\n outBuffer->mSurfaceDamage = Region::INVALID_REGION;
\n outBuffer->mQueuedBuffer = false;
\n outBuffer->mIsStale = false;
\n outBuffer->mAutoRefresh = mCore->mSharedBufferMode &&
\n mCore->mAutoRefresh;
\n }
\n \/\/ 12. \u68c0\u67e5\u662f\u5426\u53ef\u4ee5\u83b7\u53d6\u975e\u53ef\u4e22\u5f03\u7f13\u51b2\u533a
\n else if (acquireNonDroppableBuffer && front->mIsDroppable) {
\n BQ_LOGV("acquireBuffer: front buffer is not droppable");
\n return NO_BUFFER_AVAILABLE;
\n }
\n \/\/ 13. \u6b63\u5e38\u7f13\u51b2\u533a\u83b7\u53d6
\n else {
\n slot = front->mSlot;
\n *outBuffer = *front; \/\/ \u590d\u5236\u7f13\u51b2\u533a\u6570\u636e
\n }<\/p>\n

ATRACE_BUFFER_INDEX(slot); \/\/ \u8ffd\u8e2a\u7279\u5b9a\u7f13\u51b2\u533a\u7684\u64cd\u4f5c<\/p>\n

BQ_LOGV("acquireBuffer: acquiring { slot=%d\/%" PRIu64 " buffer=%p }",
\n slot, outBuffer->mFrameNumber, outBuffer->mGraphicBuffer->handle);<\/p>\n

\/\/ 14. \u66f4\u65b0\u7f13\u51b2\u533a\u72b6\u6001\u4e3a"\u5df2\u83b7\u53d6"
\n if (!outBuffer->mIsStale) {
\n mSlots[slot].mAcquireCalled = true;
\n \/\/ \u6839\u636e\u662f\u5426\u5728\u961f\u5217\u4e2d\u8c03\u7528\u4e0d\u540c\u7684\u72b6\u6001\u8f6c\u6362
\n if (mCore->mQueue.empty()) {
\n mSlots[slot].mBufferState.acquireNotInQueue(); \/\/ \u5171\u4eab\u7f13\u51b2\u533a\u6a21\u5f0f
\n } else {
\n mSlots[slot].mBufferState.acquire(); \/\/ \u6b63\u5e38\u6a21\u5f0f
\n }
\n mSlots[slot].mFence = Fence::NO_FENCE; \/\/ \u91cd\u7f6e\u6805\u680f
\n }<\/p>\n

\/\/ 15. \u4f18\u5316：\u5982\u679c\u7f13\u51b2\u533a\u4e4b\u524d\u5df2\u88ab\u83b7\u53d6\u8fc7，\u4e0d\u8fd4\u56deGraphicBuffer\u5f15\u7528
\n \/\/ \u907f\u514d\u5728\u6d88\u8d39\u8005\u7aef\u4e0d\u5fc5\u8981\u7684\u91cd\u65b0\u6620\u5c04
\n if (outBuffer->mAcquireCalled) {
\n outBuffer->mGraphicBuffer = nullptr;
\n }<\/p>\n

\/\/ 16. \u4ece\u961f\u5217\u4e2d\u79fb\u9664\u5df2\u83b7\u53d6\u7684\u7f13\u51b2\u533a
\n mCore->mQueue.erase(front);<\/p>\n

\/\/ 17. \u5524\u9192\u53ef\u80fd\u7b49\u5f85\u7684\u751f\u4ea7\u8005（\u56e0\u4e3a\u961f\u5217\u6709\u7a7a\u95f4\u4e86）
\n mCore->mDequeueCondition.notify_all();<\/p>\n

\/\/ 18. \u66f4\u65b0\u6027\u80fd\u8ffd\u8e2a\u548c\u7edf\u8ba1\u4fe1\u606f
\n ATRACE_INT(mCore->mConsumerName.c_str(), static_cast<int32_t>(mCore->mQueue.size()));
\n#ifndef NO_BINDER
\n mCore->mOccupancyTracker.registerOccupancyChange(mCore->mQueue.size());
\n#endif
\n VALIDATE_CONSISTENCY(); \/\/ \u9a8c\u8bc1\u5185\u90e8\u72b6\u6001\u4e00\u81f4\u6027
\n } \/\/ \u81ea\u52a8\u91ca\u653e\u9501<\/p>\n

\/\/ 19. \u5728\u9501\u5916\u6267\u884c\u7f13\u51b2\u533a\u91ca\u653e\u56de\u8c03（\u907f\u514d\u6b7b\u9501）
\n if (listener != nullptr) {
\n for (int i = 0; i < numDroppedBuffers; ++i) {
\n listener->onBufferReleased(); \/\/ \u901a\u77e5\u751f\u4ea7\u8005\u7f13\u51b2\u533a\u88ab\u91ca\u653e
\n }
\n }<\/p>\n

return NO_ERROR; \/\/ \u6210\u529f\u83b7\u53d6\u7f13\u51b2\u533a
\n} <\/p>\n

acquireBuffer\u7684\u903b\u8f91\u4e3b\u8981\u5c31\u662f\u6d88\u8d39\u8005\u83b7\u53d6BufferSlot，\u8be6\u7ec6\u6d41\u7a0b\u5728\u6e90\u7801\u4e2d\u6709\u8be6\u7ec6\u7684\u6ce8\u91ca：<\/p>\n

\u603b\u7ed3\u4e3b\u8981\u505a\u4e86\u5982\u4e0b\u7684\u51e0\u4ef6\u4e8b：<\/p>\n

1.\u7f13\u51b2\u533a\u6570\u91cf\u9650\u5236\u68c0\u67e5，\u901a\u8fc7numAcquiredBuffers\u53d8\u91cf\u8fdb\u884c\u68c0\u67e5，\u9632\u6b62\u6570\u91cf\u8fc7\u591a\u51fa\u73b0oom\u6216\u8005\u751f\u4ea7\u8005\u4e0e\u6d88\u8d39\u8005\u6570\u91cf\u4e0d\u5e73\u8861<\/p>\n

2.\u961f\u5217\u662f\u5426\u4e3a\u7a7a\u68c0\u67e5，\u901a\u8fc7mCore->mQueue.empty()\u8fdb\u884c\u68c0\u67e5，\u4e3a\u7a7a\u5219\u4e0d\u7ee7\u7eed\u8fdb\u884c\u4e0b\u53bb<\/p>\n

3.\u667a\u80fd\u7f13\u51b2\u533a\u4e22\u5f03\u7b97\u6cd5，\u901a\u8fc7\u65f6\u95f4\u6233\u7b49\u8fdb\u884c\u68c0\u67e5，\u5c06\u4e0d\u5408\u7406\u7684\u7f13\u51b2\u533a\u8fdb\u884c\u4e22\u5f03<\/p>\n

4.\u5bf9\u663e\u793a\u65f6\u95f4\u8fdb\u884c\u5224\u65ad，\u4e3b\u8981\u662f\u57fa\u4e8e\u65f6\u95f4\u6233\u901a\u8fc7\u4e00\u7cfb\u5217\u7b97\u6cd5\u6700\u7ec8\u901a\u8fc7bufferIsDue\u548cconsumerIsReady\u53d8\u91cf\u8fdb\u884c\u7684\u667a\u80fd\u51b3\u7b56\u673a\u5236，\u9632\u6b62\u8fc7\u65e9\u663e\u793a\u51fa\u73b0\u753b\u9762\u6495\u88c2<\/p>\n

5.\u7f13\u51b2\u533a\u83b7\u53d6，\u53d6\u51fa\u5bf9\u5e94\u7684BufferSlot<\/p>\n

6.\u5173\u952e\u72b6\u6001\u8f6c\u6362，\u901a\u8fc7mSlots[slot].mBufferState.acquire();\u5c06BufferState\u72b6\u6001\u8fdb\u884c\u8f6c\u6362：QUEUED \u2192 ACQUIRED<\/p>\n

7.\u5c06mGraphicBuffer \u7f6e\u7a7a，\u9632\u6b62\u91cd\u590d\u6620\u5c04<\/p>\n

8.\u961f\u5217\u7ef4\u62a4\u548c\u751f\u4ea7\u8005\u5524\u9192，\u901a\u8fc7mCore->mQueue.erase(front);\u5c06buffer\u79fb\u9664\u961f\u5217；\u901a\u8fc7mCore->mDequeueCondition.notify_all();\u5524\u9192\u751f\u4ea7\u8005<\/p>\n

9.\u56de\u8c03\u901a\u77e5，\u901a\u8fc7listener->onBufferReleased(); \u5c06\u88ab\u4e22\u5f03\u7684buffer\u901a\u77e5\u751f\u4ea7\u8005\u7f13\u51b2\u533a<\/p>\n<\/p>\n

\u4e09.\u6d88\u8d39\u8005\u91ca\u653e\u7f13\u51b2\u533a<\/h2>\n

\u91ca\u653e\u56de\u8c03<\/h3>\n

\u6d88\u8d39\u8005acquire\u62ff\u5230buffer\u540e\u53c8\u662f\u600e\u6837\u901a\u77e5release buffer\u5462？<\/p>\n

\u8fd9\u4e2a\u5176\u5b9e\u5c31\u662f\u5728\u6211\u4eec\u4e4b\u524d\u5206\u6790\u7684BLASTBufferQueue::acquireNextBufferLocked\u51fd\u6570\u4e2d，\u6211\u4eec\u9010\u6b65\u5206\u6790：<\/p>\n

1.\u63a5\u524d\u9762\u5206\u6790\u7684\u8c03\u7528acquireBuffer\u83b7\u53d6\u4e00\u4e2aBufferItem；<\/p>\n

2.\u901a\u8fc7GraphicBuffer — auto buffer = bufferItem.mGraphicBuffer;\u53d6\u51fabuffer<\/p>\n

3. \u8bbe\u7f6e\u91ca\u653e\u56de\u8c03\u51fd\u6570（\u6b65\u9aa413），\u5c31\u662f\u8bbe\u7f6ereleaseBufferCallback\u7684\u503c，\u5b83\u5c31\u662f\u91ca\u653e\u7684\u56de\u8c03\u51fd\u6570<\/p>\n

4.\u901a\u8fc7t->setBuffer\u51fd\u6570\u8c03\u7528\u5c06buffer\u548c\u91ca\u653e\u56de\u8c03\u51fd\u6570\u90fd\u8bbe\u7f6e\u5230\u4e8b\u52a1\u4e2d<\/p>\n

\u7136\u540ereleaseBufferCallbackThunk\u7684\u903b\u8f91\u548c\u524d\u9762\u7684\u83b7\u53d6\u7f13\u51b2\u533a\u7c7b\u4f3c，\u5982\u4e0b：<\/p>\n

>>> releaseBufferCallbackThunk >>> BLASTBufferQueue::releaseBufferCallback >>> BLASTBufferQueue::releaseBufferCallbackLocked >>> BLASTBufferQueue::releaseBuffer >>> BufferItemConsumer::releaseBuffer \u00a0>>> ConsumerBase::releaseBufferLocked >>> BufferQueueConsumer::releaseBuffer<\/p>\n

\u6d41\u7a0b\u56fe\u5982\u4e0b：<\/p>\n

\"\"<\/p>\n<\/p>\n

BufferQueueConsumer::releaseBuffer<\/h3>\n

\u7136\u540e\u6211\u4eec\u6765\u5206\u6790\u4e0bBufferQueueConsumer::releaseBuffer\u51fd\u6570，\u770b\u4e0b\u5982\u4f55\u91ca\u653ebuffer\u7684<\/p>\n

status_t BufferQueueConsumer::releaseBuffer(int slot, uint64_t frameNumber,
\n const sp<Fence>& releaseFence, EGLDisplay eglDisplay,
\n EGLSyncKHR eglFence) {
\n ATRACE_CALL();
\n ATRACE_BUFFER_INDEX(slot);<\/p>\n

\/\/ 1. \u53c2\u6570\u6709\u6548\u6027\u68c0\u67e5
\n if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS ||
\n releaseFence == nullptr) {
\n BQ_LOGE("releaseBuffer: slot %d out of range or fence %p NULL", slot,
\n releaseFence.get());
\n return BAD_VALUE;
\n }<\/p>\n

sp<IProducerListener> listener;
\n {
\n \/\/ 2. \u52a0\u9501\u4fdd\u62a4\u6838\u5fc3\u72b6\u6001
\n std::lock_guard<std::mutex> lock(mCore->mMutex);<\/p>\n

\/\/ 3. \u5e27\u53f7\u9a8c\u8bc1（\u9632\u6b62\u91ca\u653e\u9519\u8bef\u7684\u7f13\u51b2\u533a）
\n if (frameNumber != mSlots[slot].mFrameNumber &&
\n !mSlots[slot].mBufferState.isShared()) {
\n return STALE_BUFFER_SLOT; \/\/ \u7f13\u51b2\u533a\u5df2\u88ab\u91cd\u65b0\u5206\u914d
\n }<\/p>\n

\/\/ 4. \u72b6\u6001\u9a8c\u8bc1：\u5fc5\u987b\u5904\u4e8eACQUIRED\u72b6\u6001\u624d\u80fd\u91ca\u653e
\n if (!mSlots[slot].mBufferState.isAcquired()) {
\n BQ_LOGE("releaseBuffer: attempted to release buffer slot %d "
\n "but its state was %s", slot,
\n mSlots[slot].mBufferState.string());
\n return BAD_VALUE;
\n }<\/p>\n

\/\/ 5. 🔥🔥🔥 \u771f\u6b63\u7684\u7f13\u51b2\u533a\u91ca\u653e\u5f00\u59cb 🔥🔥🔥<\/p>\n

\/\/ 5.1 \u8bbe\u7f6e\u540c\u6b65\u5bf9\u8c61
\n mSlots[slot].mEglDisplay = eglDisplay;
\n mSlots[slot].mEglFence = eglFence;
\n mSlots[slot].mFence = releaseFence;<\/p>\n

\/\/ 5.2 🔥 \u5173\u952e：\u7f13\u51b2\u533a\u72b6\u6001\u8f6c\u6362 – ACQUIRED \u2192 FREE
\n mSlots[slot].mBufferState.release();<\/p>\n

\/\/ 6. \u5171\u4eab\u7f13\u51b2\u533a\u6a21\u5f0f\u7279\u6b8a\u5904\u7406
\n if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) {
\n mSlots[slot].mBufferState.mShared = false; \/\/ \u6807\u8bb0\u4e3a\u975e\u5171\u4eab
\n }<\/p>\n

\/\/ 7. 🔥 \u5173\u952e：\u5c06\u7f13\u51b2\u533a\u69fd\u4f4d\u56de\u6536\u5230\u7a7a\u95f2\u5217\u8868
\n \/\/ \u6ce8\u610f：\u5171\u4eab\u7f13\u51b2\u533a\u4e0d\u52a0\u5165\u7a7a\u95f2\u5217\u8868（\u6301\u7eed\u91cd\u7528）
\n if (!mSlots[slot].mBufferState.isShared()) {
\n mCore->mActiveBuffers.erase(slot); \/\/ \u4ece\u6d3b\u8dc3\u5217\u8868\u79fb\u9664
\n mCore->mFreeBuffers.push_back(slot); \/\/ 🔥 \u52a0\u5165\u7a7a\u95f2\u5217\u8868
\n }<\/p>\n

\/\/ 8. \u51c6\u5907\u751f\u4ea7\u8005\u56de\u8c03
\n if (mCore->mBufferReleasedCbEnabled) {
\n listener = mCore->mConnectedProducerListener;
\n }
\n BQ_LOGV("releaseBuffer: releasing slot %d", slot);<\/p>\n

\/\/ 9. 🔥 \u5173\u952e：\u5524\u9192\u7b49\u5f85\u7684\u751f\u4ea7\u8005\u7ebf\u7a0b
\n mCore->mDequeueCondition.notify_all();<\/p>\n

VALIDATE_CONSISTENCY(); \/\/ \u9a8c\u8bc1\u72b6\u6001\u4e00\u81f4\u6027
\n } \/\/ \u81ea\u52a8\u91ca\u653e\u9501<\/p>\n

\/\/ 10. \u5728\u9501\u5916\u6267\u884c\u751f\u4ea7\u8005\u56de\u8c03（\u907f\u514d\u6b7b\u9501）
\n if (listener != nullptr) {
\n listener->onBufferReleased(); \/\/ \u901a\u77e5\u751f\u4ea7\u8005\u7f13\u51b2\u533a\u5df2\u91ca\u653e
\n }<\/p>\n

return NO_ERROR;
\n} <\/p>\n

🔥 \u771f\u6b63\u91ca\u653e\u7f13\u51b2\u533a\u7684\u6838\u5fc3\u4f4d\u7f6e<\/h3>\n

\u4f4d\u7f6e1：\u7f13\u51b2\u533a\u72b6\u6001\u8f6c\u6362（\u7b2c5.2\u6b65）<\/h4>\n

mSlots[slot].mBufferState.release(); \/\/ ACQUIRED \u2192 FREE <\/p>\n

\u4f5c\u7528：\u8fd9\u662f\u903b\u8f91\u4e0a\u7684\u91ca\u653e，\u5c06\u7f13\u51b2\u533a\u72b6\u6001\u4ece"\u5df2\u83b7\u53d6"\u53d8\u4e3a"\u7a7a\u95f2"，\u5141\u8bb8\u88ab\u91cd\u65b0\u4f7f\u7528\u3002<\/p>\n

\u4f4d\u7f6e2：\u8d44\u6e90\u56de\u6536（\u7b2c7\u6b65）<\/h4>\n

if (!mSlots[slot].mBufferState.isShared()) {
\n mCore->mActiveBuffers.erase(slot); \/\/ \u4ece\u6d3b\u8dc3\u5217\u8868\u79fb\u9664
\n mCore->mFreeBuffers.push_back(slot); \/\/ 🔥 \u52a0\u5165\u7a7a\u95f2\u5217\u8868 – \u771f\u6b63\u7684\u91ca\u653e！
\n} <\/p>\n

\u4f5c\u7528：\u8fd9\u662f\u7269\u7406\u4e0a\u7684\u91ca\u653e，\u5c06\u7f13\u51b2\u533a\u69fd\u4f4d\u653e\u56de\u7a7a\u95f2\u6c60，\u4f9b\u751f\u4ea7\u8005\u91cd\u65b0\u83b7\u53d6\u3002<\/p>\n

\u4f4d\u7f6e3：\u751f\u4ea7\u8005\u5524\u9192（\u7b2c9\u6b65）<\/h4>\n

mCore->mDequeueCondition.notify_all(); \/\/ \u5524\u9192\u7b49\u5f85\u7684\u751f\u4ea7\u8005 <\/p>\n

\u4f5c\u7528：\u901a\u77e5\u53ef\u80fd\u88ab\u963b\u585e\u7684\u751f\u4ea7\u8005\u7ebf\u7a0b，\u73b0\u5728\u6709\u53ef\u7528\u7684\u7f13\u51b2\u533a\u4e86\u3002<\/p>\n

\u4f4d\u7f6e4：\u901a\u77e5\u751f\u4ea7\u8005\u91ca\u653e\u5b8c\u6210(\u7b2c10\u6b65)<\/h4>\n

listener->onBufferReleased(); \/\/ \u901a\u77e5\u751f\u4ea7\u8005\u7f13\u51b2\u533a\u5df2\u91ca\u653e <\/p>\n

\u56db.ProducerListener\u662f\u600e\u6837\u5de5\u4f5c\u7684<\/h2>\n

\u6e90\u7801\u4f4d\u7f6e：framework\/native\/include\/gui\/IProducerListener.h<\/p>\n

\u7136\u540e\u6211\u4eec\u5206\u6790\u8fd9\u4e2a\u91ca\u653e\u8fc7\u7a0b\u5982\u4f55\u901a\u77e5\u751f\u4ea7\u8005\u7684<\/p>\n

1. \u5728BufferQueueCore\u4e2d\u6709\u6210\u5458 sp mConnectedProducerListener，\u5b83\u5c31\u662f\u7528\u6765\u5904\u7406onBufferReleased\u4e8b\u4ef6\u7684；<\/p>\n

2. mConnectedProducerListener\u662f\u5728\u54ea\u91cc\u88ab\u8bbe\u7f6e\u7684\u5462？\u7b54\u6848\u662f BufferQueueProducer::connect；<\/p>\n

3.\u7136\u540e\u662f\u901a\u8fc7Surface::connect\u8c03\u7528\u5230BufferQueueProducer::connect\u7684，\u6211\u4eec\u770b\u4e0bSurface::connect\u7684\u4ee3\u7801<\/p>\n

int Surface::connect(
\n int api, bool reportBufferRemoval, const sp<SurfaceListener>& sListener) {
\n if (sListener != nullptr) {
\n mListenerProxy = new ProducerListenerProxy(this, sListener);
\n }
\n return connect(api, mListenerProxy, reportBufferRemoval);
\n}<\/p>\n

int Surface::connect(
\n int api, const sp<IProducerListener>& listener, bool reportBufferRemoval) {
\n ATRACE_CALL();
\n ALOGV("Surface::connect");
\n Mutex::Autolock lock(mMutex);
\n IGraphicBufferProducer::QueueBufferOutput output;
\n mReportRemovedBuffers = reportBufferRemoval;<\/p>\n

\/* QTI_BEGIN *\/
\n if (mQtiSurfaceGPPExtn) {
\n mQtiSurfaceGPPExtn->Connect(api, &mGraphicBufferProducer);
\n }
\n \/* QTI_END *\/<\/p>\n

int err = mGraphicBufferProducer->connect(listener, api, mProducerControlledByApp, &output);
\n if (err == NO_ERROR) {
\n mDefaultWidth = output.width;
\n mDefaultHeight = output.height;
\n mNextFrameNumber = output.nextFrameNumber;
\n mMaxBufferCount = output.maxBufferCount;<\/p>\n

\/\/ Ignore transform hint if sticky transform is set or transform to display inverse flag is
\n \/\/ set. Transform hint should be ignored if the client is expected to always submit buffers
\n \/\/ in the same orientation.
\n if (mStickyTransform == 0 && !transformToDisplayInverse()) {
\n mTransformHint = output.transformHint;
\n }<\/p>\n

mConsumerRunningBehind = (output.numPendingBuffers >= 2);<\/p>\n

\/* QTI_BEGIN *\/
\n if (mQtiSurfaceGPPExtn) {
\n mQtiSurfaceGPPExtn->StoreConnect(api, listener, reportBufferRemoval);
\n }
\n \/* QTI_END *\/
\n }
\n if (!err && api == NATIVE_WINDOW_API_CPU) {
\n mConnectedToCpu = true;
\n \/\/ Clear the dirty region in case we're switching from a non-CPU API
\n mDirtyRegion.clear();
\n } else if (!err) {
\n \/\/ Initialize the dirty region for tracking surface damage
\n mDirtyRegion = Region::INVALID_REGION;
\n }<\/p>\n

return err;
\n} <\/p>\n

\u53ef\u4ee5\u770b\u51fa\u6765\u662f\u5c06ProducerListenerProxy\u8bbe\u7f6e\u8fdb\u53bb\u7684<\/p>\n

4.\u770b\u4e00\u4e0bProducerListenerProxy\u4ee3\u7801，\u53ef\u4ee5\u770b\u51fa\u6765\u662f\u8c03\u7528\u4e86\u4e0a\u4e00\u6b65\u8bbe\u7f6e\u7684listener<\/p>\n

class ProducerListenerProxy : public BnProducerListener {
\n public:
\n ProducerListenerProxy(wp<Surface> parent, sp<SurfaceListener> listener)
\n : mParent(parent), mSurfaceListener(listener) {}
\n virtual ~ProducerListenerProxy() {}<\/p>\n

virtual void onBufferReleased() {
\n mSurfaceListener->onBufferReleased();
\n }<\/p>\n

virtual bool needsReleaseNotify() {
\n return mSurfaceListener->needsReleaseNotify();
\n }<\/p>\n

virtual void onBuffersDiscarded(const std::vector<int32_t>& slots);
\n private:
\n wp<Surface> mParent;
\n sp<SurfaceListener> mSurfaceListener;
\n }; <\/p>\n

5.\u518d\u7ee7\u7eed\u5f80\u524d\u63a8\u8fd8\u662fconnect\u51fd\u6570，\u5982\u4e0b<\/p>\n

int Surface::connect(int api) {
\n static sp<IProducerListener> listener = new StubProducerListener();
\n return connect(api, listener);
\n}<\/p>\n

int Surface::connect(int api, const sp<IProducerListener>& listener) {
\n return connect(api, listener, false);
\n} <\/p>\n

\u53ef\u4ee5\u770b\u51fa\u6765\u6700\u7ec8\u662f\u5c06StubProducerListener\u5bf9\u8c61\u8bbe\u7f6e\u8fdb\u53bb\u4e86<\/p>\n

6.\u770b\u4e0bStubProducerListener<\/p>\n

class StubProducerListener : public BnProducerListener {
\npublic:
\n virtual ~StubProducerListener();
\n virtual void onBufferReleased() {}
\n virtual bool needsReleaseNotify() { return false; }
\n}; <\/p>\n

\u53ef\u4ee5\u770b\u51fa\u6765\u5176\u5b9e\u4ec0\u4e48\u90fd\u6ca1\u505a<\/p>\n<\/p>\n

\u4e94.\u603b\u7ed3<\/h2>\n