Android Camera : 从 Framework 到 HAL，Kernel 的 buf 管理探究

本文来自作者 海角之南 在 GitChat 上分享 「Android Camera : 从 Framework 到 HAL，Kernel 的 buf 管理探究」，「阅读原文」查看交流实录。

「文末高能」

编辑 | 哈比

Android Camera Buf liVe

Phone Camera 的功能可谓日新月异且富有趣味，除了硬件功能强大，软件逻辑也很重要，Buf 管理是软件逻辑里非常重要的一环，弄懂它的来龙去脉有助于我们掌握一个系统、掌握一个思路以及学会一种框架，甚至领悟到优化着力点。

Android 是 Phone 上的流行系统，具有时新性、开源性以及趣味性，我们选择 Android 作为研究对象。

通过本篇文章的学习，我们可以掌握 Camera 架构下 Buf 的生命周期，伴随 App 的 Request 产生，从 FrameWork 传到 hal，从 hal 传到 kernel 空间，然后填充数据后经 kernel 到 hal 再到 FrameWork 的一个生命周期。

我们可以学到：

• FrameWork 下是谁对 buf 做管理？管理 buffer 的数据都有什么，这些数据结构更新的逻辑是什么？

• FrameWork 是如何和 hal 层对 buf 交互的？

• 简述 kernel 下 buf 的交互。

一、 FrameWork 的 buf 管理者

FW 层 buf 依靠 Camera3BufferManager 管理，它有什么关键函数呢？

Camera3BufferManager

可以 alloc gralloc buffer，在 client 端申请时它可以把 buffer 交给 (hands out) client(e.g.,Camera3OutputStream)    Camera3BufferManager 有若干自己管理的 buf，在 client 申请时，优先分配这些 buf 给 client，当 buf 不足时，需要重新 alloc，在 buffer 过多时，需要 de-alloc。

registerStream

提供 stream info 给 Camera3BufferManager.c3bm 会负责该 stream 的 buffer 分配。

stream 首先要处于 CONFIGUED 状态，然后再注册到 c3bm 中。

c3bm 会通过 getBufferForStream() 函数给 stream 提供 buffer。

提供的 buffer 可以传到 hal 层用于 image output，当 hal 层有输出数据时，这个 buffer 可以 queue 到 ANativeWindow (Surface) 中，等地下游 consumer 使用。

当下游 consumer 使用完并 release 后，BufferQueueProducer 的 callback 函数 onBufferReleased 会 returnBufferForStream() 函数把这个 buffer 返还给 Camera3BufferManager。

unregisterStream

注销，注销后的 buf 供 Camera3BufferManager 管理。

getBufferForStream

Camera3BuffferManager 从 free buf list 中找到第一个 free 的 buffer，分配给 stream，如果无自己管理的 buf，就 alloc 一个 buffer 给 stream。

onBufferReleased

意味着 consumer 已经使用完该 buffer，但是它并不是直接返回给 Camera3BufferManager，而是说这个 buffer 可以从    stream 上 dequeue 了，表示这么个状态。由于这个函数存在 Camera3BufferManager 就知道一个 stream 中有多少个可用的 buffer 了。

returnBufferForStream

stream 向 Camera3BufferManager 返回一个 buffer。

我们重点关注 registerStream,getBufferForStream、onBufferReleased 函数。

1.1 registerStream

Camera3BufferManager 内部含有一组 Map，它们的关系如下：

StreamSetMap 是一组 StreamSet 合集，StreamSet 下含有一组 Map、streamInfoMap、handoutBufferCountMap 以及 attachedBufferCountMap。

• 第一，handout buffer Map 是给 client 使用的 buffer 的集合。

• 第二，freeBuffers 是属于特定某个 buffer set 的所有 buffer 的合集，由 returnBufferForStream 返回，待使用的 buffer。

• 第三，attached buffer 可以是 handout 的，也可以是 free 的，它实际上是这两种的合集。

图 1- Camera3BufferManager

registerStream 就是为这个 streamInfo 建立一组 StreamSet。

• StreamSet 内部的 Map 也建立起来，并初始化为 (key=streamId,val=0)。

• 最后把 StreamSet 以 key 是 streamSetId 加到 mStreamSetMap 中。

• 把 stream 以 key 为 streamId 加到 mStreamMap 中。

下面这段代码描述了这个逻辑：

status_t Camera3BufferManager::registerStream(wp<Camera3OutputStream>& stream,        const StreamInfo& streamInfo) {
    ATRACE_CALL();    int streamId = streamInfo.streamId;    int streamSetId = streamInfo.streamSetId; 
    /* 分别拿到 sTream 的 id 以及 setId. 一个 set 含有三个 Map, 描述 streamid 的 streamInfoMap, 给 stream 的 buf 个数 handoutBufferCountMap,stream attached 的 attachedBufferCountMap.*/

    Mutex::Autolock l(mLock);// 这是个利用构造析构的 mutex 锁 . 包了 pthread_mutext.
    // 先尝试 , 一组 StreamSetMap 的 StreamMap 中找是否有 streamid 的 stream. 一个 streamSetMap 含有多个 StreamSet. 一个 StreamSet 含有多个 Stream.
     for (size_t i = 0; i < mStreamSetMap.size(); i++) {
        ssize_t streamIdx = mStreamSetMap[i].streamInfoMap.indexOfKey(streamId);
    }    // 根据 StreamSetId 在 streamSetMap 中找是否已经注册过了 . 如果找不到 , 我们需要 new 出一个 StreamSet.
    // 并把这个新的 StreamSet 和 StreamSetId 关联到 mStreamSetMap 中 .
    ssize_t setIdx = mStreamSetMap.indexOfKey(streamSetId);    if (setIdx == NAME_NOT_FOUND) {/* 没找到 , 怎么办 ?new 出一个 */
        StreamSet newStreamSet;
        setIdx = mStreamSetMap.add(streamSetId, newStreamSet);
    }    // 拿到刚才新的 StreamSet, 并取出其 streamid. 这里需要对 StreamSet 的 handout ,attached 的 Map 清零 .
    StreamSet& currentStreamSet = mStreamSetMap.editValueAt(setIdx);//currentStreamSet 是个友元ssize_t streamIdx = currentStreamSet.streamInfoMap.indexOfKey(streamId);

currentStreamSet.streamInfoMap.add(streamId, streamInfo);
    currentStreamSet.handoutBufferCountMap.add(streamId, 0);
    currentStreamSet.attachedBufferCountMap.add(streamId, 0);
    mStreamMap.add(streamId, stream);   return OK;
}

