深入淺出Android BufferQueue

1. 背景

對業務開發來說，無法接觸到BufferQueue，甚至不知道BufferQueue是什麼東西。對系統來說，BufferQueue是很重要的傳遞數據的組件，Android顯示系統依賴於BufferQueue，只要顯示內容到“屏幕”(此處指抽象的屏幕，有時候還可以包含編碼器)，就一定需要用到BufferQueue，可以說在顯示/播放器相關的領悟中，BufferQueue無處不在。即使直接調用Opengl ES來繪製，底層依然需要BufferQueue才能顯示到屏幕上。

弄明白BufferQueue，不僅可以增強對Android系統的瞭解，還可以弄明白/排查相關的問題，如爲什麼Mediacodec調用dequeueBuffer老是返回-1？爲什麼普通View的draw方法直接繪製內容即可，SurfaceView在draw完畢後還需要unlockCanvasAndPost？

注：本文分析的代碼來自於Android6.0.1。

2. BufferQueue內部運作方式

BufferQueue是Android顯示系統的核心，它的設計哲學是生產者-消費者模型，只要往BufferQueue中填充數據，則認爲是生產者，只要從BufferQueue中獲取數據，則認爲是消費者。有時候同一個類，在不同的場景下既可能是生產者也有可能是消費者。如SurfaceFlinger，在合成並顯示UI內容時，UI元素作爲生產者生產內容，SurfaceFlinger作爲消費者消費這些內容。而在截屏時，SurfaceFlinger又作爲生產者將當前合成顯示的UI內容填充到另一個BufferQueue，截屏應用此時作爲消費者從BufferQueue中獲取數據並生產截圖。

以下是Android官網對其的介紹：

以下是常見的BufferQueue使用步驟：

初始化一個BufferQueue
圖形數據的生產者通過BufferQueue申請一塊GraphicBuffer，對應圖中的dequeueBuffer方法
申請到GraphicBuffer後，獲取GraphicBuffer，通過函數requestBuffer獲取
獲取到GraphicBuffer後，通過各種形式往GraphicBuffer中填充圖形數據後，然後將GraphicBuffer入隊到BufferQueue中，對應上圖中的queueBuffer方法
在新的GraphicBuffer入隊BufferQueue時，BufferQueue會通過回調通知圖形數據的消費者，有新的圖形數據被生產出來了
然後消費者從BufferQueue中出隊一個GraphicBuffer，對應圖中的acquireBuffer方法
待消費者消費完圖形數據後，將空的GraphicBuffer還給BufferQueue以便重複利用，此時對應上圖中的releaseBuffer方法
此時BufferQueue再通過回調通知圖形數據的生產者有空的GraphicBuffer了，圖形數據的生產者又可以從BufferQueue中獲取一個空的GraphicBuffer來填充數據
一直循環2-8步驟，這樣就有條不紊的完成了圖形數據的生產-消費

當然圖形數據的生產者可以不用等待BufferQueue的回調再生產數據，而是一直生產數據然後入隊到BufferQueue，直到BufferQueue滿爲止。圖形數據的消費者也可以不用等BufferQueue的回調通知，每次都從BufferQueue中嘗試獲取數據，獲取失敗則嘗試，只是這樣效率比較低，需要不斷的輪訓BufferQueue（因爲BufferQueue有同步阻塞和非同步阻塞兩種機種，在非同步阻塞機制下獲取數據失敗不會阻塞該線程直到有數據才喚醒該線程，而是直接返回-1）。

同時使用BufferQueue的生產者和消費者往往處在不同的進程，BufferQueue內部使用共享內存和Binder在不同的進程傳遞數據，減少數據拷貝提高效率。

和BufferQueue有關的幾個類分別是：

BufferBufferCore：BufferQueue的實際實現
BufferSlot：用來存儲GraphicBuffer
BufferState：表示GraphicBuffer的狀態
IGraphicBufferProducer：BufferQueue的生產者接口，實現類是BufferQueueProducer
IGraphicBufferConsumer：BufferQueue的消費者接口，實現類是BufferQueueConsumer
GraphicBuffer：表示一個Buffer，可以填充圖像數據
ANativeWindow_Buffer：GraphicBuffer的父類
ConsumerBase：實現了ConsumerListener接口，在數據入隊列時會被調用到，用來通知消費者

