Android-View绘制原理(14)-RenderPipeline

在上一篇关于帧绘制的原理中，做好了EGLSuface切换，同步好了UI的更新，为需要进行GPU绘制的RenderNode创好了SKSurface, 最后通过ANativeWindow为下一帧调用了dequeueBuffer。所有的资源和数据都准备好了，从而可以进行绘制，这个任务将由RenderPipeline来完成。我们先不考虑Fence的逻辑，直接接着上一篇文章，从CanvasContext.draw方法出发。

1 CanvasContext.draw

frameworks/base/libs/hwui/renderthread/CanvasContext.cpp

nsecs_t CanvasContext::draw() {
    ...
    Frame frame = mRenderPipeline->getFrame();
    SkRect windowDirty = computeDirtyRect(frame, &dirty);

    bool drew = mRenderPipeline->draw(frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue,
                                      mContentDrawBounds, mOpaque, mLightInfo, mRenderNodes,
                                      &(profiler()));
    ...
   bool didSwap =  mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo, &requireSwap);

    ...
     for (auto& func : mFrameCompleteCallbacks) {
            std::invoke(func, frameCompleteNr);
        }
        mFrameCompleteCallbacks.clear();
    }
   ...
    cleanupResources();
    mRenderThread.cacheManager().onFrameCompleted();
    return mCurrentFrameInfo->get(FrameInfoIndex::DequeueBufferDuration);
}

这个draw方法比较复杂，这里摘取主要逻辑来分析一下。可以看到具体的绘制是继续委托到mRenderPipeline去完成的，仅仅分析一下使用OpenGL绘制的情况，因此对应的SkiaOpenGLPipeline。这里主要由这个几个步骤

• 创建Frame对象
• 调用mRenderPipeline->draw进行绘制
• mRenderPipeline->swapBuffers 切换GragphicBuffer
• 回调FrameCompleteCalback。

下面就按这个流程来分析

2 mRenderPipeline->getFrame

Frame是一个帧的模型

class Frame {
public:
    Frame(int32_t width, int32_t height, int32_t bufferAge)
            : mWidth(width), mHeight(height), mBufferAge(bufferAge) {}

    int32_t width() const { return mWidth; }
    int32_t height() const { return mHeight; }
    int32_t bufferAge() const { return mBufferAge; }

private:
    Frame() {}
    friend class EglManager;

    int32_t mWidth;
    int32_t mHeight;
    int32_t mBufferAge;

    EGLSurface mSurface;

    // Maps from 0,0 in top-left to 0,0 in bottom-left
    // If out is not an int32_t[4] you're going to have a bad time
    void map(const SkRect& in, int32_t* out) const;
};

它封装的是一个EGLSurface, 前面分析过，EGLSurface关联着一个ANativeWindow, 也就是一个Surface对象，所以Frame可以代表一个Surface对象。

frameworks/base/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp

Frame SkiaOpenGLPipeline::getFrame() {
    LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE,
                        "drawRenderNode called on a context with no surface!");
    return mEglManager.beginFrame(mEglSurface);
}

进入到mEglManager的beginFrame方法

Frame EglManager::beginFrame(EGLSurface surface) {
    LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE, "Tried to beginFrame on EGL_NO_SURFACE!");
    makeCurrent(surface);
    Frame frame;
    frame.mSurface = surface;
    eglQuerySurface(mEglDisplay, surface, EGL_WIDTH, &frame.mWidth);
    eglQuerySurface(mEglDisplay, surface, EGL_HEIGHT, &frame.mHeight);
    frame.mBufferAge = queryBufferAge(surface);
    eglBeginFrame(mEglDisplay, surface);
    return frame;
}

将这个surface切换到当前后，新创建一个Frame对象，并将surface赋给这个frame对象，后设在对象的长宽属性等，然后返回这个新的Frame对象。

3 mRenderPipeline->draw

使用OpenGL来绘制的时候，mRenderPipeline是一个SkiaOpenGLPipeline对象，它是SkiaPipeline的子类，我们来分析一下它的draw方法

frameworks/base/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp

bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
                              const LightGeometry& lightGeometry,
                              LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
                              bool opaque, const LightInfo& lightInfo,
                              const std::vector<sp<RenderNode>>& renderNodes,
                              FrameInfoVisualizer* profiler) {
    ...
    GrGLFramebufferInfo fboInfo;
    fboInfo.fFBOID = 0;
    ....
    GrBackendRenderTarget backendRT(frame.width(), frame.height(), 0, STENCIL_BUFFER_SIZE, fboInfo);
    ...
    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
     sk_sp<SkSurface> surface(SkSurface::MakeFromBackendRenderTarget(
            mRenderThread.getGrContext(), backendRT, this->getSurfaceOrigin(), colorType,
            mSurfaceColorSpace, &props));
     ...
    renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, contentDrawBounds, surface,
                SkMatrix::I());

    ...
    {
        ATRACE_NAME("flush commands");
        surface->flushAndSubmit();
    }
    layerUpdateQueue->clear();
    
    return true;
}

这里首先生成了一个GrGLFramebufferInfo和GrBackendRenderTarget，它是属于skia库里的api，但是只包含一些j简单的属性信息。

external/skia/include/gpu/gl/GrGLTypes.h

struct GrGLFramebufferInfo {
    GrGLuint fFBOID;
    GrGLenum fFormat = 0;