• registerStream 的调用时机是什么 ?

根据 buf 的尺寸以及 buf 有何用途，针对性的生成一个 StreamInfo 结构，此时会利用 registerStream 注册进 mStreamSetMap 中。

下面这段代码体现了 registerStream 是如何使用的。

status_t Camera3OutputStream::configureQueueLocked() {// 虽然没有传参 , 但是内部基本上是调用成员变量的函数
    // 配置 consumer 侧的 ANativeWidow 接口 .consumer 一般是 Surface 类 . 此时还要把一个 listener 注册进 consumer. 以便 consumer 在 release 时候可以及时通知 Camera3BufferManager 做一些 release 的 buf 管理 .
    res = mConsumer->connect(NATIVE_WINDOW_API_CAMERA, /*listener*/mBufferReleasedListener);

    if (mBufferManager != 0 && mSetId > CAMERA3_STREAM_SET_ID_INVALID) {
        uint32_t consumerUsage = 0;
        getEndpointUsage(&consumerUsage);
        // 先生成描述这个 stream 的 streaminfo
        // stream info 依赖 , 这个 stream 描述的 buf 的宽 , 高 , 格式 (yuv 与否), 数据空间 . 以及这块 buf 的用途 .android 系统把待显示的区域用不同的属性描述 .
        StreamInfo streamInfo(getId(), getStreamSetId(), getWidth(), getHeight(), getFormat(), getDataSpace(),camera3_stream::usage | consumerUsage, mTotalBufferCount,                /*isConfigured*/true);
        wp<Camera3OutputStream> weakThis(this);
        // 把 streaminfo 注册进去 , 这里的 this 就是 Camera3OutputStream 类本身 .
        res = mBufferManager->registerStream(weakThis,
                streamInfo);
        if (res == OK) {
            // 此时先进值 GraphicBuffer 的产生 . 因为对于创建多大的 GraphicBuffer 是由 Camera3BufferManager 负责的 .
            mConsumer->getIGraphicBufferProducer()->allowAllocation(false);
            mUseBufferManager = true;
        }
    }
}

1.2 Camera3BufferManager::unregisterStream

显而易见，上如 Register 的逆操作，就是图 1 中 StreamSet 的数据结构的解构。

status_t Camera3BufferManager::unregisterStream(int streamId, int streamSetId) {
    Mutex::Autolock l(mLock);
    // 删掉 Stream 关联的所有 Buffer.
    StreamSet& currentSet = mStreamSetMap.editValueFor(streamSetId);
    BufferList& freeBufs = currentSet.freeBuffers;// 取出 StreamSet 的 freeBuffers 链表 .
    BufferCountMap& handOutBufferCounts = currentSet.handoutBufferCountMap;
    BufferCountMap& attachedBufferCounts = currentSet.attachedBufferCountMap;// 从 Set 中取出 handout,attached 的计数 Map
    InfoMap& infoMap = currentSet.streamInfoMap;
    removeBuffersFromBufferListLocked(freeBufs, streamId);// 这里是删掉 buf 的地方 .
    handOutBufferCounts.removeItem(streamId); // 删掉对应的 id
    attachedBufferCounts.removeItem(streamId);

    infoMap.removeItem(streamId); // 删掉 streamid 的 infoMap
    currentSet.maxAllowedBufferCount = 0;
    for (size_t i = 0; i < infoMap.size(); i++) {
        if (infoMap[i].totalBufferCount > currentSet.maxAllowedBufferCount) {
            currentSet.maxAllowedBufferCount = infoMap[i].totalBufferCount;
        }
    }
    mStreamMap.removeItem(streamId); // 删除 streamId 的 mStreamMap
    return OK;
}

• Camera3BufferManager::unregisterStream 的调用时机

status_t Camera3OutputStream::disconnectLocked() {
    status_t res;

   //  和 native window disconnect
    res = native_window_api_disconnect(mConsumer.get(),                                      NATIVE_WINDOW_API_CAMERA);
    // 此时 ,Camera 设备是 Idle 的 , 不会再有想 Camera3BufferManager 的 Get Buffer 的请求 . 此时注销掉这个 StreamSet 是安全的 .
    if (mUseBufferManager) {
        res = mBufferManager->unregisterStream(getId(), getStreamSetId());
        mUseBufferManager = false;
    }
    return OK;
}

1.3 Camera3BufferManager::getBufferForStream

这个 Camera3BufferManager 的核心函数 是 Client 的 buf 的获取。

• 需要理解图 1 中几个数据结构的深层含义：

