Android14 SurfaceFlinger的合成

frameworks/native/libs/gui/BufferQueueProducer.cpp

831  status_t BufferQueueProducer::queueBuffer(int slot,
832          const QueueBufferInput &input, QueueBufferOutput *output) {

1061      addAndGetFrameTimestamps(&newFrameEventsEntry,
1062              getFrameTimestamps ? &output->frameTimestamps : nullptr);

1075  
1076          if (frameAvailableListener != nullptr) {
1077              frameAvailableListener->onFrameAvailable(item);
1078          } else if (frameReplacedListener != nullptr) {
1079              frameReplacedListener->onFrameReplaced(item);
1080          }

android::BufferQueueConsumer::acquireBuffer BufferQueueConsumer.cpp:85
android::ConsumerBase::acquireBufferLocked ConsumerBase.cpp:392
android::BufferItemConsumer::acquireBuffer BufferItemConsumer.cpp:66
android::BLASTBufferQueue::acquireNextBufferLocked BLASTBufferQueue.cpp:474
android::BLASTBufferQueue::onFrameAvailable BLASTBufferQueue.cpp:694
android::ConsumerBase::onFrameAvailable ConsumerBase.cpp:157
android::BufferQueue::ProxyConsumerListener::onFrameAvailable BufferQueue.cpp:71
android::BufferQueueProducer::queueBuffer BufferQueueProducer.cpp:1054
android::Surface::queueBuffer Surface.cpp:1190
 

/frameworks/native/libs/gui/BufferQueue.cpp

62  void BufferQueue::ProxyConsumerListener::onFrameAvailable(
63          const BufferItem& item) {
64      sp<ConsumerListener> listener(mConsumerListener.promote());
65      if (listener != nullptr) {
66          listener->onFrameAvailable(item);
67      }
68  }

/frameworks/native/libs/gui/ConsumerBase.cpp

146  void ConsumerBase::onFrameAvailable(const BufferItem& item) {
147      CB_LOGV("onFrameAvailable");
148  
149      sp<FrameAvailableListener> listener;
150      { // scope for the lock
151          Mutex::Autolock lock(mFrameAvailableMutex);
152          listener = mFrameAvailableListener.promote();
153      }
154  
155      if (listener != nullptr) {
156          CB_LOGV("actually calling onFrameAvailable");
157          listener->onFrameAvailable(item);
158      }
159  }

追溯下此listen的历史

 /frameworks/native/libs/gui/ConsumerBase.cpp

237  void ConsumerBase::setFrameAvailableListener(
238          const wp<FrameAvailableListener>& listener) {
239      CB_LOGV("setFrameAvailableListener");
240      Mutex::Autolock lock(mFrameAvailableMutex);
241      mFrameAvailableListener = listener;
242  }

147  BLASTBufferQueue::BLASTBufferQueue(const std::string& name, bool updateDestinationFrame)
148        : mSurfaceControl(nullptr),
149          mSize(1, 1),
150          mRequestedSize(mSize),
151          mFormat(PIXEL_FORMAT_RGBA_8888),
152          mTransactionReadyCallback(nullptr),
153          mSyncTransaction(nullptr),
154          mUpdateDestinationFrame(updateDestinationFrame) {

172      mBufferItemConsumer->setFrameAvailableListener(this);
173  

/frameworks/native/libs/gui/BLASTBufferQueue.cpp 

696  void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) {
697      std::function<void(SurfaceComposerClient::Transaction*)> prevCallback = nullptr;
698      SurfaceComposerClient::Transaction* prevTransaction = nullptr;
699  
700      {
701          UNIQUE_LOCK_WITH_ASSERTION(mMutex);
702          BBQ_TRACE();
703          bool waitForTransactionCallback = !mSyncedFrameNumbers.empty();
704  
705          const bool syncTransactionSet = mTransactionReadyCallback != nullptr;
706          BQA_LOGV("onFrameAvailable-start syncTransactionSet=%s", boolToString(syncTransactionSet));
707  
708          if (syncTransactionSet) {
709              // If we are going to re-use the same mSyncTransaction, release the buffer that may
710              // already be set in the Transaction. This is to allow us a free slot early to continue
711              // processing a new buffer.
712              if (!mAcquireSingleBuffer) {
713                  auto bufferData = mSyncTransaction->getAndClearBuffer(mSurfaceControl);
714                  if (bufferData) {
715                      BQA_LOGD("Releasing previous buffer when syncing: framenumber=%" PRIu64,
716                               bufferData->frameNumber);
717                      releaseBuffer(bufferData->generateReleaseCallbackId(),
718                                    bufferData->acquireFence);
719                  }
720              }
721  
722              if (waitForTransactionCallback) {
723                  // We are waiting on a previous sync's transaction callback so allow another sync
724                  // transaction to proceed.
725                  //
726                  // We need to first flush out the transactions that were in between the two syncs.
727                  // We do this by merging them into mSyncTransaction so any buffer merging will get
728                  // a release callback invoked.
729                  while (mNumFrameAvailable > 0) {
730                      // flush out the shadow queue
731                      acquireAndReleaseBuffer();
732                  }
733              } else {
734                  // Make sure the frame available count is 0 before proceeding with a sync to ensure
735                  // the correct frame is used for the sync. The only way mNumFrameAvailable would be
736                  // greater than 0 is if we already ran out of buffers previously. This means we
737                  // need to flush the buffers before proceeding with the sync.
738                  while (mNumFrameAvailable > 0) {
739                      BQA_LOGD("waiting until no queued buffers");
740                      mCallbackCV.wait(_lock);
741                  }
742              }
743          }
744  
745          // add to shadow queue
746          mNumFrameAvailable++;
747          if (waitForTransactionCallback && mNumFrameAvailable >= 2) {
748              acquireAndReleaseBuffer();
749          }
750          ATRACE_INT(mQueuedBufferTrace.c_str(),
751                     mNumFrameAvailable + mNumAcquired - mPendingRelease.size());
752  
753          BQA_LOGV("onFrameAvailable framenumber=%" PRIu64 " syncTransactionSet=%s",
754                   item.mFrameNumber, boolToString(syncTransactionSet));
755  
756          if (syncTransactionSet) {
757              // Add to mSyncedFrameNumbers before waiting in case any buffers are released
758              // while waiting for a free buffer. The release and commit callback will try to
759              // acquire buffers if there are any available, but we don't want it to acquire
760              // in the case where a sync transaction wants the buffer.
761              mSyncedFrameNumbers.emplace(item.mFrameNumber);
762              // If there's no available buffer and we're in a sync transaction, we need to wait
763              // instead of returning since we guarantee a buffer will be acquired for the sync.
764              while (acquireNextBufferLocked(mSyncTransaction) == BufferQueue::NO_BUFFER_AVAILABLE) {
765                  BQA_LOGD("waiting for available buffer");
766                  mCallbackCV.wait(_lock);
767              }
768  
769              // Only need a commit callback when syncing to ensure the buffer that's synced has been
770              // sent to SF
771              incStrong((void*)transactionCommittedCallbackThunk);
772              mSyncTransaction->addTransactionCommittedCallback(transactionCommittedCallbackThunk,
773                                                                static_cast<void*>(this));
774              if (mAcquireSingleBuffer) {
775                  prevCallback = mTransactionReadyCallback;
776                  prevTransaction = mSyncTransaction;
777                  mTransactionReadyCallback = nullptr;
778                  mSyncTransaction = nullptr;
779              }
780          } else if (!waitForTransactionCallback) {
781              acquireNextBufferLocked(std::nullopt);
782          }
783      }
784      if (prevCallback) {
785          prevCallback(prevTransaction);
786      }
787  }

505  status_t BLASTBufferQueue::acquireNextBufferLocked(
506          const std::optional<SurfaceComposerClient::Transaction*> transaction) {
507      // Check if we have frames available and we have not acquired the maximum number of buffers.
508      // Even with this check, the consumer can fail to acquire an additional buffer if the consumer
509      // has already acquired (mMaxAcquiredBuffers + 1) and the new buffer is not droppable. In this
510      // case mBufferItemConsumer->acquireBuffer will return with NO_BUFFER_AVAILABLE.
511      if (mNumFrameAvailable == 0) {
512          BQA_LOGV("Can't acquire next buffer. No available frames");
513          return BufferQueue::NO_BUFFER_AVAILABLE;
514      }
515  
516      if (mNumAcquired >= (mMaxAcquiredBuffers + 2)) {
517          BQA_LOGV("Can't acquire next buffer. Already acquired max frames %d max:%d + 2",
518                   mNumAcquired, mMaxAcquiredBuffers);
519          return BufferQueue::NO_BUFFER_AVAILABLE;
520      }
521  
522      if (mSurfaceControl == nullptr) {
523          BQA_LOGE("ERROR : surface control is null");
524          return NAME_NOT_FOUND;
525      }
526  
527      SurfaceComposerClient::Transaction localTransaction;
528      bool applyTransaction = true;
529      SurfaceComposerClient::Transaction* t = &localTransaction;
530      if (transaction) {
531          t = *transaction;
532          applyTransaction = false;
533      }
534  
535      BufferItem bufferItem;
536  
537      status_t status =
538              mBufferItemConsumer->acquireBuffer(&bufferItem, 0 /* expectedPresent */, false);
539      if (status == BufferQueue::NO_BUFFER_AVAILABLE) {
540          BQA_LOGV("Failed to acquire a buffer, err=NO_BUFFER_AVAILABLE");
541          return status;
542      } else if (status != OK) {
543          BQA_LOGE("Failed to acquire a buffer, err=%s", statusToString(status).c_str());
544          return status;
545      }
546  
547      auto buffer = bufferItem.mGraphicBuffer;
548      mNumFrameAvailable--;
549      BBQ_TRACE("frame=%" PRIu64, bufferItem.mFrameNumber);
550  
551      if (buffer == nullptr) {
552          mBufferItemConsumer->releaseBuffer(bufferItem, Fence::NO_FENCE);
553          BQA_LOGE("Buffer was empty");
554          return BAD_VALUE;
555      }
556  
557      if (rejectBuffer(bufferItem)) {
558          BQA_LOGE("rejecting buffer:active_size=%dx%d, requested_size=%dx%d "
559                   "buffer{size=%dx%d transform=%d}",
560                   mSize.width, mSize.height, mRequestedSize.width, mRequestedSize.height,
561                   buffer->getWidth(), buffer->getHeight(), bufferItem.mTransform);
562          mBufferItemConsumer->releaseBuffer(bufferItem, Fence::NO_FENCE);
563          return acquireNextBufferLocked(transaction);
564      }
565  
566      mNumAcquired++;
567      mLastAcquiredFrameNumber = bufferItem.mFrameNumber;
568      ReleaseCallbackId releaseCallbackId(buffer->getId(), mLastAcquiredFrameNumber);
569      mSubmitted[releaseCallbackId] = bufferItem;
570  
571      bool needsDisconnect = false;
572      mBufferItemConsumer->getConnectionEvents(bufferItem.mFrameNumber, &needsDisconnect);
573  
574      // if producer disconnected before, notify SurfaceFlinger
575      if (needsDisconnect) {
576          t->notifyProducerDisconnect(mSurfaceControl);
577      }
578  
579      // Ensure BLASTBufferQueue stays alive until we receive the transaction complete callback.
580      incStrong((void*)transactionCallbackThunk);
581  
582      // Only update mSize for destination bounds if the incoming buffer matches the requested size.
583      // Otherwise, it could cause stretching since the destination bounds will update before the
584      // buffer with the new size is acquired.
585      if (mRequestedSize == getBufferSize(bufferItem) ||
586          bufferItem.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE) {
587          mSize = mRequestedSize;
588      }
589      Rect crop = computeCrop(bufferItem);
590      mLastBufferInfo.update(true /* hasBuffer */, bufferItem.mGraphicBuffer->getWidth(),
591                             bufferItem.mGraphicBuffer->getHeight(), bufferItem.mTransform,
592                             bufferItem.mScalingMode, crop);
593  
594      auto releaseBufferCallback =
595              std::bind(releaseBufferCallbackThunk, wp<BLASTBufferQueue>(this) /* callbackContext */,
596                        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
597      sp<Fence> fence = bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE;
598      t->setBuffer(mSurfaceControl, buffer, fence, bufferItem.mFrameNumber, mProducerId,
599                   releaseBufferCallback);
600      t->setDataspace(mSurfaceControl, static_cast<ui::Dataspace>(bufferItem.mDataSpace));
601      t->setHdrMetadata(mSurfaceControl, bufferItem.mHdrMetadata);
602      t->setSurfaceDamageRegion(mSurfaceControl, bufferItem.mSurfaceDamage);
603      t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));
604  
605      mSurfaceControlsWithPendingCallback.push(mSurfaceControl);
606  
607      if (mUpdateDestinationFrame) {
608          t->setDestinationFrame(mSurfaceControl, Rect(mSize));
609      } else {
610          const bool ignoreDestinationFrame =
611                  bufferItem.mScalingMode == NATIVE_WINDOW_SCALING_MODE_FREEZE;
612          t->setFlags(mSurfaceControl,
613                      ignoreDestinationFrame ? layer_state_t::eIgnoreDestinationFrame : 0,
614                      layer_state_t::eIgnoreDestinationFrame);
615      }
616      t->setBufferCrop(mSurfaceControl, crop);
617      t->setTransform(mSurfaceControl, bufferItem.mTransform);
618      t->setTransformToDisplayInverse(mSurfaceControl, bufferItem.mTransformToDisplayInverse);
619      t->setAutoRefresh(mSurfaceControl, bufferItem.mAutoRefresh);
620      if (!bufferItem.mIsAutoTimestamp) {
621          t->setDesiredPresentTime(bufferItem.mTimestamp);
622      }
623  
624      // Drop stale frame timeline infos
625      while (!mPendingFrameTimelines.empty() &&
626             mPendingFrameTimelines.front().first < bufferItem.mFrameNumber) {
627          ATRACE_FORMAT_INSTANT("dropping stale frameNumber: %" PRIu64 " vsyncId: %" PRId64,
628                                mPendingFrameTimelines.front().first,
629                                mPendingFrameTimelines.front().second.vsyncId);
630          mPendingFrameTimelines.pop();
631      }
632  
633      if (!mPendingFrameTimelines.empty() &&
634          mPendingFrameTimelines.front().first == bufferItem.mFrameNumber) {
635          ATRACE_FORMAT_INSTANT("Transaction::setFrameTimelineInfo frameNumber: %" PRIu64
636                                " vsyncId: %" PRId64,
637                                bufferItem.mFrameNumber,
638                                mPendingFrameTimelines.front().second.vsyncId);
639          t->setFrameTimelineInfo(mPendingFrameTimelines.front().second);
640          mPendingFrameTimelines.pop();
641      }
642  
643      {
644          std::lock_guard _lock{mTimestampMutex};
645          auto dequeueTime = mDequeueTimestamps.find(buffer->getId());
646          if (dequeueTime != mDequeueTimestamps.end()) {
647              Parcel p;
648              p.writeInt64(dequeueTime->second);
649              t->setMetadata(mSurfaceControl, gui::METADATA_DEQUEUE_TIME, p);
650              mDequeueTimestamps.erase(dequeueTime);
651          }
652      }
653  
654      mergePendingTransactions(t, bufferItem.mFrameNumber);
655      if (applyTransaction) {
656          // All transactions on our apply token are one-way. See comment on mAppliedLastTransaction
657          t->setApplyToken(mApplyToken).apply(false, true);
658          mAppliedLastTransaction = true;
659          mLastAppliedFrameNumber = bufferItem.mFrameNumber;
660      } else {
661          t->setBufferHasBarrier(mSurfaceControl, mLastAppliedFrameNumber);
662          mAppliedLastTransaction = false;
663      }
664  
665      BQA_LOGV("acquireNextBufferLocked size=%dx%d mFrameNumber=%" PRIu64
666               " applyTransaction=%s mTimestamp=%" PRId64 "%s mPendingTransactions.size=%d"
667               " graphicBufferId=%" PRIu64 "%s transform=%d",
668               mSize.width, mSize.height, bufferItem.mFrameNumber, boolToString(applyTransaction),
669               bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp ? "(auto)" : "",
670               static_cast<uint32_t>(mPendingTransactions.size()), bufferItem.mGraphicBuffer->getId(),
671               bufferItem.mAutoRefresh ? " mAutoRefresh" : "", bufferItem.mTransform);
672      return OK;
673  }

 frameworks/native/libs/gui/BufferItemConsumer.cpp