BufferQueue中用BufferSlot來存儲GraphicBuffer，使用數組來存儲一系列BufferSlot，數組默認大小爲64。

GraphicBuffer用BufferState來表示其狀態，有以下狀態：

FREE：表示該Buffer沒有被生產者-消費者所使用，該Buffer的所有權屬於BufferQueue
DEQUEUED：表示該Buffer被生產者獲取了，該Buffer的所有權屬於生產者
QUEUED：表示該Buffer被生產者填充了數據，並且入隊到BufferQueue了，該Buffer的所有權屬於BufferQueue
ACQUIRED：表示該Buffer被消費者獲取了，該Buffer的所有權屬於消費者

爲什麼需要這些狀態呢？假設不需要這些狀態，實現一個簡單的BufferQueue，假設是如下實現：

BufferQueue{
 vector<GraphicBuffer> slots;
 void push(GraphicBuffer slot){
 slots.push(slot);
 }
 GraphicBuffer pull(){
 return slots.pull();
 }
}

生產者生產完數據後，通過調用BufferQueue的push函數將數據插入到vector中。消費者調用BufferQueue的pull函數出隊一個Buffer數據。

上述實現的問題在於，生產者每次都需要自行創建GraphicBuffer，而消費者每次消費完數據後的GraphicBuffer就被釋放了，GraphicBuffer沒有得到循環利用。而在Android中，由於BufferQueue的生產者-消費者往往處於不同的進程，GraphicBuffer內部是需要通過共享內存來連接生成者-消費者進程的，每次創建GraphicBuffer，即意味着需要創建共享內存，效率較低。

而BufferQueue中用BufferState來表示GraphicBuffer的狀態則解決了這個問題。每個GraphicBuffer都有當前的狀態，通過維護GraphicBuffer的狀態，完成GraphicBuffer的複用。

由於BufferQueue內部實現是BufferQueueCore，下文均用BufferQueueCore代替BufferQueue。先介紹下BufferQueueCore內部相應的數據結構，再介紹BufferQueue的狀態扭轉過程和生產-消費過程。

以下是Buffer的入隊/出隊操作和BufferState的狀態扭轉的過程，這裏只介紹非同步阻塞模式。

2.1 BufferQueueCore內部數據結構

核心數據結構如下：

BufferQueueDefs::SlotsType mSlots：用數組存放的Slot，數組默認大小爲BufferQueueDefs::NUM_BUFFER_SLOTS,具體是64，代表所有的Slot
std::set<int> mFreeSlots：當前所有的狀態爲FREE的Slot，這些Slot沒有關聯上具體的GraphicBuffer，後續用的時候還需要關聯上GraphicBuffer
std::list<int> mFreeBuffers：當前所有的狀態爲FREE的Slot，這些Slot已經關聯上具體的GraphicBuffer，可以直接使用
Fifo mQueue：一個先進先出隊列，保存了生產者生產的數據

在BufferQueueCore初始化時，由於此時隊列中沒有入隊任何數據，按照上面的介紹，此時mFreeSlots應該包含所有的Slot，元素大小和mSlots一致，初始化代碼如下：

for (int slot = 0; slot < BufferQueueDefs::NUM_BUFFER_SLOTS; ++slot) {
 mFreeSlots.insert(slot);
 }

2.2 生產者dequeueBuffer

當生產者可以生產圖形數據時，首先向BufferQueue中申請一塊GraphicBuffer。調用函數是BufferQueueProducer.dequeueBuffer，如果當前BufferQueue中有可用的GraphicBuffer，則返回其對用的索引，如果不存在，則返回-1，代碼在BufferQueueProducer，流程如下：