• • 一个 StreamSetMap 含有多个 StreamSet，根据 StreamSetId 来区分。

  • 一个 StreamSet 含有一个 handoutBufferCountMap，一个 attachedBufferCountMap，一个 freeBuffers，一个 handoutBufferCountMap 含有多个 count， 以 Stream 区分， attchedBufferCountMap 同理。

理清楚这些，下面的 get buffer 函数就明白了。

• 首先，我们有 streamId，根据这个 StreamId 从 StreamSetMap 中拿到 StreamSet，一个 StreamSet 含有一个StreamInfoMap、一个HandoutCountBufferMap、一个attachedCountBufferMap。

• handoutCountBufferMap 记录有几个 buffer 分配给 stream 了。AttachedCountBufferMap，记录了 stream 中含有多少个 attached 状态的 buf。这个所谓的 attached buf 是 client release 的个数和 handout 给 client buffer 的个数之和。

• 我们在一个 StreamSet 中轮询所有的 streamId，叠加其 attachedCount 得到一个 StreamSet 的 buffer 总和，记为 count3，如果 count3 大于 MAX WATERMARK，意味着此时需要 free 掉一些 buffer。

  由于 StreamSet 是一组 streamid 的 count 的总和，我们只需要找到一个第三方（另一个 streamid）的 streamid，其满足其count2(attached ones)>count1(handout ones)，这种说明含有 client release 的 buffers。

  如下公式描述，如果 attached 个数大于 handout 的个数，说明有 free 状态 client release 的 buf。

  
  

• 注意区别 client release 的 buf 和处于 freeBuffers 中的 buffer。 相同点是它们都是 free 的。

不同点是 client release 的 buf 说明 client 处理完了，但尚在Camera3BufferManager的管理范围内（也就是说尚在 attached buffer count 记录内）。

而 freeBuffers 处于 StreamSet 的，不是某个 stream 的，而是属于一组 stream 组成的 streamSet 的。

• 如果没有超过 watermark 的情况。直接从 freebuffers 取出描述目标 streamid 的 buf 的一个 bufferEntry 结构。如果这个 bufferEntry 描述的 graphicBuffer 尚未分配到，需要经createGraphicBuffer 创建一个GraphicBuffer，而要创建一个 buf，就需要 buffer 的期望尺寸、以及其 bpp 格式、还有其用途等等。

图 2- Camera3BufferManager’s StreamSet summary

status_t Camera3BufferManager::getBufferForStream(int streamId, int streamSetId,
        sp<GraphicBuffer>* gb, int* fenceFd) {
    Mutex::Autolock l(mLock);

    StreamSet &streamSet = mStreamSetMap.editValueFor(streamSetId);// 从 set 中拿到 handout ,attached buffer, 他们是友元 .
    BufferCountMap& handOutBufferCounts = streamSet.handoutBufferCountMap;
    size_t& bufferCount = handOutBufferCounts.editValueFor(streamId);

    BufferCountMap& attachedBufferCounts = streamSet.attachedBufferCountMap;
    size_t& attachedBufferCount = attachedBufferCounts.editValueFor(streamId);    if (attachedBufferCount > bufferCount/* handout buffer count*/) {    // 如果 buf attached 的个数超过了 handout 出去的个数 , 说明 Stream 本身有一些被 consumer release 的可用 buffer, 直接在此使用它们就好了 .
        bufferCount++;        return ALREADY_EXISTS;
    }

    GraphicBufferEntry buffer =
            getFirstBufferFromBufferListLocked(streamSet.freeBuffers, streamId);    if (mGrallocVersion < HARDWARE_DEVICE_API_VERSION(1,0)) {        // Allocate one if there is no free buffer available.
        if (buffer.graphicBuffer == nullptr) {// 如果 Camera3BufferManager 本身没有管理的 freebuffer. 重新 alloc
            const StreamInfo& info = streamSet.streamInfoMap.valueFor(streamId);
            buffer.fenceFd = -1;            // graphicbuffer 的分配 , 需要尺寸 .
            buffer.graphicBuffer = mAllocator->createGraphicBuffer(
                    info.width, info.height, info.format, info.combinedUsage, &res);

        }


        bufferCount++; // 它们都是友元 , 此处递增也会同步到对应的 Map 中 , 此处是递增 handout
        attachedBufferCount++;

        *gb = buffer.graphicBuffer;
        *fenceFd = buffer.fenceFd;// 用于和 hal 层的同步 . 拿到 fence 的那一方才可以对 buf 读写

        // 如果这个 StreamSet 的 free 状态的 buf 大于 watermark, 说明这 StreamSet 中有过多空闲的 buf, 需要回收 .

        if (streamSet.streamInfoMap.size() > 1) { // 还有多个 stream
            bool freeBufferIsAttached = false;            for (size_t i = 0; i < streamSet.streamInfoMap.size(); i++) {
                firstOtherStreamId = streamSet.streamInfoMap[i].streamId;                if (firstOtherStreamId != streamId) { 
                // 找到同个 streamSet 里的其他的 stream, 看它的 attached 状态的 buf 是不是比 handout 的 buffer 多 . 多意味着 stream 上被 attached 的 buf 有一部分是空闲的 .

                    size_t otherBufferCount  =
                            streamSet.handoutBufferCountMap.valueFor(firstOtherStreamId);
                    size_t otherAttachedBufferCount =
                            streamSet.attachedBufferCountMap.valueFor(firstOtherStreamId);                    if (otherAttachedBufferCount > otherBufferCount) {
                        freeBufferIsAttached = true; // 找到了 ,attached 比 handout 的个数多的 StreamId, 说明有多个空闲的 buf.
                        break; // 找到一个 Stream 就可以了 , 我们不需要释放太多 , 找到一个释放一个就能满足目前需求 . 因为我们本来也是只是申请一个 buf 的 , 所以释放一个 , 再申请一个应该不会差太多 . 这里先不考虑尺寸等信息 .
                    }                    if (hasBufferForStreamLocked(streamSet.freeBuffers, firstOtherStreamId)) {
                        freeBufferIsAttached = false;                        break;
                    }
                }
                firstOtherStreamId = CAMERA3_STREAM_ID_INVALID;
            }            if (firstOtherStreamId == CAMERA3_STREAM_ID_INVALID) {                return OK;
            }


            size_t totalAllocatedBufferCount = streamSet.freeBuffers.size();            for (size_t I = 0; I < streamSet.attachedBufferCountMap.size(); i++) {// 每个 streamSet 含有 free 的 buffer 以及 attached 状态的 buffer. 他们的和是 Camera3BufferManage 分配给 streamSet 的所有 buffer 的个数和
                totalAllocatedBufferCount += streamSet.attachedBufferCountMap[i];
            }            if (totalAllocatedBufferCount > streamSet.allocatedBufferWaterMark) {// 大于 watermark 就 de-alloc 一部分 .
                if (freeBufferIsAttached) {
                    ALOGV("Stream %d: Freeing buffer: detach", firstOtherStreamId);
                    sp<Camera3OutputStream> stream =
                            mStreamMap.valueFor(firstOtherStreamId).promote();//de-alloc 的是” 其他” 的 stream 的 buffer, 也因为是他们的 attachedbuf 超过了 handout 的 buf.

                    // Detach and then drop the buffer.
                    {
                        mLock.unlock();
                        sp<GraphicBuffer> buffer;
                        stream->detachBuffer(&buffer, /*fenceFd*/ nullptr);
                        mLock.lock();
                    }
                    size_t& otherAttachedBufferCount =
                            streamSet.attachedBufferCountMap.editValueFor(firstOtherStreamId);
                    otherAttachedBufferCount--;
                } else {                    // Droppable buffer is in the free buffer list, grab and drop
                    getFirstBufferFromBufferListLocked(streamSet.freeBuffers, firstOtherStreamId);
                }
            }
        }
    } else {        // TODO: implement this.
        return BAD_VALUE;
    }    return OK;
}

