Android SurfaceFlinger2　获取Surface

最新推荐文章于 2023-06-27 16:25:48 发布

Big Skipper

最新推荐文章于 2023-06-27 16:25:48 发布

阅读量883

点赞数

分类专栏： Android framework

本文链接：https://blog.csdn.net/liuwg1226/article/details/115318032

版权

Android framework 专栏收录该内容

94 篇文章 123 订阅

订阅专栏

在这里插入图片描述

一　概述

接上篇文章对代码进行分析

该部分代码是在上一章节中 Surface 测试程序源码的精简版，保存了最关键的流程，如下所示：

#include <cutils/memory.h>
#include <utils/Log.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
#include <android/native_window.h>
 
using namespace android;
 
int main(int argc, char** argv)
{
    //...
    //1 创建surfaceflinger的客户端
    sp<SurfaceComposerClient> client = new SurfaceComposerClient();
    
    //2 获取surface
    sp<SurfaceControl> surfaceControl = client->createSurface(String8("resize"),
            160, 240, PIXEL_FORMAT_RGB_565, 0);
    sp<Surface> surface = surfaceControl->getSurface();
 
    //设置layer，layer值越大，显示层越靠前
    SurfaceComposerClient::openGlobalTransaction();
    surfaceControl->setLayer(100000);
    SurfaceComposerClient::closeGlobalTransaction();
 
    //3 获取 buffer->锁定 buffer->写入 buffer->解锁并提交 buffer 
    //这里主要关注：申请 Buff 和提交 Buff
    ANativeWindow_Buffer outBuffer;
    surface->lock(&outBuffer, NULL);
    ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
    android_memset16((uint16_t*)outBuffer.bits, 0xF800, bpr*outBuffer.height);
    surface->unlockAndPost();
    //...
    
    return 0;
}

主要的步骤为：

获取 SurfaceFlinger（后简称 SF）的客户端，通过 SF 的客户端获取 SurfaceControl，进而获得 Surface
通过 SurfaceControl 设置 Layer 层数值(忽略)，通过 Surface 获取 Buffer，锁定 Buffer 并写入 Buffer
最后提交 Buffer

本章节主要关注第1步和第2步，获取 SF 的客户端，进而获取 SurfaceControl，再获得 Surface 的过程。

二　获取SF客户端

我们从下面源码开始分析：

sp<SurfaceComposerClient> client = new SurfaceComposerClient();

分析 SurafceComposerClient，代码如下：

SurfaceComposerClient::SurfaceComposerClient()
    : mStatus(NO_INIT), mComposer(Composer::getInstance())
{
}

主要是初始化了 mStatus 和 mComposer，同时留意下关键的 onFirstRef 函数，代码如下：

void SurfaceComposerClient::onFirstRef() {
    //获取 SF 服务的客户端
    sp<ISurfaceComposer> sm(ComposerService::getComposerService());
    if (sm != 0) {
        //通过 SF 服务的 createConnection 得到
        //一个 client 对象（ISurfaceComposerClient 类型）
        sp<ISurfaceComposerClient> conn = sm->createConnection();
        if (conn != 0) {
            mClient = conn;
            mStatus = NO_ERROR;
        }
    }
}

这里首先获取SF服务，通过访问 SF 服务的 createConnection 方法获得 client（ISurfaceComposerClient 类型，实际上是对应一个 APP）对象。代码如下：

sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
{
    sp<ISurfaceComposerClient> bclient;
    sp<Client> client(new Client(this));
    status_t err = client->initCheck();
    if (err == NO_ERROR) {
        bclient = client;
    }
    return bclient;
}

这里主要是创建了一个 client 并返回给上一层的 conn。（这里整个分析过程中忽略了 Binder 通信部分的分析，Binder 通信部分详见系列文章链接：专题分纲目录 android 系统核心机制 binder），这里最后给出一张该部分的 Binder 通信架构的 UML 图，如下所示：
在这里插入图片描述

三　获取Surface

我们首先是通过获取 SF 的客户端，进而获取 SurfaceControl，通过 SurfaceControl 再获得 Surface，所以我们先分析获取 SurfaceControl 的流程，之后分析获取 Surface 的流程。关键代码如下：

    sp<SurfaceControl> surfaceControl = client->createSurface(String8("resize"),
            160, 240, PIXEL_FORMAT_RGB_565, 0);
    sp<Surface> surface = surfaceControl->getSurface();

3.1 获取SurfaceControl

这里关注上面代码中的第一句，createSurface 的实现代码如下：

sp<SurfaceControl> SurfaceComposerClient::createSurface(
        const String8& name,
        uint32_t w,
        uint32_t h,
        PixelFormat format,
        uint32_t flags)
{
    sp<SurfaceControl> sur;
    if (mStatus == NO_ERROR) {
        sp<IBinder> handle;
        sp<IGraphicBufferProducer> gbp;
        status_t err = mClient->createSurface(name, w, h, format, flags,
                &handle, &gbp);
        ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
        if (err == NO_ERROR) {
            sur = new SurfaceControl(this, handle, gbp);
        }
    }
    return sur;
}