status_t BufferQueueProducer::dequeueBuffer(int *outSlot,
 sp<android::Fence> *outFence, bool async,
 uint32_t width, uint32_t height, PixelFormat format, uint32_t usage) {
 //1. 尋找可用的Slot，可用指Buffer狀態爲FREE
 status_t status = waitForFreeSlotThenRelock("dequeueBuffer", async,
 &found, &returnFlags);
 if (status != NO_ERROR) {
 return status;
 }
 //2.找到可用的Slot，將Buffer狀態設置爲DEQUEUED，由於步驟1找到的Slot狀態爲FREE,因此這一步完成了FREE到DEQUEUED的狀態切換
 *outSlot = found;
 ATRACE_BUFFER_INDEX(found);
 attachedByConsumer = mSlots[found].mAttachedByConsumer;
 mSlots[found].mBufferState = BufferSlot::DEQUEUED;
 //3. 找到的Slot如果需要申請GraphicBuffer，則申請GraphicBuffer，這裏採用了懶加載機制，如果內存沒有申請，申請內存放在生產者來處理
 if (returnFlags & BUFFER_NEEDS_REALLOCATION) {
 status_t error;
 sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer(width, height, format, usage, &error));
 graphicBuffer->setGenerationNumber(mCore->mGenerationNumber);
 mSlots[*outSlot].mGraphicBuffer = graphicBuffer;
 }
}

關鍵在於尋找可用Slot，waitForFreeSlotThenRelock的流程如下：

status_t BufferQueueProducer::waitForFreeSlotThenRelock(const char* caller,
 bool async, int* found, status_t* returnFlags) const {
 //1. mQueue 是否太多
 bool tooManyBuffers = mCore->mQueue.size()> static_cast<size_t>(maxBufferCount);
 if (tooManyBuffers) {
 } else {
 // 2. 先查找mFreeBuffers中是否有可用的，由2.1介紹可知，mFreeBuffers中的元素關聯了GraphicBuffer，直接可用
 if (!mCore->mFreeBuffers.empty()) {
 auto slot = mCore->mFreeBuffers.begin();
 *found = *slot;
 mCore->mFreeBuffers.erase(slot);
 } else if (mCore->mAllowAllocation && !mCore->mFreeSlots.empty()) {
 // 3. 再查找mFreeSlots中是否有可用的，由2.1可知，初始化時會填充滿這個列表，因此第一次調用一定不會爲空。同時用這個列表中的元素需要關聯上GraphicBuffer纔可以直接使用，關聯的過程由外層函數來實現
 auto slot = mCore->mFreeSlots.begin();
 // Only return free slots up to the max buffer count
 if (*slot < maxBufferCount) {
 *found = *slot;
 mCore->mFreeSlots.erase(slot);
 }
 }
 }
 tryAgain = (*found == BufferQueueCore::INVALID_BUFFER_SLOT) ||
 tooManyBuffers;
 //4. 如果找不到可用的Slot或者Buffer太多（同步阻塞模式下），則可能需要等
 if (tryAgain) {
 if (mCore->mDequeueBufferCannotBlock &&
 (acquiredCount <= mCore->mMaxAcquiredBufferCount)) {
 return WOULD_BLOCK;
 }
 mCore->mDequeueCondition.wait(mCore->mMutex);
 }
}
waitForFreeSlotThenRelock函數會嘗試尋找一個可用的Slot，可用的Slot狀態一定是FREE（因爲是從兩個FREE狀態的列表中獲取的），然後dequeueBuffer將狀態改變爲DEQUEUED，即完成了狀態的扭轉。

waitForFreeSlotThenRelock返回可用的Slot分爲兩種：

從mFreeBuffers中獲取到的，mFreeBuffers中的元素關聯了GraphicBuffer，直接可用
從mFreeSlots中獲取到的，沒有關聯上GraphicBuffer，因此需要申請GraphicBuffer並和Slot關聯上，通過createGraphicBuffer申請一個GraphicBuffer，然後賦值給Slot的mGraphicBuffer完成關聯

小結dequeueBuffer：嘗試找到一個Slot，並完成Slot與GraphicBuffer的關聯（如果需要），然後將Slot的狀態由FREE扭轉成DEQUEUED。返回Slot在BufferQueueCore中mSlots對應的索引。

2.3 生產者requestBuffer

dequeueBuffer函數獲取到了可用Slot的索引後，通過requestBuffer獲取到對應的GraphicBuffer。流程如下：