• getFreeBufferForStream 的用法。

下面的代码会逐渐解释mConsumer对象的 attached buffer 的逻辑实现。

status_t Camera3OutputStream::getBufferLocked(camera3_stream_buffer *buffer) {
    if ((res = getBufferPreconditionCheckLocked()) != OK) {
        return res;
    }

    ANativeWindowBuffer* anb;
    int fenceFd = -1;
    bool gotBufferFromManager = false;

    if (mUseBufferManager) {
        sp<GraphicBuffer> gb;
        // 使用 Camera3BufferManager 管理 buffer. 并从中拿到 GraphicBuffer. 这里作为 gb.
        res = mBufferManager->getBufferForStream(getId(), getStreamSetId(), &gb, &fenceFd);
        if (res == OK) {
            // 把 gb 转成 ANativeWindowBuffer. 并添加到 consumer 的 activeBuffer 中 .
            anb = gb.get();
            res = mConsumer->attachBuffer(anb);

            gotBufferFromManager = true; // 表明从 Camera3BufferManager 获得来的 buf

        } else if (res == ALREADY_EXISTS) {
        // 如果这个 buf 是本身 stream release 下的 , 此时并没有重新 create buf. 说明这个 buf 不是由 Camera3BufferManager 管理的 .
            gotBufferFromManager = false;
        } else if (res != OK) {
            return res;// error
        }
    }
    if (!gotBufferFromManager) {
        /**
         * 我们先 unlock 锁 , 因为会有如下的死锁场景:
         * Thread 1: StreamingProcessor::startStream -> Camera3Stream::isConfiguring().
         * 线程 1 会请求 StreamingProcessor lock 并且锁住 Camera3Stream lock.
         * 
         * Thread 2: Camera3Stream::returnBuffer->StreamingProcessor::onFrameAvailable().
         * 线程 2 会请求 Camera3Stream lock 和 bufferQueue lock, 并锁住
         * StreamingProcessor lock.
         * 
         * Thread 3: Camera3Stream::getBuffer(). 
         * 线程 3 会请求 Camera3Stream lock 并锁住 bufferQueue lock.
         * 此时会有一个循环锁依赖 .
         */
        sp<ANativeWindow> currentConsumer = mConsumer;
        mLock.unlock();
        // 使用 consumer 自己的空闲 buffer
        res = currentConsumer->dequeueBuffer(currentConsumer.get(), &anb, &fenceFd);
        mLock.lock();
        return res;
        }
    }

    handoutBufferLocked(*buffer, &(anb->handle), /*acquireFence*/fenceFd,
                        /*releaseFence*/-1, CAMERA3_BUFFER_STATUS_OK, /*output*/true);

    return OK;
}

1.4  Camera3BufferManager::onBufferReleased

了解了这几个 Map 之间的关系，也不难理解如下逻辑。这里需要特别注意所有的操作都是用的友元方法，会直接更新到本体类。