这里的 mClient->createSurface 方法最后调用了 Client 类的 createSurface（这个分析过程中忽略了 Binder 通信部分的分析，Binder 通信部分详见系列文章链接：专题分纲目录 android 系统核心机制 binder），相关代码如下：

status_t Client::createSurface(
        const String8& name,
        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
        sp<IBinder>* handle,
        sp<IGraphicBufferProducer>* gbp)
{
    class MessageCreateLayer : public MessageBase {
        SurfaceFlinger* flinger;
        Client* client;
        sp<IBinder>* handle;
        sp<IGraphicBufferProducer>* gbp;
        status_t result;
        const String8& name;
        uint32_t w, h;
        PixelFormat format;
        uint32_t flags;
    public:
        MessageCreateLayer(SurfaceFlinger* flinger,
                const String8& name, Client* client,
                uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
                sp<IBinder>* handle,
                sp<IGraphicBufferProducer>* gbp)
            : flinger(flinger), client(client),
              handle(handle), gbp(gbp),
              name(name), w(w), h(h), format(format), flags(flags) {
        }
        status_t getResult() const { return result; }
        virtual bool handler() {
            //通过SF 创建Layer
            result = flinger->createLayer(name, client, w, h, format, flags,
                    handle, gbp);
            return true;
        }
    };
 
    sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
            name, this, w, h, format, flags, handle, gbp);
    mFlinger->postMessageSync(msg);
    return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}

这里主要是通过 handler Message 机制发送消息，最后通过 SF 创建了一个 Layer，createLayer 的代码如下：

status_t SurfaceFlinger::createLayer(
        const String8& name,
        const sp<Client>& client,
        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
{
    if (int32_t(w|h) < 0) {
        return BAD_VALUE;
    }
    status_t result = NO_ERROR;
    sp<Layer> layer;
 
    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceNormal:
            result = createNormalLayer(client,
                    name, w, h, flags, format,
                    handle, gbp, &layer);
            break;
        case ISurfaceComposerClient::eFXSurfaceDim:
            result = createDimLayer(client,
                    name, w, h, flags,
                    handle, gbp, &layer);
            break;
        default:
            result = BAD_VALUE;
            break;
    }
 
    if (result == NO_ERROR) {
        addClientLayer(client, *handle, *gbp, layer);
        setTransactionFlags(eTransactionNeeded);
    }
    return result;
}

同时创建 Layer 时会有两个分支，是用 createNormalLayer 创建一般的Layer 还是用 createDimLayer 创建一个 DimLayer，最终都会对 handle 和 gbp 进行赋值，两段代码如下：

status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
        const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
    // initialize the surfaces
    switch (format) {
    case PIXEL_FORMAT_TRANSPARENT:
    case PIXEL_FORMAT_TRANSLUCENT:
        format = PIXEL_FORMAT_RGBA_8888;
        break;
    case PIXEL_FORMAT_OPAQUE:
        format = PIXEL_FORMAT_RGBX_8888;
        break;
    }
 
    *outLayer = new Layer(this, client, name, w, h, flags);
    status_t err = (*outLayer)->setBuffers(w, h, format, flags);
    if (err == NO_ERROR) {
        *handle = (*outLayer)->getHandle();
        *gbp = (*outLayer)->getProducer();
    }
 
    return err;
}
 
status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
        const String8& name, uint32_t w, uint32_t h, uint32_t flags,
        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
    *outLayer = new LayerDim(this, client, name, w, h, flags);
    *handle = (*outLayer)->getHandle();
    *gbp = (*outLayer)->getProducer();
    return NO_ERROR;
}

两者都有这段代码：

    *handle = (*outLayer)->getHandle();
    *gbp = (*outLayer)->getProducer();

即对 handle 和 gbp（后面会详细分析）进行赋值，最后把这两个值传递给新创建的 SurfaceControl，之后返回。即每一个 Client（对应 APP）的 SurfaceControl 都对应一个 Layer。同时上面的代码中 LayerDim也是继承 Layer 的，因此创建 Layer 到底做什么？我们要详细分析下 Layer 才知道。

3.2 创建的Layer分析