status_t BufferQueueProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
 // 1. 判斷slot參數是否合法
 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
 BQ_LOGE("requestBuffer: slot index %d out of range [0, %d)",
 slot, BufferQueueDefs::NUM_BUFFER_SLOTS);
 return BAD_VALUE;
 } else if (mSlots[slot].mBufferState != BufferSlot::DEQUEUED) {
 BQ_LOGE("requestBuffer: slot %d is not owned by the producer "
 "(state = %d)", slot, mSlots[slot].mBufferState);
 return BAD_VALUE;
 }
 //2. 將mRequestBufferCalled置爲true
 mSlots[slot].mRequestBufferCalled = true;
 *buf = mSlots[slot].mGraphicBuffer;
 return NO_ERROR;
}

這一步不是必須的。業務層可以直接通過Slot的索引獲取到對應的GraphicBuffer。

2.4 生產者queueBuffer

上文dequeueBuffer獲取到一個Slot後，就可以在Slot對應的GraphicBuffer上完成圖像數據的生產了，可以是View的主線程Draw過程，也可以是SurfaceView的子線程繪製過程，甚至可以是MediaCodec的解碼過程。

填充完圖像數據後，需要將Slot入隊BufferQueueCore（數據寫完了，可以傳給生產者-消費者隊列，讓消費者來消費了），入隊調用queueBuffer函數。queueBuffer的流程如下：

status_t BufferQueueProducer::queueBuffer(int slot,
 const QueueBufferInput &input, QueueBufferOutput *output) {
 // 1. 先判斷傳入的Slot是否合法
 if (slot < 0 || slot >= maxBufferCount) {
 BQ_LOGE("queueBuffer: slot index %d out of range [0, %d)",
 slot, maxBufferCount);
 return BAD_VALUE;
 }
 //2. 將Buffer狀態扭轉成QUEUED，此步完成了Buffer的狀態由DEQUEUED到QUEUED的過程
 mSlots[slot].mFence = fence;
 mSlots[slot].mBufferState = BufferSlot::QUEUED;
 ++mCore->mFrameCounter;
 mSlots[slot].mFrameNumber = mCore->mFrameCounter;
 //3. 入隊mQueue
 if (mCore->mQueue.empty()) {
 mCore->mQueue.push_back(item);
 frameAvailableListener = mCore->mConsumerListener;
 }
 // 4. 回調frameAvailableListener，告知消費者有數據入隊了
 if (frameAvailableListener != NULL) {
 frameAvailableListener->onFrameAvailable(item);
 } else if (frameReplacedListener != NULL) {
 frameReplacedListener->onFrameReplaced(item);
 }
}
從上面的註釋可以看到，queueBuffer的主要步驟如下：

將Buffer狀態扭轉成QUEUED，此步完成了Buffer的狀態由DEQUEUED到QUEUED的過程
將Buffer入隊到BufferQueueCore的mQueue隊列中
回調frameAvailableListener，告知消費者有數據入隊，可以來消費數據了，frameAvailableListener是消費者註冊的回調

小結queueBuffer：將Slot的狀態扭轉成QUEUED，並添加到mQueue中，最後通知消費者有數據入隊。

2.5 消費者acquireBuffer

在消費者接收到onFrameAvailable回調時或者消費者主動想要消費數據，調用acquireBuffer嘗試向BufferQueueCore獲取一個數據以供消費。消費者的代碼在BufferQueueConsumer中，acquireBuffer流程如下：

status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
 nsecs_t expectedPresent, uint64_t maxFrameNumber) {
 //1. 如果隊列爲空，則直接返回
 if (mCore->mQueue.empty()) {
 return NO_BUFFER_AVAILABLE;
 }
 //2. 取出mQueue隊列的第一個元素，並從隊列中移除
 BufferQueueCore::Fifo::iterator front(mCore->mQueue.begin());
 int slot = front->mSlot;
 *outBuffer = *front;
 mCore->mQueue.erase(front);
 //3. 處理expectedPresent的情況，這種情況可能會連續丟幾個Slot的“顯示”時間小於expectedPresent的情況,這種情況下這些Slot已經是“過時”的，直接走下文的releaseBuffer消費流程,代碼比較長，忽略了
 
 //4. 更新Slot的狀態爲ACQUIRED
 if (mCore->stillTracking(front)) {
 mSlots[slot].mAcquireCalled = true;
 mSlots[slot].mNeedsCleanupOnRelease = false;
 mSlots[slot].mBufferState = BufferSlot::ACQUIRED;
 mSlots[slot].mFence = Fence::NO_FENCE;
 }
 //5. 如果步驟3有直接releaseBuffer的過程，則回調生產者，有數據被消費了
 if (listener != NULL) {
 for (int i = 0; i < numDroppedBuffers; ++i) {
 listener->onBufferReleased();
 }
 }
}