status_t Camera3BufferManager::onBufferReleased(int streamId, int streamSetId) {
    Mutex::Autolock l(mLock);
    // Camera3BufferManager 会在收到这个回调时候，统计当前的 stream 的 handout 的 buffer count。此处也是释放。
        StreamSet& streamSet = mStreamSetMap.editValueFor(streamSetId);
        BufferCountMap& handOutBufferCounts = streamSet.handoutBufferCountMap;
        size_t& bufferCount = handOutBufferCounts.editValueFor(streamId);
        bufferCount--;
        /*  
         * 此处只是 handout 的 buffer count 减一 , 注意此处的 attachedbuffer count 并没有减一 .
         * 这就是这两者的不同 ,attached buffer count 包含”handout” 给 client 的 ,
         * 也包含 client release 回来的 .        
         * */
    return OK;
}

• 什么时候会调用onBufferReleased？

第一步，在configureQueueLocked中添加 release 时候的 listener。即mBufferReleasedListener描述的Camera3OutputStream::BufferReleasedListener类。

这个类含有onBufferReleaseed函数。

status_t Camera3OutputStream::configureQueueLocked() {
    res = mConsumer->connect(NATIVE_WINDOW_API_CAMERA, /*listener*/mBufferReleasedListener);// 注册一个 release 时候 consuemr 可以调用 Camera3OutputStream 的回调函数 .
}

•  listener 去哪儿了 ?

• • Connect 中有记录 listener 的部分

status_t BufferQueueProducer::connect(const sp<IProducerListener>& listener,
        int api/*4*/, bool producerControlledByApp, QueueBufferOutput *output) {

    Mutex::Autolock lock(mCore->mMutex);
    mConsumerName = mCore->mConsumerName;

    int delta = mCore->getMaxBufferCountLocked(mCore->mAsyncMode,
            mDequeueTimeout < 0 ?
            mCore->mConsumerControlledByApp && producerControlledByApp : false,
            mCore->mMaxBufferCount) -
            mCore->getMaxBufferCountLocked();
    switch (api) {
        case NATIVE_WINDOW_API_EGL:
        case NATIVE_WINDOW_API_CPU:
        case NATIVE_WINDOW_API_MEDIA:
        case NATIVE_WINDOW_API_CAMERA:
            mCore->mConnectedApi = api;
            output->inflate(mCore->mDefaultWidth, mCore->mDefaultHeight,
                    mCore->mTransformHint,
                    static_cast<uint32_t>(mCore->mQueue.size()),
                    mCore->mFrameCounter + 1);

            // Set up a death notification so that we can disconnect
            // automatically if the remote producer dies
            if (listener != NULL &&
                    IInterface::asBinder(listener)->remoteBinder() != NULL) {
                status = IInterface::asBinder(listener)->linkToDeath(
                        static_cast<IBinder::DeathRecipient*>(this));
            }
            // 把 Camera3OutputStream 类的 mBufferReleasedListener 结构的 listener 暂存起来
            mCore->mConnectedProducerListener = listener;
            break;
        default:

    }
    mCore->mConnectedPid = IPCThreadState::self()->getCallingPid();
    mCore->mBufferHasBeenQueued = false;
    mCore->mDequeueBufferCannotBlock = false;
}

• listener 我直到它被保存起来了，可是什么时候使用 listener？

• • 在 comsumer 使用完 buffer 需要 release 时，从mActiveBuffers中取出来一个 slot，放到mFreeBuffers中，并调用 listener 的onReleaseBuffer函数。

图 3 - BufferQueue’s Slots arch

status_t BufferQueueConsumer::releaseBuffer(int slot, uint64_t frameNumber,
        const sp<Fence>& releaseFence, EGLDisplay eglDisplay,
        EGLSyncKHR eglFence) {

    sp<IProducerListener> listener;
    { // Autolock scope
        Mutex::Autolock lock(mCore->mMutex);

        // 如果在 release 前时候，buf 又被重新 alloc 了，那忽略这次 release 行为。
        // 特别对于 shared 类型的 buf，高概率在 release 过程中出现的 queue 和 acquire 请求。这时候忽略这次的 release 行为。
        if (frameNumber != mSlots[slot].mFrameNumber &&
                !mSlots[slot].mBufferState.isShared()) {
            return STALE_BUFFER_SLOT;
        }

        mSlots[slot].mEglDisplay = eglDisplay;
        mSlots[slot].mEglFence = eglFence;
        mSlots[slot].mFence = releaseFence;
        mSlots[slot].mBufferState.release();

        // After leaving shared buffer mode, the shared buffer will
        // still be around. Mark it as no longer shared if this
        // operation causes it to be free.
        if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) {
            mSlots[slot].mBufferState.mShared = false;
        }
        // Don't put the shared buffer on the free list.
        if (!mSlots[slot].mBufferState.isShared()) {
            mCore->mActiveBuffers.erase(slot);
            mCore->mFreeBuffers.push_back(slot); // 把待释放的 buf 放到 freeBuffers 中
        }
    // 此时正好取出暂存的回调函数 .
        listener = mCore->mConnectedProducerListener;// 取出 connect 时候准备的 Listener
        mCore->mDequeueCondition.broadcast();

    } // Autolock scope
    //  调用回调 .
    if (listener != NULL) {
        listener->onBufferReleased();// 执行 Camera3BufferManage 的 onBufferReleased
    }

    return NO_ERROR;
}

• 神秘的 listener 究竟是什么 ?

• • Listener 是Camera3OutputStream::BufferReleasedListener 类，Camera3OutputStream::BufferReleasedListener类是Camera3OutputStream类的子类，而Camera3OutputStream::BufferReleasedListener类的成员函数onReleaseBuffer 即为在 release 时候调用的回调函数。

