上一篇说完App申请完vsync后要进行绘制，本来要说一下绘制的过程，但是感觉进度有点慢，主要研究sf，所以转换下学习思路。
一、BufferQueue基本概念：
BufferQueue的核心逻辑是生产者消费者逻辑又是GraphicBuffer管理者,在BufferQueue这个生产者消费者框架中， BufferQueuecore可以理解为数据缓冲区的管理者，代码逻辑在BufferQueue.cpp和BufferQueuecore.cpp中。它的消费者是BufferQueueConsumer，生产者是BufferQueueProducer。
先看一张比较权威的BufferQueue相关基本操作流程，
image
首先初始状态下，所有可用BufferSlot全是FREE状态，在mFreeSlots中管理。
- Producer 从 BufferQueue中dequeue一个FREE BufferSlot, Dequeue成功后，BufferSlot状态从FREE变为DEQUEUED；
- Producer端填充好BufferSlot数据后，queue到BufferQueue中，BufferSlot状态从DEQUEUED变为QUEUED，且调用消费者onFrameAvailable通知它有可消费的BufferSlot；
- Consumer从BufferQueue中acquire一个有数据的BufferSlot，BufferSlot状态从QUEUED变为ACQUIRED；
- Consumer 使用完BufferSlot后，BufferSlot状态从ACQUIRED变为FREE
总结一下BufferSlot的5种状态：FREE、DEQUEUED、QUEUED、ACQUIRED、SHARED。
从源码中看下buffer状态改变原理
/frameworks/native/include/gui/BufferSlot.h
A buffer can be in one of five states, represented as below:
| mShared | mDequeueCount | mQueueCount | mAcquireCount |
--------|---------|---------------|-------------|---------------|
FREE | false | 0 | 0 | 0 |
DEQUEUED| false | 1 | 0 | 0 |
QUEUED | false | 0 | 1 | 0 |
ACQUIRED| false | 0 | 0 | 1 |
SHARED | true | any | any | any |
举例一个mQueueCount变化
inline bool isQueued const {
return mQueueCount> 0;
}
inline void queue() {
if (mDequeueCount > 0) {
mDequeueCount--;
}
mQueueCount++;
}
queue()方法调用后，mQueueCount++，isQueued() 方法返回值当然就为true;
可以明显的看到 buffer的状态由引用计数来表示。
二、BufferQueue内部结构
/frameworks/native/libs/gui/BufferQueue.cpp
void BufferQueue::createBufferQueue(sp* outProducer,
sp* outConsumer,
bool consumerIsSurfaceFlinger) {
sp core(new BufferQueueCore());
sp producer(new BufferQueueProducer(core, consumerIsSurfaceFlinger));
sp consumer(new BufferQueueConsumer(core));
*outProducer = producer;
*outConsumer = consumer;
}
通过其createBufferQueue方法可以看到会创建
BufferQueueCore、BufferQueueProducer、BufferQueueConsumer。
BufferQueueCore 负责维护 BufferQueue 的基本数据结构，而 BufferQueueProducer 和 BufferQueueConsumer 则负责提供操作 BufferQueue 的基本接口。
三、BufferSlot和BufferItem详解
1、BufferSlot和GraphicBuffer关联
BufferQueueCore中管理着数据缓冲区，而数据的核心GraphicBuffer关联在BufferSlot中。
/frameworks/native/include/gui/BufferQueueCore.h
class BufferQueueCore : public virtual RefBase {
......
BufferQueueDefs::SlotsType mSlots;
} @1
/frameworks/native/libs/gui/include/gui/BufferQueueDefs.h
namespace BufferQueueDefs {
Typedef BufferSlot SlotsType[NUM_BUFFER_SLOTS];
} @2
/frameworks/native/libs/gui/include/gui/BufferSlot.h
struct BufferSlot {
sp mGraphicBuffer;
} @3
由@1知BufferQueueCore定义了BufferQueueDefs::SlotsType mSlots，
由@2知mSlots实际上是一个BufferSolt的数组。
由@3知 BufferSolt中定义了一个GraphicBuffer的強指针用于关联mGraphicBuffer。
这样BufferSlot 和 GraphicBuffer 就关联上了。
2、BuffetItem关联BufferSlot
BufferQueue框架中，消费者和生产者对缓冲区数据操作的单元核心就是一个BufferSlot，也就是取GraphicBuffer，放GraphicBuffer的操作其实是针对BufferSlot来完成的。
/frameworks/native/libs/gui/include/gui/BufferQueueCore.h
class BufferQueueCore : public virtual RefBase {
......
typedef Vector Fifo;
......
Fifo mQueue;
}
/frameworks/native/libs/gui/include/gui/BufferItem.h
class BufferItem:public Flattenable{
//mSlot is the slot idex of this buffer(default INVALID_BUFFER_SLOT)
Int mSlot;
}
- BufferSlot 的存和取是在BufferQueueCore中定义了Fifo mQueue,Fifo是向量集，里面存的是BufferItem，而 BufferItem中又定义了mSlot的索引值。这样就可以和BufferSlot关联上了，可以在dequeue,queue,acquire方法中看出其关系。
- 生产者从mQueue上获取BufferItem从而找到了对应的BufferSlot，并对它完成一系列的操作之后，放回到mQueue中供消费者使用，消费者也是从mQueue上获取BufferItem从而找到对应的BufferSlot来消费，消费完成之后放回mQueue。不过需要注意实际上不是真正的把BufferSlot取出放回mQueue，而是mSlots索引值的传递过程。
3、BufferSlot状态说明
image.png
说明：
mSlots BufferSlot结构体数组，数组长度为64
- mFreeSlots BufferSlot状态为FREE，且没有GraphicBuffer与之相绑定的slot集合
- mFreeBuffers BufferSlot状态为FREE，且有GraphicBuffer与之相绑定的slot集合
- mActiveBuffers BufferSlot状态不为FREE（即DEQUEUED、QUEUED、ACQUIRED、SHARED）的slot集合。既然状态不是FREE，那么该BufferSlot必然有一个GraphicBuffer与之相绑定
- mUnusedSlots 未参与使用的slot集合，由 mMaxBufferCount 决定
- mSlots = mFreeSlots + mFreeBuffers + mActiveBuffers + mUnusedSlots
四、BufferQueue生产者和消费者详解
我们知道 一个widow对应一个layer，一个layer对应一个生产者消费者模型。
BufferQueueConsumer 和 BufferQueueProducer 分别对应文件BufferQueueConsumer.cpp 和 BufferQueueProducer.cpp 和 BufferQueueCore.cpp 在同级目录都在/frameworks/native/libs/gui目录下。
1、两个类的继承关系和重要函数：
BuffeQueueProducer继承关系:
(BufferQueueProducer.h) BufferQueueProducer : public BnGraphicBufferProducer,private IBinder::DeathRecipient
(IGraphicBufferProducer.h)BnGraphicBufferProducer : public BnInterface
(IInterface.h)class BnInterface : public INTERFACE, public BBinder
可以看到BufferQueueProducer继承了BnGraphicBufferProducer而BnGraphicBufferProducer又继承了IGraphicBufferProducer和BnInterface ，来完成主要的BufferSlot的流转操作，也提供了远程代理接口，实现跨进程binder调用。
同时BufferQueueProducer还继承了DeathRecipient 用来处理Binder死亡通知。
BuffeQueueProducer关键方法:
- requestBuffer 获取对应BufferSlot的GraphicBuffer地址。
- setMaxDequeuedBufferCount 设置最大同时可以dequeue出来的的BufferSlot数量。
- dequeueBuffer 从FREE状态下的BufferSlots中队列中获取空闲的BufferSlot做生产使用，优先从mFreeBuffers中获取，如果没有则从mFreeSlots中获取。
- attachBuffer 绑定已经分配好的GraphicBuffer到FREE状态下的BufferSlot中，优先从- mFreeSlots中查找BufferSlot，如果没有则从mFreeBuffers中查找并绑定。
- queueBuffer 生产者把生产好的BufferSlot放到队列中供消费者使用。
- detachBuffer 把attachBuffer了GraphicBuffer的 Active状态下的BufferSlot的放到mFreeBuffers之后直接取消GraphicBuffer的绑定。
- detachNextBuffer 把需要释放的BufferSlot中的GraphicBuffer指针赋值到outBuffer输出之后，把BufferSlot的放到mFreeBuffers并解绑定GraphicBuffer。
- cancelBuffer 把BufferSlot放回到mfreeBuffers中，不会释放graphicbuffer。
- connect 生产者通过该接口把IProducerListener注册到BufferQueueCore中供消费者回调，同时建立了Binder死亡通知通路。
- disconnect断开BufferQueueProducer和BufferQueueCore之间建立的链接关系。
BufferQueueConsumer继承关系:
(BufferQueueConsumer.h) BufferQueueConsumer : public BnGraphicBufferConsumer
(IGraphicBufferConsumer.h)BnGraphicBufferConsumer : public SafeBnInterface
(SafeInterface.h)SafeBnInterface:public BnInterface
可以看到BufferQueueConsumer的实现结构和BufferQueueProducer很相似继承了BnGraphicBufferConsumer 而BnGraphicBufferConsumer又最终继承了IGraphicBufferConsumer和SafeBnInterface，来完成主要的BufferSlot的流转操作，也提供了远程代理接口，实现跨进程binder调用。
BufferQueueConsumer关键方法:
- acquireBuffer 获取QUEUE状态下的BufferSlot进行消费。
- releaseBuffer消费完成之后把BufferSlot放回mFreeBuffers队列中。
- attachBuffer 把消费者的GraphicBuffer绑定到BufferSlot上使用。
- detachBuffer把消费者的GraphicBuffer从BufferSlot上解绑。
- setMaxBufferCount 设置最大可用BufferSlot数量。
- setMaxAcquiredBufferCount 设置最大同时可以acquire的BufferSlot数量。
- connect 建立消费者和BufferQueueCore之间的链接，注册IConsumerListener回调。
- disconnect 销毁消费者和BufferQueue之间的链接。
2、BufferQueueConsumer关键流程分析
(1). acquirebuffer的流程
主要流程是首先判断acquireBuffers是否已经超过最大一次能够Acquire的数量，mQueue是否为空，然后从mQueue中获取迭代器的第一个元素赋值给outBuffer输出，同时把mBufferState状态改为Acquired 并从mQueue中移除
status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
nsecs_t expectedPresent, uint64_t maxFrameNumber) {
...
{
//判断AcquireBuffers是否已经超过最大一次能够Acquire的数量。
if (numAcquiredBuffers >= mCore->mMaxAcquiredBufferCount + 1) {
return INVALID_OPERATION;
}
//判断mQueue队列是否为空
if (mCore->mQueue.empty() && !sharedBufferAvailable) {
return NO_BUFFER_AVAILABLE;
}
//mCore->mQueue.begin()返回iterator,指向第一个元素赋值给front
BufferQueueCore::Fifo::iterator front(mCore->mQueue.begin());
if (sharedBufferAvailable && mCore->mQueue.empty()) {//共享buffer的处理逻辑
...
} else {//正常非共享模式下的逻辑
slot = front->mSlot; //从front获取对应的slot，front是一个BufferItem指针
*outBuffer = *front; //把front指向的BufferItem赋值给outBuffer,outBuffer就是要的buffer
}
if (!outBuffer->mIsStale) {
mSlots[slot].mAcquireCalled = true;
if (mCore->mQueue.empty()) {
mSlots[slot].mBufferState.acquireNotInQueue();
} else {
mSlots[slot].mBufferState.acquire(); //把BufferState修改成acquired状态
}
}
mCore->mQueue.erase(front); //把acquired slot 对应的BufferItem从mQueue中移除。
mCore->mDequeueCondition.notify_all();
}
return NO_ERROR;
}
(2). releasebuffer的流程
releasebuffer主要流程是先做slot frameNumber 以及 BufferState有效性检查，修改mBufferState状态成FREE状态。然后把对应的slot从mActiveBuffers中移除并放回mFreeBuffers的过程。
这个过程中不做GraphicBuffer和BufferSlot的解绑定操作，也就是说GraphicBuffer不会被释放。
status_t BufferQueueConsumer::releaseBuffer(int slot, uint64_t frameNumber,
const sp& releaseFence, EGLDisplay eglDisplay,
EGLSyncKHR eglFence) {
//slot的合法性判断。
if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS ||
releaseFence == nullptr) {
BQ_LOGE("releaseBuffer: slot %d out of range or fence %p NULL", slot,
releaseFence.get());
return BAD_VALUE;
}
sp listener;
{
//判断frameNumber是否有效，如果做过reallocated frameNumber将会改变。
//这个frameNumber是什么？
if (frameNumber != mSlots[slot].mFrameNumber &&
!mSlots[slot].mBufferState.isShared()) {
return STALE_BUFFER_SLOT;
}
//判断BufferState是否是acquired状态
if (!mSlots[slot].mBufferState.isAcquired()) {
return BAD_VALUE;
}
mSlots[slot].mBufferState.release(); //调用mBufferState.release()将acqiure状态释放。
if (!mSlots[slot].mBufferState.isShared()) {
mCore->mActiveBuffers.erase(slot); //将slot从mActiveBuffers中移除
mCore->mFreeBuffers.push_back(slot); //将slot放入到mFreeBuffers队列中
}
listener = mCore->mConnectedProducerListener; //获取ProducerListener
mCore->mDequeueCondition.notify_all();
}
if (listener != nullptr) {
listener->onBufferReleased(); //调用Producer的onBufferReleased回调通知Producer完成释放。
}
return NO_ERROR;
}
3、BufferQueueProducer关键流程分析
(1). dequeuebuffer的流程
dequeuebuffer是生产者端从BufferQueueCore上获取一个GraphicBuffer进行生产的过程，生产者BufferQueueProducer 会在去获取一个FREE状态的的BufferSlot。
同时把mBufferState状态修改成Dequeue状态，把BufferSlot放到mActiveBuffers中管理。也由此可见GraphicBuffer是在这里实际创建的。
status_t BufferQueueProducer::dequeueBuffer(int* outSlot, sp* outFence,
uint32_t width, uint32_t height, PixelFormat format,
uint64_t usage, uint64_t* outBufferAge,
FrameEventHistoryDelta* outTimestamps) {
int found = BufferItem::INVALID_BUFFER_SLOT;
//调用waitForFreeSlotThenRelock 找到可以dequeue的 FREE状态下的BufferSlot
while (found == BufferItem::INVALID_BUFFER_SLOT) {
status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Dequeue, lock, &found);
}
const sp& buffer(mSlots[found].mGraphicBuffer); //把获取到的mGraphicBuffer地址赋值给buffer。
if (mCore->mSharedBufferSlot != found) {
mCore->mActiveBuffers.insert(found); //把找到的slot放到mActiveBuffers中管理
}
*outSlot = found; //赋值给outSlot输出
mSlots[found].mBufferState.dequeue(); //修改BufferState 状态成dequeue状态。
}
return returnFlags;
}
FREE状态的BufferSlot又包含了mFreeSlots和mFreebuffers两组slots，dequeue的时候会先从mFreebuffers查找如果有可用的就使用，如果没有就从mFreeSlots获取BufferSlot并分配GraphicBuffer。
这个过程在waitForFreeSlotThenRelock中实现
下面是waitForFreeSlotThenRelock的流程：
status_t BufferQueueProducer::waitForFreeSlotThenRelock(FreeSlotCaller caller,
std::unique_lock& lock, int* found) const {
auto callerString = (caller == FreeSlotCaller::Dequeue) ?
"dequeueBuffer" : "attachBuffer";
bool tryAgain = true;
while (tryAgain) {
if (){
} else {
if (caller == FreeSlotCaller::Dequeue) { //Dequeuebuffer调用这段代码，先调用getFreeBufferLocked从mFreeBuffers中获取，如果找到了就返回。
// If we're calling this from dequeue, prefer free buffers
int slot = getFreeBufferLocked();
if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) {
*found = slot;
} else if (mCore->mAllowAllocation) { // 如果没找到，在调用getFreeSlotLocked从mFreeSlots中获取。
*found = getFreeSlotLocked();
}
} else {
// If we're calling this from attach, prefer free slots
int slot = getFreeSlotLocked(); //attachbuffer调用这段代码，优先先调用getFreeSlotLocked从mFreeSlots中获取，如果找到了就返回。
if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) {
*found = slot;
} else {
*found = getFreeBufferLocked(); 如果没找到，在调用getFreeBufferLocked从mFreeBuffers中获取。
}
}
}
}
}
return NO_ERROR;
}
int BufferQueueProducer::getFreeSlotLocked() const {
if (mCore->mFreeSlots.empty()) {
return BufferQueueCore::INVALID_BUFFER_SLOT;
}
int slot = *(mCore->mFreeSlots.begin());
mCore->mFreeSlots.erase(slot);
return slot;
}
(2). attachbuffer的流程
如上面的waitForFreeSlotThenRelock流程，attachBuffer也是从FREE状态的slots上获取BufferSlot，但是和dequeueBuffer不同attachBuffer是优先从mfreeslots上获取，如果mfreeslots没有，再从mfreebuffers上获取。
waitForFreeSlotThenRelock获取到BufferSlot之后，再把已有的申请好的GraphicBuffer绑定到这个BufferSlot上。同时把mBufferState状态修改成Dequeued状态。把BufferSlot放到mActiveBuffers中管理。
status_t BufferQueueProducer::attachBuffer(int* outSlot,
const sp& buffer) {
//调用waitForFreeSlotThenRelock 找到可以FREE状态下的BufferSlot
status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Attach, lock, &found);
*outSlot = found; //把找到的slot赋值给outSlot
mSlots[*outSlot].mGraphicBuffer = buffer; //把准备好的buffer关联到slot的mGraphicBuffer上
mSlots[*outSlot].mBufferState.attachProducer(); // 修改BufferState成Dequued状态
mCore->mActiveBuffers.insert(found); // 把slot放到mActiveBuffers中管理。
return returnFlags;
}
(3). queuebuffer的流程
queuebuffer是生产者完成对GraphicBuffer的处理之后调用queuebuffer把GraphicBuffer放回mQueue的操作，同时把mBufferState修改成QUEUE状态。
status_t BufferQueueProducer::queueBuffer(int slot,
const QueueBufferInput &input, QueueBufferOutput *output) {
sp frameAvailableListener;
sp frameReplacedListener;
BufferItem item;
{ // Autolock scope
mSlots[slot].mBufferState.queue(); //修改mBufferState状态为QUEUE状态。
//增加mFrameCounter
++mCore->mFrameCounter;
currentFrameNumber = mCore->mFrameCounter;
mSlots[slot].mFrameNumber = currentFrameNumber;
//给BufferItem赋值
item.mGraphicBuffer = mSlots[slot].mGraphicBuffer;
item.mSlot = slot;
output->bufferReplaced = false;
if (mCore->mQueue.empty()) { //如果mQueue为空，就直接把BufferItem push到mQueue尾部。
mCore->mQueue.push_back(item);
frameAvailableListener = mCore->mConsumerListener;
} else { //如mQueue不为空，需要判断一下last BufferItem是否被替换，如果可以替换就替换，如果不可以替换就直接把BufferItem放到mQueue尾部。
const BufferItem& last = mCore->mQueue.itemAt(
mCore->mQueue.size() - 1);
if (last.mIsDroppable) {
if (!last.mIsStale) {
mSlots[last.mSlot].mBufferState.freeQueued();
// Don't put the shared buffer on the free list.
if (!mSlots[last.mSlot].mBufferState.isShared()) {
mCore->mActiveBuffers.erase(last.mSlot);
mCore->mFreeBuffers.push_back(last.mSlot);
output->bufferReplaced = true;
}
}
mCore->mQueue.editItemAt(mCore->mQueue.size() - 1) = item;
frameReplacedListener = mCore->mConsumerListener;
} else {
mCore->mQueue.push_back(item);
frameAvailableListener = mCore->mConsumerListener;
}
}
if (frameAvailableListener != nullptr) {
frameAvailableListener->onFrameAvailable(item); //调用消费者的onFrameAvailable通知消费者，有queue状态的BufferSlot可以使用。
} else if (frameReplacedListener != nullptr) {
frameReplacedListener->onFrameReplaced(item); //调用消费者的onFrameReplaced通知消费者，有queue状态的BufferSlot可以被替换。
}
} // Autolock scope
return NO_ERROR;
}
(4). detachBuffer的流程
detachBuffer主要是对应生产者端的attachbuffer操作，将attachbuffer之后的BufferSlot，放回到mFreeSlots中，并解除对GraphicBuffer的绑定，并通知消费者Buffer释放。
status_t BufferQueueProducer::detachBuffer(int slot) {
sp listener;
mSlots[slot].mBufferState.detachProducer(); //修改BufferState的Dequeued状态成FREE状态
mCore->mActiveBuffers.erase(slot); //把slot从mActiveBuffers中移除
mCore->mFreeSlots.insert(slot); //把slot加到mFreeSlots中。
mCore->clearBufferSlotLocked(slot); //清除slot和Graphicbuffer的绑定关系。
mCore->mDequeueCondition.notify_all();
listener = mCore->mConsumerListener; //把消费者回调的listener赋值给listener
}
if (listener != nullptr) {
listener->onBuffersReleased();//调用消费者的listener接口通知消费者Buffer释放
}
return NO_ERROR;
}
五、总结
BufferQueue的生产消费和BufferSlot状态关系用一张图总结下：
image.png