    bool operator==(const GrGLFramebufferInfo& that) const {
        return fFBOID == that.fFBOID && fFormat == that.fFormat;
    }
};

external/skia/src/gpu/GrBackendSurface.cpp

GrBackendRenderTarget::GrBackendRenderTarget(int width,
                                             int height,
                                             int sampleCnt,
                                             int stencilBits,
                                             const GrGLFramebufferInfo& glInfo)
        : fWidth(width)
        , fHeight(height)
        , fSampleCnt(std::max(1, sampleCnt))
        , fStencilBits(stencilBits)
        , fBackend(GrBackendApi::kOpenGL)
        , fGLInfo(glInfo) {
    fIsValid = SkToBool(glInfo.fFormat); // the glInfo must have a valid format
}

随后调用SkSurface::MakeFromBackendRenderTarget生成一个SkSurface，这是Skia在GPU上申请用于绘制的surface。我们来看看这个sksurface 的生成流程。

sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrRecordingContext* context,
                                                        const GrBackendRenderTarget& rt,
                                                        GrSurfaceOrigin origin,
                                                        SkColorType colorType,
                                                        sk_sp<SkColorSpace> colorSpace,
                                                        const SkSurfaceProps* props,
                                                        SkSurface::RenderTargetReleaseProc relProc,
                                                        SkSurface::ReleaseContext releaseContext) {
    ...
    auto sdc = GrSurfaceDrawContext::MakeFromBackendRenderTarget(context,
                                                                 grColorType,
                                                                 std::move(colorSpace),
                                                                 rt,
                                                                 origin,
                                                                 SkSurfacePropsCopyOrDefault(props),
                                                                 std::move(releaseHelper));
    if (!sdc) {
        return nullptr;
    }

    auto device = SkGpuDevice::Make(std::move(sdc), SkGpuDevice::kUninit_InitContents);
    if (!device) {
        return nullptr;
    }

    return sk_make_sp<SkSurface_Gpu>(std::move(device));
}

首先生成一个GrSurfaceDrawContext的对象sdc，由它来持有上面生成的GrBackendRenderTarget和GrRecordingContext，

sk_sp<SkGpuDevice> SkGpuDevice::Make(std::unique_ptr<GrSurfaceDrawContext> surfaceDrawContext,
                                     InitContents init) {
    if (!surfaceDrawContext) {
        return nullptr;
    }

    GrRecordingContext* rContext = surfaceDrawContext->recordingContext();
    if (rContext->abandoned()) {
        return nullptr;
    }

    SkColorType ct = GrColorTypeToSkColorType(surfaceDrawContext->colorInfo().colorType());

    unsigned flags;
    if (!rContext->colorTypeSupportedAsSurface(ct) ||
        !CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
        return nullptr;
    }
    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(surfaceDrawContext), flags));
}

SkGpuDevice::SkGpuDevice(std::unique_ptr<GrSurfaceDrawContext> surfaceDrawContext, unsigned flags)
        : INHERITED(make_info(surfaceDrawContext.get(), SkToBool(flags & kIsOpaque_Flag)),
                    surfaceDrawContext->surfaceProps())
        , fContext(sk_ref_sp(surfaceDrawContext->recordingContext()))
        , fSurfaceDrawContext(std::move(surfaceDrawContext))
#if !defined(SK_DISABLE_NEW_GR_CLIP_STACK)
        , fClip(SkIRect::MakeSize(fSurfaceDrawContext->dimensions()),
                &this->asMatrixProvider(),
                force_aa_clip(fSurfaceDrawContext.get())) {
#else
        , fClip(fSurfaceDrawContext->dimensions(), &this->cs(), &this->asMatrixProvider()) {
#endif
    if (flags & kNeedClear_Flag) {
        this->clearAll();
    }
}

这里创将了一个SkGpuDevice对象，它的成员变量 fContext 是通过外部传入的 surfaceDrawContext 调用 recordingContext 方法的得来的，而这个surfaceDrawContext就是上面的 sdc 局部变量，它的 recordingContext 实质上来自 mRenderThread.getGrContext() 方法。因此 SkGpuDevice的fContext指向的是mRenderThread.getGrContext()返回的对象 。

之后此构建了一个SkSurface_Gpu对象，它是SkSurface的子类，因为传入的是SkGpuDevice，所以绘制命令将通过它提交到GPU进行像素渲染。准备好了SkSurface之后，调用renderFrame在该SkSurface上绘制。最后调用 surface->flushAndSubmit();提交到GPU。这里的内容比较多，在后面的文章中再展开。

4 总结

本文分析了帧绘制的流程，这个抽象成了一个RenderPipeline，根据使用不同渲染引擎，提供了SkiaOpenGLPipeline和SkiaVulkanPipeline两个实现，本文仅仅分析SkiaOpenGLPipeline，它的绘制总共被分成了3个步骤：

• 创建SkSurface
• renderFrame 将记录的描述数据记录的SkSurface
• flushAndSubmit 提交绘制命令到GPU进行像素渲染

在更大的视角上看，绘制的步骤包含：

• 绘制前准备Frame模型
• SkiaOpenGLPipeline 调用GPU绘制
• mRenderPipeline->swapBuffers 通知HWComposer进行屏幕合成
• 回调FrameCompleteCalback结尾