void Camera3OutputStream::BufferReleasedListener::onBufferReleased() {
    sp<Camera3OutputStream> stream = mParent.promote();
    Mutex::Autolock l(stream->mLock);
   status_t res = stream->mBufferManager->onBufferReleased(
        stream->getId(), stream->getStreamSetId());
  }

1.5 Camera3BufferManager::returnBufferForStream

主要是涉及几个 count map 的管理，将streamId和GraphicBuffer组合成BufferEntry，放到freeBuffers中，前面我们也遇到过BufferEntry结构。

status_t Camera3BufferManager::returnBufferForStream(int streamId,
        int streamSetId, const sp<GraphicBuffer>& buffer, int fenceFd) {
    Mutex::Autolock l(mLock);

    if (mGrallocVersion < HARDWARE_DEVICE_API_VERSION(1,0)) {
        // 取出对应 StreamSetId 的 StreamSet.
        StreamSet& streamSet = mStreamSetMap.editValueFor(streamSetId);
        if (buffer != 0) {
            BufferEntry entry;
            entry.add(streamId, GraphicBufferEntry(buffer, fenceFd));
            status_t res = addBufferToBufferListLocked(streamSet.freeBuffers, entry);// 把返回的 buf 再次加回 freeBuffers 列表 .

        }

        // Update the handed out and attached buffer count for this buffer.
        // 把返回的 buf 放到 freeBuffers 中 .handout 描述的给 client buffer 的个数应该减一 .
        BufferCountMap& handOutBufferCounts = streamSet.handoutBufferCountMap;
        size_t& bufferCount = handOutBufferCounts.editValueFor(streamId);
        bufferCount--;
        // 由于返回的 buf, 我们认为是 free, 给到 freebuffers. 这个 freeBuffers 属于全体 stream 组成的 streamSet 的 .
// 而 attachedBufferCount 描述的是给 stream 的 count 的个数 , 它包含 handout 和从 client 上 release 的 buffer 的集合 . 此 // 处也会减一 , 以作为 handout 的相应 .
        size_t& attachedBufferCount = streamSet.attachedBufferCountMap.editValueFor(streamId);
        attachedBufferCount--;
    } else {
        // TODO: implement this.
        return BAD_VALUE;
    }

    return OK;
}

status_t Camera3BufferManager::addBufferToBufferListLocked(BufferList& bufList,
        const BufferEntry& buffer) {
    bufList.push_back(buffer);
    return OK;
}

二、 GUI/BufferQueueProducer 之 buf 产生者

第一个问题，何为 Producer？

我们先看一下BufferQueueProducer类的关键成员函数：

requestBuffer
    返回 slot 对应的 GraphicBuffer. 正常情况下 ,dequeuBuffer 会返回一个 slot 值 , 然后我们按照这个 slot 值取请求
    GraphicBuffer. 如果之前的 dequeueBuffer 返回 flags 揭示之前的 buffer 不再合法 , 一定要再次调用 requestBuffer 函数 .

dequeueBuffer
    为 BufferQueueProducer 拿到下一个 buffer 的 index。从 BufferQueue 中。
    outFense 是说，只有在 NO_FENSE 时候，才能立即写。其他的情况会返回-EBUSY.
    width,height,format,musage 是描述 buffer 的属性。
    返回值如果是 OK 的话，紧接着调用 requestBuffer 拿到对应这个槽的 buffer。

queueBuffer
    会把填充好的 buffer 放到 BufferQueue 中。
    需要一个 timeStamp 做输入，描述 buffer，单位 ns。
    输出是含有 buffer 信息的结构，包括已经 queued 的 buffer 的个数。
Query
    寻味 native window 的属性。输入 window.h 定义的，比如 NATIVE_WINDOW_FORMAT

Connect
    尝试链接 producer api 到 bufferQueue 中。填充 app 的 listener。

一般的步骤：

• 先调用 dequeueBuffer 拿到一个 slot；

• 然后依据这个 slot，调用 requestBuffer，拿到 buffer。

重要数据结构：mSlot，它是 BufferSlot 结构。

namespace android {
    class BufferQueueCore;
    namespace BufferQueueDefs {
        enum { NUM_BUFFER_SLOTS = 64 };
        typedef BufferSlot SlotsType[NUM_BUFFER_SLOTS];
    } // namespace BufferQueueDefs
} // namespace android
struct BufferSlot {

    BufferSlot()
    : mGraphicBuffer(nullptr),
      mEglDisplay(EGL_NO_DISPLAY),
      mBufferState(),
      mRequestBufferCalled(false),
      mFrameNumber(0),
      mEglFence(EGL_NO_SYNC_KHR),
      mFence(Fence::NO_FENCE),
      mAcquireCalled(false),
      mNeedsReallocation(false) {
    }

   // 指向分配的 GraphicBuffer
    sp<GraphicBuffer> mGraphicBuffer;

    // 用来构建 EGLSyncKHR 对象组
    EGLDisplay mEglDisplay;

    // 当前这个 slot 的状态
    BufferState mBufferState;

// debug 用 , 描述了 producer 曾发起过 requestBuffer 请求 .
    bool mRequestBufferCalled;

    // mFrameNumber  该 slot 上装的 frame 的 framenumber, 可以利用它以 LRU 顺序 dequeue buffer
    uint64_t mFrameNumber;

// EGL 同步对象 . 必须保证在 slot 槽 dequeue 之前触发 (signal).
EGLSyncKHR mEglFence;

// 同步信号 . 揭示上任主人的读写操作是否完成 . 如果是 free 态 , 说明上个 consumer 的读完成了 , 或者上个
Producer 的写完成了 .
    sp<Fence> mFence;

