深入浅出Android BufferQueue

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

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：一个先进先出队列，保存了生产者生产的数据

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

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;
 }
}

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，即完成了状态的扭转。

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;
}

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的主要步骤如下：

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();
 }
 }
}

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();
 }
}

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();
}

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);
 }
}

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);
 }
}

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;
}

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);
}

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)");
 }
}

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;
 }
}

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;
}

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);
}

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;
 }
}

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;
}

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;
 }
}