從上面的註釋可以看到，acquireBuffer的主要步驟如下：

從mQueue隊列中取出並移除一個元素
改變Slot對應的狀態爲ACQUIRED
如果有丟幀邏輯，回調告知生產者有數據被消費，生產者可以準備生產數據了

小結acquireBuffer：將Slot的狀態扭轉成ACQUIRED，並從mQueue中移除，最後通知生產者有數據出隊。

2.6 消費者releaseBuffer

消費者獲取到Slot後開始消費數據（典型的消費如SurfaceFlinger的UI合成），消費完畢後，需要告知BufferQueueCore這個Slot被消費者消費完畢了，可以給生產者重新生產數據，releaseBuffer流程如下：

status_t BufferQueueConsumer::releaseBuffer(int slot, uint64_t frameNumber,
 const sp<Fence>& releaseFence, EGLDisplay eglDisplay,EGLSyncKHR eglFence) {
 //1. 檢查Slot是否合法
 if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS || 
 return BAD_VALUE;
 }
 //2. 容錯處理：如果要處理的Slot存在於mQueue中，那麼說明這個Slot的來源不合法，並不是從2.5的acquireBuffer獲取的Slot，拒絕處理
 BufferQueueCore::Fifo::iterator current(mCore->mQueue.begin());
 while (current != mCore->mQueue.end()) {
 if (current->mSlot == slot) {
 return BAD_VALUE;
 }
 ++current;
 }
 // 3. 將Slot的狀態扭轉爲FREE，之前是ACQUIRED，並將該Slot添加到BufferQueueCore的mFreeBuffers列表中（mFreeBuffers的定義參考2.1的介紹）
 if (mSlots[slot].mBufferState == BufferSlot::ACQUIRED) {
 mSlots[slot].mEglDisplay = eglDisplay;
 mSlots[slot].mEglFence = eglFence;
 mSlots[slot].mFence = releaseFence;
 mSlots[slot].mBufferState = BufferSlot::FREE;
 mCore->mFreeBuffers.push_back(slot);
 listener = mCore->mConnectedProducerListener;
 BQ_LOGV("releaseBuffer: releasing slot %d", slot);
 }
 // 4. 回調生產者，有數據被消費了
 if (listener != NULL) {
 listener->onBufferReleased();
 }
}

從上面的註釋可以看到，releaseBuffer的主要步驟如下：

將Slot的狀態扭轉爲FREE
將被消費的Slot添加到mFreeBuffers供後續的生產者dequeueBuffer使用
回調告知生產者有數據被消費，生產者可以準備生產數據了

小結releaseBuffer：將Slot的狀態扭轉成FREE，並添加到BufferQueueCore mFreeBuffers隊列中，最後通知生產者有數據出隊。

總結下狀態變化的過程：

上面主要介紹了BufferQueue的設計思想和內部實現。

下面將繼續介紹BufferQueue，着重介紹Android中對於BufferQueue的常用封裝，以及SurfaceView中使用BufferQueue的具體實現。

3.BufferQueue常用封裝類

在實際應用中，除了直接使用BuferQueue外，更多的是使用Surface/SurfaceTexture，其對BufferQueue做了包裝，方便業務更方便的使用BufferQueue。Surface作爲BufferQueue的生產者，SurfaceTexture作爲BufferQueue的消費者。

3.1 Surface

Surface的構造函數如下：

Surface::Surface(

const sp<IGraphicBufferProducer>& bufferProducer,

bool controlledByApp)

: mGraphicBufferProducer(bufferProducer),

mGenerationNumber(0)