    // buffer 是否被 consumer 请求过 .
    bool mAcquireCalled;

    // 是否需要在不通知 producer 的情况下重新分配 buffer, 可能是由于现有的 buffer 的尺寸 , 用途不合适 . 
    bool mNeedsReallocation;
};

mCore 是什么？

如图 4 所示。所谓的 mCore，其实是BufferQueueCore结构 。它主要是几个数据成员：mFreeSlots、 mFreeBuffers以及mActiveBuffers。他们都是int型 数组，数据成员是 slot 的 id。

所谓的 slot，是SlotType数组，共 64 个SlotType的结构 。每个SlotType的结构都含有mGraphicBuffer。

这几个结构的区别是：

• mFreeSlots描述的一组 slot id，他们是 free 并没有关联的 buffer。

• mFreeBuffers描述的一组 slot id，他们是 free 但有关联的 buffer。

• mActiveBuffers描述一组有 non-free 态 buffer 的 slot id。

• mSharedBufferSlot描述一个 shared 的GraphicBuffer，所谓共享是在 “物理内存” 层面的共享。

图-4-BufferQueueCore 中 slots 和 slotsType 结构

class BufferQueueCore : public virtual RefBase {
    // mFreeSlots contains all of the slots which are FREE and do not currently
// have a buffer attached.
// 包含所有 free 态的并且尚未和 buffer attached 的 slot id
    std::set<int> mFreeSlots;

    // mFreeBuffers contains all of the slots which are FREE and currently have
// a buffer attached.
// 包含所有 free 态的并且已有 buffer attached 上的 slot id
    std::list<int> mFreeBuffers;

    // mUnusedSlots contains all slots that are currently unused. They should be
// free and not have a buffer attached.
// 尚未使用的 slot id , 他们是 free 并且没有 buffer attached 上的 .
    std::list<int> mUnusedSlots;

// mActiveBuffers contains all slots which have a non-FREE buffer attached.
// 含有所有非 free 态 buffer attached 的 slot id
    std::set<int> mActiveBuffers;

    // mDequeueCondition is a condition variable used for dequeueBuffer in
    // synchronous mode.
mutable Condition mDequeueCondition;

// 是否该 slot 使能了共享模式 .
bool mSharedBufferMode;

// When shared buffer mode is enabled, this indicates whether the consumer
// should acquire buffers even if BufferQueue doesn't indicate that they are
// available.
bool mAutoRefresh;

// When shared buffer mode is enabled, this tracks which slot contains the
// shared buffer.
// 共享 buf 模式使能时 , 揭示究竟是哪一个 BufferSlot 关联的是共享 buf, 它也是个 slot 的 id.
int mSharedBufferSlot;
}

2.1 BufferQueueProducer::dequeueBuffer

从mFreeSlots 、mFreeBuffers中找到合适的 slot 的 id。

status_t BufferQueueProducer::dequeueBuffer(int *outSlot,sp<android::Fence> *outFence, uint32_t width, uint32_t height,PixelFormat format, uint32_t usage) {
    // 初始化
    status_t returnFlags = NO_ERROR;
    EGLDisplay eglDisplay = EGL_NO_DISPLAY;
    EGLSyncKHR eglFence = EGL_NO_SYNC_KHR;
    bool attachedByConsumer = false;

    { // Autolock scope
        Mutex::Autolock lock(mCore->mMutex);
        mCore->waitWhileAllocatingLocked();

        int found = BufferItem::INVALID_BUFFER_SLOT;
        // 这里会阻塞等待可用的 slot.
        while (found == BufferItem::INVALID_BUFFER_SLOT) {
            status_t status = waitForFreeSlotThenRelock(FreeSlotCaller::Dequeue,
                    &found);


            const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer);
            //  如果 BufferQueueCore 不允许 allocation, 我们就把这个 buffer 再次添加回 mFreeSlots 链表中 . 然后继续等待 freeSlot 的 buffer. 本来 mFreeSlots 里描述的 slot 就是没有关联 buffer 的 , 此处再不让 allocation, 岂不是拿不到我们的 buffer 了 . 所以此处再把 buffer 放回 mFreeSlots 中 .
            if (!mCore->mAllowAllocation) {
                if (buffer->needsReallocation(width, height, format, usage)) {
                    if (mCore->mSharedBufferSlot == found) {
                        BQ_LOGE("dequeueBuffer: cannot re-allocate a shared"
                                "buffer");
                        return BAD_VALUE;
                    }
                    mCore->mFreeSlots.insert(found);
                    mCore->clearBufferSlotLocked(found);
                    found = BufferItem::INVALID_BUFFER_SLOT;
                    continue;
                }
            }
        }
    // shared buffer 不能重新分配
        const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer);
        if (mCore->mSharedBufferSlot == found &&
                buffer->needsReallocation(width,  height, format, usage)) {
            BQ_LOGE("dequeueBuffer: cannot re-allocate a shared"
                    "buffer");

            return BAD_VALUE;
        }

        if (mCore->mSharedBufferSlot != found) {
            mCore->mActiveBuffers.insert(found);// 添加到 mActiveBuffers 中
        }
        *outSlot = found;
        ATRACE_BUFFER_INDEX(found);

        attachedByConsumer = mSlots[found].mNeedsReallocation;
        mSlots[found].mNeedsReallocation = false;

        mSlots[found].mBufferState.dequeue();

        if ((buffer == NULL) ||
                buffer->needsReallocation(width, height, format, usage))// 由于尺寸 , 用途等不满足 , 需要重新分配 .
        {
            mSlots[found].mAcquireCalled = false;
            mSlots[found].mGraphicBuffer = NULL;
            mSlots[found].mRequestBufferCalled = false;
            mSlots[found].mEglDisplay = EGL_NO_DISPLAY;
            mSlots[found].mEglFence = EGL_NO_SYNC_KHR;
            mSlots[found].mFence = Fence::NO_FENCE;
            mCore->mBufferAge = 0;
            mCore->mIsAllocating = true;

            returnFlags |= BUFFER_NEEDS_REALLOCATION;
        } else {
            // We add 1 because that will be the frame number when this buffer
            // is queued
            mCore->mBufferAge =
                    mCore->mFrameCounter + 1 - mSlots[found].mFrameNumber;
        }

        eglDisplay = mSlots[found].mEglDisplay;
        eglFence = mSlots[found].mEglFence;

    } // Autolock scope

    if (returnFlags & BUFFER_NEEDS_REALLOCATION) {// 如果需要分配 .
        status_t error;
        BQ_LOGV("dequeueBuffer: allocating a new buffer for slot %d", *outSlot);
        sp<GraphicBuffer> graphicBuffer(mCore->mAllocator->createGraphicBuffer(
                width, height, format, usage,
                {mConsumerName.string(), mConsumerName.size()}, &error));
        { // Autolock scope
            Mutex::Autolock lock(mCore->mMutex);

            if (graphicBuffer != NULL && !mCore->mIsAbandoned) {
                graphicBuffer->setGenerationNumber(mCore->mGenerationNumber);
                mSlots[*outSlot].mGraphicBuffer = graphicBuffer;
            }

         } // Autolock scope
    }
    return returnFlags;
}