58  status_t BufferItemConsumer::acquireBuffer(BufferItem *item,
59          nsecs_t presentWhen, bool waitForFence) {
60      status_t err;
61  
62      if (!item) return BAD_VALUE;
63  
64      Mutex::Autolock _l(mMutex);
65  
66      err = acquireBufferLocked(item, presentWhen);
67      if (err != OK) {
68          if (err != NO_BUFFER_AVAILABLE) {
69              BI_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
70          }
71          return err;
72      }
73  
74      if (waitForFence) {
75          err = item->mFence->waitForever("BufferItemConsumer::acquireBuffer");
76          if (err != OK) {
77              BI_LOGE("Failed to wait for fence of acquired buffer: %s (%d)",
78                      strerror(-err), err);
79              return err;
80          }
81      }
82  
83      item->mGraphicBuffer = mSlots[item->mSlot].mGraphicBuffer;
84  
85     

/frameworks/native/libs/gui/ConsumerBase.cpp 

385  status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
386          nsecs_t presentWhen, uint64_t maxFrameNumber) {
387      if (mAbandoned) {
388          CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!");
389          return NO_INIT;
390      }
391  
392      status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
393      if (err != NO_ERROR) {
394          return err;
395      }
396  
397      if (item->mGraphicBuffer != nullptr) {
398          if (mSlots[item->mSlot].mGraphicBuffer != nullptr) {
399              freeBufferLocked(item->mSlot);
400          }
401          mSlots[item->mSlot].mGraphicBuffer = item->mGraphicBuffer;
402      }
403  
404      mSlots[item->mSlot].mFrameNumber = item->mFrameNumber;
405      mSlots[item->mSlot].mFence = item->mFence;
406  
407      CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64,
408              item->mSlot, item->mFrameNumber);
409  
410      return OK;
411  }

frameworks/native/libs/gui/BufferQueueConsumer.cpp 

79  status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
80          nsecs_t expectedPresent, uint64_t maxFrameNumber) {

BLASTBufferQueue::queueBuffer 成功后，通过 listener->addAndGetFrameTimestamps 通知Queue成功时间

/frameworks/native/libs/gui/BufferQueueProducer.cpp 

1675  void BufferQueueProducer::addAndGetFrameTimestamps(
1676          const NewFrameEventsEntry* newTimestamps,
1677          FrameEventHistoryDelta* outDelta) {
1678      if (newTimestamps == nullptr && outDelta == nullptr) {
1679          return;
1680      }
1681  
1682      ATRACE_CALL();
1683      BQ_LOGV("addAndGetFrameTimestamps");
1684      sp<IConsumerListener> listener;
1685      {
1686          std::lock_guard<std::mutex> lock(mCore->mMutex);
1687          listener = mCore->mConsumerListener;
1688      }
1689      if (listener != nullptr) {
1690          listener->addAndGetFrameTimestamps(newTimestamps, outDelta);
1691      }
1692  }