構造函數需要傳入一個生產者的引用，和BufferQueue的交互均有這個生產者的引用來完成。dequeueBuffer的流程如下：

int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
 // 1. 調用mGraphicBufferProducer的dequeueBuffer方法，嘗試獲取一個Slot索引
 int buf = -1;
 sp<Fence> fence;
 status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, swapIntervalZero,
 reqWidth, reqHeight, reqFormat, reqUsage);
 if (result < 0) {
 ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer(%d, %d, %d, %d, %d)"
 "failed: %d", swapIntervalZero, reqWidth, reqHeight, reqFormat,
 reqUsage, result);
 return result;
 }
 // 2. 調用mGraphicBufferProducer的requestBuffer方法，嘗試獲取Slot
 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
 if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
 result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
 if (result != NO_ERROR) {
 ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
 mGraphicBufferProducer->cancelBuffer(buf, fence);
 return result;
 }
 }
 // 3. 返回GraphicBuffer
 *buffer = gbuf.get();
}

queueBuffer也是如下，流程如下：

int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
 IGraphicBufferProducer::QueueBufferOutput output;
 IGraphicBufferProducer::QueueBufferInput input(timestamp, isAutoTimestamp,
 mDataSpace, crop, mScalingMode, mTransform ^ mStickyTransform,
 mSwapIntervalZero, fence, mStickyTransform);
 // 1. 直接調用mGraphicBufferProducer的queueBuffer方法即可
 status_t err = mGraphicBufferProducer->queueBuffer(i, input, &output);
 if (err != OK) {
 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
 }
}

Surface還提供了lock函數，用來支持雙緩衝，內部也是調用dequeueBuffer方法獲取最新的Buffer：

status_t Surface::lock(
 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
{
 ANativeWindowBuffer* out;
 int fenceFd = -1;
 //1. 獲取實際Buffer
 status_t err = dequeueBuffer(&out, &fenceFd);
 //2. 處理雙緩衝
 if (canCopyBack) {
 // copy the area that is invalid and not repainted this round
 const Region copyback(mDirtyRegion.subtract(newDirtyRegion));
 if (!copyback.isEmpty())
 copyBlt(backBuffer, frontBuffer, copyback);
 }
}

Surface也提供了unlockAndPost方法，將數據給到BufferQueue：

status_t Surface::unlockAndPost()
{
 if (mLockedBuffer == 0) {
 ALOGE("Surface::unlockAndPost failed, no locked buffer");
 return INVALID_OPERATION;
 }
 int fd = -1;
 status_t err = mLockedBuffer->unlockAsync(&fd);
 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
 //1. 將生產好的數據給到BufferQueue
 err = queueBuffer(mLockedBuffer.get(), fd);
 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
 mLockedBuffer->handle, strerror(-err));
 mPostedBuffer = mLockedBuffer;
 mLockedBuffer = 0;
 return err;
}

3.2 SurfaceTexture

SurfaceTexture作爲BufferQueue的消費者，其初始化代碼如下：

static void SurfaceTexture_init(JNIEnv* env, jobject thiz, jboolean isDetached,
 jint texName, jboolean singleBufferMode, jobject weakThiz)
{
 sp<IGraphicBufferProducer> producer;
 sp<IGraphicBufferConsumer> consumer;
 //1. 創建一個BufferQueue
 BufferQueue::createBufferQueue(&producer, &consumer);
 if (singleBufferMode) {
 consumer->disableAsyncBuffer();
 consumer->setDefaultMaxBufferCount(1);
 }
 //2. 創建一個消費者實例surfaceTexture
 sp<GLConsumer> surfaceTexture;
 if (isDetached) {
 surfaceTexture = new GLConsumer(consumer, GL_TEXTURE_EXTERNAL_OES,
 true, true);
 } else {
 surfaceTexture = new GLConsumer(consumer, texName,
 GL_TEXTURE_EXTERNAL_OES, true, true);
 }
 //3. 將消費者實例和該BufferQueue對應的生產者保存到java層，這樣Surface構造時，就可以獲取到該BufferQueue對應的生產者了
 SurfaceTexture_setSurfaceTexture(env, thiz, surfaceTexture);
 SurfaceTexture_setProducer(env, thiz, producer);
}