Layer 类的构造函数如下：

Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client,
        const String8& name, uint32_t w, uint32_t h, uint32_t flags)
    :   contentDirty(false),
        //...
        mClientRef(client),
        mPotentialCursor(false)
{
    mCurrentCrop.makeInvalid();
    mFlinger->getRenderEngine().genTextures(1, &mTextureName);
    mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName);
 
    uint32_t layerFlags = 0;
    if (flags & ISurfaceComposerClient::eHidden)
        layerFlags |= layer_state_t::eLayerHidden;
    if (flags & ISurfaceComposerClient::eOpaque)
        layerFlags |= layer_state_t::eLayerOpaque;
 
    if (flags & ISurfaceComposerClient::eNonPremultiplied)
        mPremultipliedAlpha = false;
 
    mName = name;
 
    mCurrentState.active.w = w;
    //...
    mCurrentState.requested = mCurrentState.active;
 
    // drawing state & current state are identical
    mDrawingState = mCurrentState;
 
    nsecs_t displayPeriod =
            flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
    mFrameTracker.setDisplayRefreshPeriod(displayPeriod);
}

可以看到以上主要是对一些变量的初始化，暂且忽略，再接着看关键方法 onFirstRef，代码如下：

void Layer::onFirstRef() {
    // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
    sp<IGraphicBufferProducer> producer;
    sp<IGraphicBufferConsumer> consumer;
    BufferQueue::createBufferQueue(&producer, &consumer);
    mProducer = new MonitoredProducer(producer, mFlinger);
    mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName);
    mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
    mSurfaceFlingerConsumer->setContentsChangedListener(this);
    mSurfaceFlingerConsumer->setName(mName);
 
#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
#warning "disabling triple buffering"
    mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2);
#else
    mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3);
#endif
 
    const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice());
    updateTransformHint(hw);
}

3.2.1 createBufferQueue方法

这里关注 BufferQueue的createBufferQueue 方法，代码如下：

void BufferQueue::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
        sp<IGraphicBufferConsumer>* outConsumer,
        const sp<IGraphicBufferAlloc>& allocator) {
    sp<BufferQueueCore> core(new BufferQueueCore(allocator));
    sp<IGraphicBufferProducer> producer(new BufferQueueProducer(core));
    sp<IGraphicBufferConsumer> consumer(new BufferQueueConsumer(core));
    *outProducer = producer;
    *outConsumer = consumer;
}

可以看到，每一个 Layer 都有一个生产者 producer 和消费者 consumer 并指向同一个 BufferQueueCore，BufferQueueCore 中有一个关键的成员变量 BufferQueueDefs::SlotsType mSlots；SlotsType 类型是一个数量为64的数组。即生产者 producer 和消费者 consumer 最终指向的同一个核心数组 mSlots（一个64元素的数组）。

3.2.2 MonitoredProducer类分析

MonitoredProducer(producer, mFlinger)中 producer 和 SF 的关系主要是在析构时 SF 将 producer 从 mGraphicBufferProducerList （gbp 链表）中移除，对应代码如下：

//构造函数
MonitoredProducer::MonitoredProducer(const sp<IGraphicBufferProducer>& producer,
        const sp<SurfaceFlinger>& flinger) :
    mProducer(producer),
    mFlinger(flinger) {}
//析构函数
MonitoredProducer::~MonitoredProducer() {
    class MessageCleanUpList : public MessageBase {
    public:
        MessageCleanUpList(const sp<SurfaceFlinger>& flinger,
                const wp<IBinder>& producer)
            : mFlinger(flinger), mProducer(producer) {}
        virtual ~MessageCleanUpList() {}
        virtual bool handler() {
            Mutex::Autolock _l(mFlinger->mStateLock);
            mFlinger->mGraphicBufferProducerList.remove(mProducer);
            return true;
        }
    private:
        sp<SurfaceFlinger> mFlinger;
        wp<IBinder> mProducer;
    };
 
    mFlinger->postMessageAsync(new MessageCleanUpList(mFlinger, asBinder()));
}

3.3 获取Surface

这里关注上面代码中的第二句，surfaceControl->getSurface() 的实现代码如下：

sp<Surface> SurfaceControl::getSurface() const
{
    Mutex::Autolock _l(mLock);
    if (mSurfaceData == 0) {
        // This surface is always consumed by SurfaceFlinger, so the
        // producerControlledByApp value doesn't matter; using false.
        //这里的mGraphicBufferProducer就是之前传递进来的gbp
        mSurfaceData = new Surface(mGraphicBufferProducer, false);
    }
    return mSurfaceData;
}

这里创建了一个新的 Surface 并把 gbp 参数传递给 Surface，最后返回。

3.4 总结

APP 对应一个 client，一个 SurfaceControl 对应一个 Layer，gbp（BpGraphicBufferProducer）对应 Layer 中的 mProducer（BnGraphicBufferProducer），它们均遵守同一个接口 IGraphicBufferProducer，相关类的关系如下所示：
在这里插入图片描述

Big Skipper

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Android SurfaceFlinger2　获取Surface

一　概述接上篇文章对代码进行分析该部分代码是在上一章节中 Surface 测试程序源码的精简版，保存了最关键的流程，如下所示：#include <cutils/memory.h>#include <utils/Log.h>#include <binder/IPCThreadState.h>#include <binder/ProcessState.h>#include <binder/IServiceManager.h>#incl.
复制链接

扫一扫