在上面的第一步就是要等到 free 的 slot。

status_t BufferQueueProducer::waitForFreeSlotThenRelock(FreeSlotCaller caller,
        int* found) const {
    auto callerString = (caller == FreeSlotCaller::Dequeue) ?"dequeueBuffer" : "attachBuffer";// 我们这里是 dequeueBuffer.
    bool tryAgain = true;
    while (tryAgain) {

        int dequeuedCount = 0;
        int acquiredCount = 0;
        for (int s : mCore->mActiveBuffers) {
            if (mSlots[s].mBufferState.isDequeued()) {
                ++dequeuedCount;
            }
            if (mSlots[s].mBufferState.isAcquired()) {
                ++acquiredCount;
            }
        }


        *found = BufferQueueCore::INVALID_BUFFER_SLOT;

        // If we disconnect and reconnect quickly, we can be in a state where
        // our slots are empty but we have many buffers in the queue. This can
        // cause us to run out of memory if we outrun the consumer. Wait here if
        // it looks like we have too many buffers queued up.
        const int maxBufferCount = mCore->getMaxBufferCountLocked();
        bool tooManyBuffers = mCore->mQueue.size()
                            > static_cast<size_t>(maxBufferCount);
        if (tooManyBuffers) {
            BQ_LOGV("%s: queue size is %zu, waiting", callerString,
                    mCore->mQueue.size());
        } else {
         // 如果处于共享 buf 模式 , 返回已有的共享 buf. 所谓共享 buf, 就是一个 StreamSet 里边多个 Stream 共享一个 buf.
            if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot !=
                    BufferQueueCore::INVALID_BUFFER_SLOT) {
      // 一 , 如果使能 shared 模式 . 并且有 shared buffer slot, 优先选择使用 shared buffer
                *found = mCore->mSharedBufferSlot;
            } else {
                if (caller == FreeSlotCaller::Dequeue) {
        // 二 , 从 FreeeBuffer 和 FreeSlot 中依次拿到 slot.mFreeBuffers 是含有关联 buf 的空闲 slot.mFreeSlot 是尚未关联 buf 的 slot.
                int slot = getFreeBufferLocked();
                    if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) {
                        *found = slot;
                    } else if (mCore->mAllowAllocation) {
                        *found = getFreeSlotLocked();
                    }
                } else {
                    // If we're calling this from attach, prefer free slots
                    int slot = getFreeSlotLocked();
                    if (slot != BufferQueueCore::INVALID_BUFFER_SLOT) {
                        *found = slot;
                    } else {
                        *found = getFreeBufferLocked();
                    }
                }
            }
        }
    } // while (tryAgain)

    return NO_ERROR;
}

进一步的 buffer 的 “槽” 来源于mFreeBuffers和mFreeSlots。

int BufferQueueProducer::getFreeBufferLocked() const {
    if (mCore->mFreeBuffers.empty()) {
        return BufferQueueCore::INVALID_BUFFER_SLOT;
    }
    int slot = mCore->mFreeBuffers.front();
    mCore->mFreeBuffers.pop_front();
    return slot;
}

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.2 BufferQueueProducer::requestBuffer

返回刚才 dequeue 的 slot 对应的mGraphicBuffer。

status_t BufferQueueProducer::requestBuffer(int slot, sp<GraphicBuffer>* buf) {
    Mutex::Autolock lock(mCore->mMutex);
    mSlots[slot].mRequestBufferCalled = true;
    *buf = mSlots[slot].mGraphicBuffer;
    return NO_ERROR;
}

2.3 典型用法

图-5- camera3OutputStream::getBufferLocked 典型用法

扫描下方二维码，阅读完整原文