消費的方法是updateTexImage，流程如下：

static void SurfaceTexture_updateTexImage(JNIEnv* env, jobject thiz)
{
 // 1. 先獲取到初始化時構造的消費者
 sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
 // 2. 調用消費者的updateTexImage方法
 status_t err = surfaceTexture->updateTexImage方法();
 if (err == INVALID_OPERATION) {
 jniThrowException(env, IllegalStateException, "Unable to update texture contents (see "
 "logcat for details)");
 } else if (err < 0) {
 jniThrowRuntimeException(env, "Error during updateTexImage (see logcat for details)");
 }
}

GLConsumer的updateTextImage實現如下：

status_t GLConsumer::updateTexImage() {
 BufferItem item;
 //1. 調用自身的acquireBufferLocked方法
 err = acquireBufferLocked(&item, 0);:updateTexImage() {
 // Release the previous buffer.
 err = updateAndReleaseLocked(item);
 if (err != NO_ERROR) {
 glBindTexture(mTexTarget, mTexName);
 return err;
 }
}

acquireBufferLocked方法，最終走到了ConsumerBase的acquireBufferLocked方法。

status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
 nsecs_t presentWhen, uint64_t maxFrameNumber) {
 //1. 最終還是走到了消費者的acquireBuffer方法，消費者對應上面的BufferQueueConsumer
 status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
 if (err != NO_ERROR) {
 return err;
 }
 return OK;
}

同理，消費者消費數據的方法是releaseTexImage，最終也會走到BufferQueueConsumer的releaseBufferLocked方法，這裏不再描述了。

4.BufferQueue的實例

上述介紹了BufferQueue的內部實現，以及常用的封裝類。接下來將介紹一個具體的實例。

Android中，SurfaceView作爲系統提供的組件，因爲可以在子線程中繪製提高性能，SurfaceView擁有自身的Surface，不需要和Activity的Surface共享，在SurfaceFlinger中，Activity的Surface和SurfaceView的Surface是平級且互相獨立的，可以獨立的進行合成。那我們來看一下SurfaceView是怎麼使用BufferQueue的。

4.1 數據的生產過程

SurfaceView的Surface創建過程，這裏不關注，有興趣的可以參考 android SurfaceView繪製實現原理解析這篇文章，我們主要關注其中與BufferQueue相關的繪製和顯示步驟。

使用SuerfaceView繪製僞碼如下：

Canvas canvas = null;

try {

canvas = holder.lockCanvas(null);

//實際的draw

}catch (Exception e) {

// TODO: handle exception

e.printStackTrace();

}finally {

if(canvas != null) {

holder.unlockCanvasAndPost(canvas);

}

需要調用lockCanvas和unlockCanvasAndPost方法，這兩個方法的作用是什麼呢？

先看下lockCanvas，調用流程是：

SurfaceHolder.lockCanvas
SurfaceHolder.internalLockCanvas
Surface.lockCanvas
Surface.nativeLockCanvas

nativeLockCanvas實現如下：

static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
 jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
 ANativeWindow_Buffer outBuffer;
 //1. 通過Surface::lock方法，獲取一個合適的Buffer
 status_t err = surface->lock(&outBuffer, dirtyRectPtr);
 //2. 構造一個Bitmap，地址指向步驟1獲取的Buffer的地址，這樣在這個Bitmap上繪製的內容，直接繪製到了GraphicBuffer，如果GraphicBuffer的內存是SurfaceFlinger通過共享內存申請的，那麼SurfaceFlinger就能直接看到繪製的圖形數據
 SkImageInfo info = SkImageInfo::Make(outBuffer.width, outBuffer.height,
 convertPixelFormat(outBuffer.format),
 kPremul_SkAlphaType);
 SkBitmap bitmap;
 ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
 bitmap.setInfo(info, bpr);
 if (outBuffer.width > 0 && outBuffer.height > 0) {
 bitmap.setPixels(outBuffer.bits);
 } else {
 // be safe with an empty bitmap.
 bitmap.setPixels(NULL);
 }
 // 3. 將創建的Bitmap設置給Canvas，作爲畫布
 Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);
 nativeCanvas->setBitmap(bitmap);
}

從這裏可以看到，nativeLockCanvas的步驟主要如下：

通過調用Surface::lock方法（內部也是調用dequeueBuffer和requestBuffer方法），獲取到一個GraphicBuffer
將步驟1獲取的GraphicBuffer構造成一個Bitmap，設置給Canvas
應用通過這個Canvas就可以繪製圖形了

在繪製圖形完成後，調用unlockCanvasAndPost方法，調用流程是：

SurfaceHolder.unlockCanvasAndPost
Surface.unlockCanvasAndPost
Surface.nativeUnlockCanvasAndPost

nativeUnlockCanvasAndPost 的實現如下：

static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,

jlong nativeObject, jobject canvasObj) {

sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

if (!isSurfaceValid(surface)) {

return;

}

// detach the canvas from the surface

Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);

nativeCanvas->setBitmap(SkBitmap());

// 直接調用Surface的unlockAndPost方法，有上文可知unlockAndPost內部最終也會調用到qeueBuffer方法

status_t err = surface->unlockAndPost方法，有上文可知unlockAndPost內部最終也會調用到qeueBuffer方法();

if (err < 0) {

doThrowIAE(env);

}

從註釋可以看到，這個方法，最終會調用到Surface的unlockAndPost方法方法，而該方法內部最終也會調用到BufferQueueProducer的queueBuffer方法。即完成了數據的生產和入隊。

4.2 數據的消費過程

SurfaceView繪製的數據，傳遞過BufferQueue後，最終由SurfaceFlinger進行合成消費。SurfaceFlinger的消費由SurfaceFlingerConsumer實現，流程如下：

status_t SurfaceFlingerConsumer::updateTexImage(BufferRejecter* rejecter,
 const DispSync& dispSync, uint64_t maxFrameNumber)
{
 BufferItem item;
 // 1. 調用acquireBufferLocked獲取一個Slot
 err = acquireBufferLocked(&item, computeExpectedPresent(dispSync),
 maxFrameNumber);
 if (err != NO_ERROR) {
 return err;
 }
 //2. 消費完畢，釋放Slot
 err = updateAndReleaseLocked(item);
 if (err != NO_ERROR) {
 return err;
 }
}

acquireBufferLocked的實現如下：

status_t SurfaceFlingerConsumer::acquireBufferLocked(BufferItem* item,
 nsecs_t presentWhen, uint64_t maxFrameNumber) {
 //1. 調用 GLConsumer::acquireBufferLocked，最終會調用到BufferQueueConsumer的acquireBuffer方法
 status_t result = GLConsumer::acquireBufferLocked(item, presentWhen,
 maxFrameNumber);
 if (result == NO_ERROR) {
 mTransformToDisplayInverse = item->mTransformToDisplayInverse;
 mSurfaceDamage = item->mSurfaceDamage;
 }
 return result;
}

而updateAndReleaseLocked方法的流程如下：

status_t GLConsumer::updateAndReleaseLocked(const BufferItem& item)
{
 // Do whatever sync ops we need to do before releasing the old slot.
 err = syncForReleaseLocked(mEglDisplay);
 if (err != NO_ERROR) {
 //1. releaseBufferLocked釋放Slot，最終會調用到BufferQueueConsumer的releaseBuffer方法
 releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer,
 mEglDisplay, EGL_NO_SYNC_KHR);
 return err;
 }
}

5. 總結

本文對BufferQueue的內部實現做了介紹，結合入隊/出對說明了BufferQueue內部Slot的狀態扭轉過程，並介紹了常用的BufferQueue封裝類，最後介紹了一個基於BufferQueue的例子。

深入淺出Android BufferQueue

開源高性能結構化日誌模塊NanoLog

【簡寫Mybatis-02】註冊機的實現以及SqlSession處理

手繪二維碼

.NET藉助虛擬網卡實現一個簡單異地組網工具

騰訊iOA零信任安全——IT變革下的新一代企業網

決戰9小時，產品上線的危機時刻

巨人的魔法——騰訊打造會思考的數據中心

大牛書單 | 大數據存儲方向好書分享

騰訊雲TStack，帶着“數據中心”遊雲南

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結