Android下SF合成流程重学习之GPU合成

    Android下SF合成流程重学习之GPU合成



弁言

SurfaceFlinger中的图层选择GPU合成(CLIENT合成方式)时，会把待合成的图层Layers通过renderengine(SkiaGLRenderEngine)绘制到一块GraphicBuffer中，然后把这块GraphicBuffer图形缓存通过调用setClientTarget传递给HWC模块，HWC进一步处置惩罚后把这个GraphicBuffer中的图像呈现到屏幕上。
本篇文章，我们先聚焦如下量点做介绍：

• 用于存储GPU合成后的图形数据的GraphicBuffer是从那里来的？
  
• GPU合成中,SF实行的主要逻辑是什么？
  

---

一.从dumpsys SurfaceFlinger中的信息谈起

如果你检察过dumpsys SurfaceFlinger的信息，也许你注意过一些GraphicBufferAllocator/GraphicBufferMapper打印出的一些信息，这些信息记载了所有通过Gralloc模块allocate和import的图形缓存的信息。
如下是在我的平台下截取的dumpsys SurfaceFlinger部门信息：

1. GraphicBufferAllocator buffers:
2.     Handle |        Size |     W (Stride) x H | Layers |   Format |      Usage | Requestor
3. 0xf3042b90 | 8100.00 KiB | 1920 (1920) x 1080 |      1 |        1 | 0x    1b00 | FramebufferSurface
4. 0xf3042f30 | 8100.00 KiB | 1920 (1920) x 1080 |      1 |        1 | 0x    1b00 | FramebufferSurface
5. 0xf3046020 | 8100.00 KiB | 1920 (1920) x 1080 |      1 |        1 | 0x    1b00 | FramebufferSurface
6. Total allocated by GraphicBufferAllocator (estimate): 24300.00 KB
7. Imported gralloc buffers:
8. + name:FramebufferSurface, id:e100000000, size:8.3e+03KiB, w/h:780x438, usage: 0x40001b00, req fmt:5, fourcc/mod:875713089/576460752303423505, dataspace: 0x0, compressed: true
9.         planes: B/G/R/A:         w/h:780x440, stride:1e00 bytes, size:818000
10. + name:FramebufferSurface, id:e100000001, size:8.3e+03KiB, w/h:780x438, usage: 0x40001b00, req fmt:5, fourcc/mod:875713089/576460752303423505, dataspace: 0x0, compressed: true
11.         planes: B/G/R/A:         w/h:780x440, stride:1e00 bytes, size:818000
12. + name:FramebufferSurface, id:e100000002, size:8.3e+03KiB, w/h:780x438, usage: 0x40001b00, req fmt:5, fourcc/mod:875713089/576460752303423505, dataspace: 0x0, compressed: true
13.         planes: B/G/R/A:         w/h:780x440, stride:1e00 bytes, size:818000
14. Total imported by gralloc: 5e+04KiB

复制代码

上面的信息中可以看到一些儿冥冥之中貌似、好像、好像很有意思的字眼：FramebufferSurface。
作为Requestor的FramebufferSurface去请求分配了三块图形缓存，还规定了width、height、format、usage等信息。
如上你看到的这3块GraphicBuffer，就是用来存储CPU合成后的图形数据的。

---

二.SF为GPU合成做的准备

俗话说的好，不打没有准备的仗。SF也是云云，为了做好GPU的合成，SF会在启动的时候就搭建好EGL环境，为后续GPU合成做好准备。详细逻辑如下:

1. 文件：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
3. void SurfaceFlinger::init() {
4.     ALOGI(  "SurfaceFlinger's main thread ready to run. "
5.             "Initializing graphics H/W...");
6.     Mutex::Autolock _l(mStateLock);
8.     // Get a RenderEngine for the given display / config (can't fail)
9.     // TODO(b/77156734): We need to stop casting and use HAL types when possible.
10.     // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
11.     // 创建RenderEngine对象
12.     mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(
13.             renderengine::RenderEngineCreationArgs::Builder()
14.                 .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
15.                 .setImageCacheSize(maxFrameBufferAcquiredBuffers)
16.                 .setUseColorManagerment(useColorManagement)
17.                 .setEnableProtectedContext(enable_protected_contents(false))
18.                 .setPrecacheToneMapperShaderOnly(false)
19.                 .setSupportsBackgroundBlur(mSupportsBlur)
20.                 .setContextPriority(useContextPriority
21.                         ? renderengine::RenderEngine::ContextPriority::HIGH
22.                         : renderengine::RenderEngine::ContextPriority::MEDIUM)
23.                 .build()));
25. 文件：frameworks/native/libs/renderengine/RenderEngine.cpp
27. std::unique_ptr<impl::RenderEngine> RenderEngine::create(const RenderEngineCreationArgs& args) {
28.     char prop[PROPERTY_VALUE_MAX];
29.      // 如果PROPERTY_DEBUG_RENDERENGINE_BACKEND 属性不设，则默认是gles类型
30.     property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "gles");
31.     if (strcmp(prop, "gles") == 0) {
32.         ALOGD("RenderEngine GLES Backend");
33.         // 创建GLESRenderEngine对象
34.         return renderengine::gl::GLESRenderEngine::create(args);
35.     }
36.     ALOGE("UNKNOWN BackendType: %s, create GLES RenderEngine.", prop);
37.     return renderengine::gl::GLESRenderEngine::create(args);
38. }
40. 文件：frameworks/native/libs/renderengine/gl/GLESRenderEngine.cpp
42. std::unique_ptr<GLESRenderEngine> GLESRenderEngine::create(const RenderEngineCreationArgs& args) {
43.     // initialize EGL for the default display
44.     // 获得EGLDisplay
45.     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
46.     if (!eglInitialize(display, nullptr, nullptr)) {
47.         LOG_ALWAYS_FATAL("failed to initialize EGL");
48.     }
49.      // 查询EGL版本信息
50.     const auto eglVersion = eglQueryStringImplementationANDROID(display, EGL_VERSION);
51.     if (!eglVersion) {
52.         checkGlError(__FUNCTION__, __LINE__);
53.         LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_VERSION) failed");
54.     }
55.     //查询EGL支持哪些拓展
56.     const auto eglExtensions = eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS);
57.     if (!eglExtensions) {
58.         checkGlError(__FUNCTION__, __LINE__);
59.         LOG_ALWAYS_FATAL("eglQueryStringImplementationANDROID(EGL_EXTENSIONS) failed");
60.     }
62.     //根据支持的拓展设置属性，目前来看所有的属性都为true
63.     GLExtensions& extensions = GLExtensions::getInstance();
64.     extensions.initWithEGLStrings(eglVersion, eglExtensions);
66.     // The code assumes that ES2 or later is available if this extension is
67.     // supported.
68.     EGLConfig config = EGL_NO_CONFIG;
69.     if (!extensions.hasNoConfigContext()) {
70.         config = chooseEglConfig(display, args.pixelFormat, /*logConfig*/ true);
71.     }
73.     bool useContextPriority =
74.             extensions.hasContextPriority() && args.contextPriority == ContextPriority::HIGH;
75.     EGLContext protectedContext = EGL_NO_CONTEXT;
76.     if (args.enableProtectedContext && extensions.hasProtectedContent()) {
77.         protectedContext = createEglContext(display, config, nullptr, useContextPriority,
78.                                             Protection::PROTECTED);
79.         ALOGE_IF(protectedContext == EGL_NO_CONTEXT, "Can't create protected context");
80.     }
81.     // 创建非protect的EglContext
82.     EGLContext ctxt = createEglContext(display, config, protectedContext, useContextPriority,
83.                                        Protection::UNPROTECTED);
84.     LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");
86.     EGLSurface dummy = EGL_NO_SURFACE;
87.      // 支持该属性，不走if逻辑
88.     if (!extensions.hasSurfacelessContext()) {
89.         dummy = createDummyEglPbufferSurface(display, config, args.pixelFormat,
90.                                              Protection::UNPROTECTED);
91.         LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");
92.     }
93.     // eglMakeCurrent 将 EGLDisplay和EglContext 绑定
94.     EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);
95.     LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");
96.     ...
97.     std::unique_ptr<GLESRenderEngine> engine;
98.     switch (version) {
99.         case GLES_VERSION_1_0:
100.         case GLES_VERSION_1_1:
101.             LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");
102.             break;
103.         case GLES_VERSION_2_0:
104.         case GLES_VERSION_3_0:
105.             // GLESRenderEngine 初始化
106.             engine = std::make_unique<GLESRenderEngine>(args, display, config, ctxt, dummy,
107.                                                         protectedContext, protectedDummy);
108.             break;
109.     }
110. ...
111. }
113. GLESRenderEngine::GLESRenderEngine(const RenderEngineCreationArgs& args, EGLDisplay display,
114.                                    EGLConfig config, EGLContext ctxt, EGLSurface dummy,
115.                                    EGLContext protectedContext, EGLSurface protectedDummy)
116.       : renderengine::impl::RenderEngine(args),
117.         mEGLDisplay(display),
118.         mEGLConfig(config),
119.         mEGLContext(ctxt),
120.         mDummySurface(dummy),
121.         mProtectedEGLContext(protectedContext),
122.         mProtectedDummySurface(protectedDummy),
123.         mVpWidth(0),
124.         mVpHeight(0),
125.         mFramebufferImageCacheSize(args.imageCacheSize),
126.         mUseColorManagement(args.useColorManagement) {
127.     // 查询可支持最大的纹理尺寸和视图大小
128.     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
129.     glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
130.     //像素数据按4字节对齐
131.     glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
132.     glPixelStorei(GL_PACK_ALIGNMENT, 4);
133.     ...
134.       // 色彩空间相关设置，遇到具体场景再分析
135.      if (mUseColorManagement) {
136.         const ColorSpace srgb(ColorSpace::sRGB());
137.         const ColorSpace displayP3(ColorSpace::DisplayP3());
138.         const ColorSpace bt2020(ColorSpace::BT2020());
140.         // no chromatic adaptation needed since all color spaces use D65 for their white points.
141.         mSrgbToXyz = mat4(srgb.getRGBtoXYZ());
142.         mDisplayP3ToXyz = mat4(displayP3.getRGBtoXYZ());
143.         mBt2020ToXyz = mat4(bt2020.getRGBtoXYZ());
144.         mXyzToSrgb = mat4(srgb.getXYZtoRGB());
145.         mXyzToDisplayP3 = mat4(displayP3.getXYZtoRGB());
146.         mXyzToBt2020 = mat4(bt2020.getXYZtoRGB());
148.         // Compute sRGB to Display P3 and BT2020 transform matrix.
149.         // NOTE: For now, we are limiting output wide color space support to
150.         // Display-P3 and BT2020 only.
151.         mSrgbToDisplayP3 = mXyzToDisplayP3 * mSrgbToXyz;
152.         mSrgbToBt2020 = mXyzToBt2020 * mSrgbToXyz;
154.         // Compute Display P3 to sRGB and BT2020 transform matrix.
155.         mDisplayP3ToSrgb = mXyzToSrgb * mDisplayP3ToXyz;
156.         mDisplayP3ToBt2020 = mXyzToBt2020 * mDisplayP3ToXyz;
158.         // Compute BT2020 to sRGB and Display P3 transform matrix
159.         mBt2020ToSrgb = mXyzToSrgb * mBt2020ToXyz;
160.         mBt2020ToDisplayP3 = mXyzToDisplayP3 * mBt2020ToXyz;
161.     }
162.     ...
163.      // 涉及到有模糊的layer，具体场景再分析
164.     if (args.supportsBackgroundBlur) {
165.         mBlurFilter = new BlurFilter(*this);
166.         checkErrors("BlurFilter creation");
167.     }
168.     // 创建ImageManager 线程，这个线程是管理输入的mEGLImage
169.     mImageManager = std::make_unique<ImageManager>(this);
170.     mImageManager->initThread();
171.     //创建GLFramebuffer
172.     mDrawingBuffer = createFramebuffer();
173.     ...
174. }
175.    
176. 文件：frameworks/native/libs/renderengine/gl/GLFramebuffer.cpp
178. // 创建了一个纹理ID mTextureName，和 fb ID mFramebufferName
179. GLFramebuffer::GLFramebuffer(GLESRenderEngine& engine)
180.       : mEngine(engine), mEGLDisplay(engine.getEGLDisplay()), mEGLImage(EGL_NO_IMAGE_KHR) {
181.     glGenTextures(1, &mTextureName);
182.     glGenFramebuffers(1, &mFramebufferName);
183. }

复制代码

通过上述的代码我们可以看到在启动之初就搭建好了EGL环境，并将当火线程与context绑定，为背面利用gl下令做好准备，然后创建了ImageManager 线程，这个线程是管理输入Buffer的EGLImage，然后创建了GLFrameBuffer，用来操作输出的buffer。
并且有一点我们必要特别注意，在在创建BufferQueueLayer时就已经对各个layer创建了纹理ID，为背面走GPU合成做准备。如下:

1. 文件：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
3. status_t SurfaceFlinger::createBufferQueueLayer(const sp<Client>& client, std::string name,
4.                                                 uint32_t w, uint32_t h, uint32_t flags,
5.                                                 LayerMetadata metadata, PixelFormat& format,
6.                                                 sp<IBinder>* handle,
7.                                                 sp<IGraphicBufferProducer>* gbp,
8.                                                 sp<Layer>* outLayer) {
9.     ...
10.    
11.     args.textureName = getNewTexture();
12.     ...
13. }
15. uint32_t SurfaceFlinger::getNewTexture() {
16.     {
17.         std::lock_guard lock(mTexturePoolMutex);
18.         if (!mTexturePool.empty()) {
19.             uint32_t name = mTexturePool.back();
20.             mTexturePool.pop_back();
21.             ATRACE_INT("TexturePoolSize", mTexturePool.size());
22.             return name;
23.         }
25.         // The pool was too small, so increase it for the future
26.         ++mTexturePoolSize;
27.     }
29.     // The pool was empty, so we need to get a new texture name directly using a
30.     // blocking call to the main thread
31.     // 每个layer，调用glGenTextures 生成纹理ID，schedule运行在sf主线程
32.     return schedule([this] {
33.                uint32_t name = 0;
34.                getRenderEngine().genTextures(1, &name);
35.                return name;
36.            })
37.             .get();
38. }

复制代码

---

三.创建与初始化FramebufferSurface的流程

FramebufferSurface的初始化逻辑必要从SurfaceFlinger的初始化谈起，我们知道在SurfaceFlinger::init()中会去注册HWC的回调函数mCompositionEngine->getHwComposer().setCallback(this)，当第一次注册callback时，onComposerHalHotplug()会立即在调用registerCallback()的线程中被调用，并跨进程回调到SurfaceFlinger:nComposerHalHotplug。然后一腾飞奔：

在SurfaceFlinger::processDisplayAdded这个方法中去创建了BufferQueue和FramebufferSurface，简单理解为连接上了表现屏幕(Display)，那就要给准备一个BufferQueue，以便GPU合成UI等图层时，可以向这个BufferQueue索要GraphicBuffer来存储合成后的图形数据，再呈现到屏幕上去（我的傻瓜式理解）
摘取关键代码如下：

1. [/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp]
2. void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
3.                                          const DisplayDeviceState& state) {
4.     ......
5.     sp<compositionengine::DisplaySurface> displaySurface;
6.     sp<IGraphicBufferProducer> producer;
7.     // 创建BufferQueue,获取到生产者和消费者，而且消费者不是SurfaceFlinger哦
8.     sp<IGraphicBufferProducer> bqProducer;
9.     sp<IGraphicBufferConsumer> bqConsumer;
10.     getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
11.     if (state.isVirtual()) { // 虚拟屏幕，不管它
12.         const auto displayId = VirtualDisplayId::tryCast(compositionDisplay->getId());
13.         LOG_FATAL_IF(!displayId);
14.         auto surface = sp<VirtualDisplaySurface>::make(getHwComposer(), *displayId, state.surface,
15.                                                        bqProducer, bqConsumer, state.displayName);
16.         displaySurface = surface;
17.         producer = std::move(surface);
18.     } else { // 看这个case
19.         ALOGE_IF(state.surface != nullptr,
20.                  "adding a supported display, but rendering "
21.                  "surface is provided (%p), ignoring it",
22.                  state.surface.get());
23.         const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
24.         LOG_FATAL_IF(!displayId);
25.         // 创建了FramebufferSurface对象，FramebufferSurface继承自compositionengine::DisplaySurface
26.         // FramebufferSurface是作为消费者的角色工作的，消费SF GPU合成后的图形数据
27.         displaySurface =
28.                 sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
29.                                              state.physical->activeMode->getSize(),
30.                                              ui::Size(maxGraphicsWidth, maxGraphicsHeight));
31.         producer = bqProducer;
32.     }
33.     LOG_FATAL_IF(!displaySurface);
34.     // 创建DisplayDevice，其又去创建RenderSurface，作为生产者角色工作，displaySurface就是FramebufferSurface对象
35.     const auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay),
36.                                                        state, displaySurface, producer);
37.     mDisplays.emplace(displayToken, display);
38.     ......
39. }

复制代码

瞅一瞅 FramebufferSuraface的构造函数，没啥复杂的，就是一些设置，初始化一些成员。

1. FramebufferSurface::FramebufferSurface(HWComposer& hwc, PhysicalDisplayId displayId,
2.                                        const sp<IGraphicBufferConsumer>& consumer,
3.                                        const ui::Size& size, const ui::Size& maxSize)
4.       : ConsumerBase(consumer),
5.         mDisplayId(displayId),
6.         mMaxSize(maxSize),
7.         mCurrentBufferSlot(-1),
8.         mCurrentBuffer(),
9.         mCurrentFence(Fence::NO_FENCE),
10.         mHwc(hwc),
11.         mHasPendingRelease(false),
12.         mPreviousBufferSlot(BufferQueue::INVALID_BUFFER_SLOT),
13.         mPreviousBuffer() {
14.     ALOGV("Creating for display %s", to_string(displayId).c_str());
15.     mName = "FramebufferSurface";
16.     mConsumer->setConsumerName(mName); // 设置消费者的名字是 "FramebufferSurface"
17.     mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_FB |  // 设置usage
18.                                        GRALLOC_USAGE_HW_RENDER |
19.                                        GRALLOC_USAGE_HW_COMPOSER);
20.     const auto limitedSize = limitSize(size);
21.     mConsumer->setDefaultBufferSize(limitedSize.width, limitedSize.height); // 设置buffer 大小
22.     mConsumer->setMaxAcquiredBufferCount(
23.             SurfaceFlinger::maxFrameBufferAcquiredBuffers - 1);
24. }

复制代码

再进到SurfaceFlinger::setupNewDisplayDeviceInternal中看看相关的逻辑：

1. [/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp]
2. sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
3.         const wp<IBinder>& displayToken,
4.         std::shared_ptr<compositionengine::Display> compositionDisplay,
5.         const DisplayDeviceState& state,
6.         const sp<compositionengine::DisplaySurface>& displaySurface,
7.         const sp<IGraphicBufferProducer>& producer) {
8.     ......
9.     creationArgs.displaySurface = displaySurface;  // displaySurface就是FramebufferSurface对象   
10.     // producer是前面processDisplayAdded中创建的
11.     auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
12.     auto nativeWindow = nativeWindowSurface->getNativeWindow();
13.     creationArgs.nativeWindow = nativeWindow;
14.     ....
15.     // 前面一大坨代码是在初始话creationArgs，这些参数用来创建DisplayDevice
16.     // creationArgs.nativeWindow会把前面创建的producer关联到了DisplayDevice
17.     sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);
18.     // 后面一大坨，对display进行了些设置
19.     if (!state.isVirtual()) {
20.         display->setActiveMode(state.physical->activeMode->getId());
21.         display->setDeviceProductInfo(state.physical->deviceProductInfo);
22.     }
23.     ....
24. }

复制代码

接下来就是 DisplayDevice 的构造函数了，里面主要是创建了RenderSurface对象，然后对其举行初始化

1. [/frameworks/native/services/surfaceflinger/DisplayDevice.cpp]
2. DisplayDevice::DisplayDevice(DisplayDeviceCreationArgs& args)
3.       : mFlinger(args.flinger),
4.         mHwComposer(args.hwComposer),
5.         mDisplayToken(args.displayToken),
6.         mSequenceId(args.sequenceId),
7.         mConnectionType(args.connectionType),
8.         mCompositionDisplay{args.compositionDisplay},
9.         mPhysicalOrientation(args.physicalOrientation),
10.         mSupportedModes(std::move(args.supportedModes)),
11.         mIsPrimary(args.isPrimary) {
12.     mCompositionDisplay->editState().isSecure = args.isSecure;
13.     // 创建RenderSurface，args.nativeWindow 即为producer,指向生产者
14.     mCompositionDisplay->createRenderSurface(
15.             compositionengine::RenderSurfaceCreationArgsBuilder()
16.                     .setDisplayWidth(ANativeWindow_getWidth(args.nativeWindow.get()))
17.                     .setDisplayHeight(ANativeWindow_getHeight(args.nativeWindow.get()))
18.                     .setNativeWindow(std::move(args.nativeWindow))
19.                     .setDisplaySurface(std::move(args.displaySurface)) // displaySurface就是FramebufferSurface对象
20.                     .setMaxTextureCacheSize(
21.                             static_cast<size_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers))
22.                     .build());
23.     if (!mFlinger->mDisableClientCompositionCache &&
24.         SurfaceFlinger::maxFrameBufferAcquiredBuffers > 0) {
25.         mCompositionDisplay->createClientCompositionCache(
26.                 static_cast<uint32_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers));
27.     }
28.     mCompositionDisplay->createDisplayColorProfile(
29.             compositionengine::DisplayColorProfileCreationArgs{args.hasWideColorGamut,
30.                                                                std::move(args.hdrCapabilities),
31.                                                                args.supportedPerFrameMetadata,
32.                                                                args.hwcColorModes});
33.     if (!mCompositionDisplay->isValid()) {
34.         ALOGE("Composition Display did not validate!");
35.     }
36.     // 初始化RenderSurface
37.     mCompositionDisplay->getRenderSurface()->initialize();
38.     setPowerMode(args.initialPowerMode);
39.     // initialize the display orientation transform.
40.     setProjection(ui::ROTATION_0, Rect::INVALID_RECT, Rect::INVALID_RECT);
41. }

复制代码

RenderSurface作为生产者的角色工作，构造函数如下，留意启成员displaySurface就是SurfaceFlinger中创建的FramebufferSurface对象
也就是 作为生产者的RenderSurface中持有 消耗者的引用 displaySurface，可以呼叫FramebufferSurface的方法。

1. [ /frameworks/native/services/surfaceflinger/CompositionEngine/src/RenderSurface.cpp]
2. RenderSurface::RenderSurface(const CompositionEngine& compositionEngine, Display& display,
3.                              const RenderSurfaceCreationArgs& args)
4.       : mCompositionEngine(compositionEngine),
5.         mDisplay(display),
6.         mNativeWindow(args.nativeWindow),
7.         mDisplaySurface(args.displaySurface),  // displaySurface就是FramebufferSurface对象
8.         mSize(args.displayWidth, args.displayHeight),
9.         mMaxTextureCacheSize(args.maxTextureCacheSize) {
10.     LOG_ALWAYS_FATAL_IF(!mNativeWindow);
11. }

复制代码

我们看看他的RenderSurface::initialize()方法

1. [/frameworks/native/services/surfaceflinger/CompositionEngine/src/RenderSurface.cpp]
2. void RenderSurface::initialize() {
3.     ANativeWindow* const window = mNativeWindow.get();
4.     int status = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
5.     ALOGE_IF(status != NO_ERROR, "Unable to connect BQ producer: %d", status);
6.     status = native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
7.     ALOGE_IF(status != NO_ERROR, "Unable to set BQ format to RGBA888: %d", status);
8.     status = native_window_set_usage(window, DEFAULT_USAGE);
9.     ALOGE_IF(status != NO_ERROR, "Unable to set BQ usage bits for GPU rendering: %d", status);
10. }

复制代码

上述方法也很简单，就是作为producer去和BufferQueue创建connect，并设置format为RGBA_8888，设置usage为GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE
为了验证上述分析的流程是精确的，我在BufferQueueProducer::connect中加log来打印调用栈的信息，如下，是不是和分析的一样啊

1. 11-13 00:52:58.497   227   227 D BufferQueueProducer: connect[1303] /vendor/bin/hw/android.hardware.graphics.composer@2.4-service start
2. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#00 pc 0005e77f  /system/lib/libgui.so (android::BufferQueueProducer::connect(android::sp<android::IProducerListener> const&, int, bool, android::IGraphicBufferProducer::QueueBufferOutput*)+1282)
3. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#01 pc 000a276b  /system/lib/libgui.so (android::Surface::connect(int, android::sp<android::IProducerListener> const&, bool)+138)
4. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#02 pc 0009de41  /system/lib/libgui.so (android::Surface::hook_perform(ANativeWindow*, int, ...)+128)
5. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#03 pc 00121b1d  /system/bin/surfaceflinger (android::compositionengine::impl::RenderSurface::initialize()+12)
6. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#04 pc 00083cc5  /system/bin/surfaceflinger (android::DisplayDevice::DisplayDevice(android::DisplayDeviceCreationArgs&)+1168)
7. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#05 pc 000d8bed  /system/bin/surfaceflinger (android::SurfaceFlinger::processDisplayAdded(android::wp<android::IBinder> const&, android::DisplayDeviceState const&)+4440)
8. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#06 pc 000d0db5  /system/bin/surfaceflinger (android::SurfaceFlinger::processDisplayChangesLocked()+2436)
9. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#07 pc 000cef6b  /system/bin/surfaceflinger (android::SurfaceFlinger::processDisplayHotplugEventsLocked()+6422)
10. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#08 pc 000d2c7f  /system/bin/surfaceflinger (android::SurfaceFlinger::onComposerHalHotplug(unsigned long long, android::hardware::graphics::composer::V2_1::IComposerCallback::Connection)+334)
11. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#09 pc 0009afab  /system/bin/surfaceflinger (_ZN7android12_GLOBAL__N_122ComposerCallbackBridge9onHotplugEyNS_8hardware8graphics8composer4V2_117IComposerCallback10ConnectionE$d689f7ac1c60e4abeed02ca92a51bdcd+20)
12. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#10 pc 0001bb97  /system/lib/android.hardware.graphics.composer@2.1.so (android::hardware::graphics::composer::V2_1::BnHwComposerCallback::_hidl_onHotplug(android::hidl::base::V1_0::BnHwBase*, android::hardware::Parcel const&, android::hardware::Parcel*, std::__1::function<void (android::hardware::Parcel&)>)+166)
13. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#11 pc 000275e9  /system/lib/android.hardware.graphics.composer@2.4.so (android::hardware::graphics::composer::V2_4::BnHwComposerCallback::onTransact(unsigned int, android::hardware::Parcel const&, android::hardware::Parcel*, unsigned int, std::__1::function<void (android::hardware::Parcel&)>)+228)
14. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#12 pc 00054779  /system/lib/libhidlbase.so (android::hardware::BHwBinder::transact(unsigned int, android::hardware::Parcel const&, android::hardware::Parcel*, unsigned int, std::__1::function<void (android::hardware::Parcel&)>)+96)
15. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#13 pc 0004fc67  /system/lib/libhidlbase.so (android::hardware::IPCThreadState::transact(int, unsigned int, android::hardware::Parcel const&, android::hardware::Parcel*, unsigned int)+2174)
16. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#14 pc 0004f2e5  /system/lib/libhidlbase.so (android::hardware::BpHwBinder::transact(unsigned int, android::hardware::Parcel const&, android::hardware::Parcel*, unsigned int, std::__1::function<void (android::hardware::Parcel&)>)+36)
17. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#15 pc 0002bdf1  /system/lib/android.hardware.graphics.composer@2.4.so (android::hardware::graphics::composer::V2_4::BpHwComposerClient::_hidl_registerCallback_2_4(android::hardware::IInterface*, android::hardware::details::HidlInstrumentor*, android::sp<android::hardware::graphics::composer::V2_4::IComposerCallback> const&)+296)
18. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#16 pc 0002ed8d  /system/lib/android.hardware.graphics.composer@2.4.so (android::hardware::graphics::composer::V2_4::BpHwComposerClient::registerCallback_2_4(android::sp<android::hardware::graphics::composer::V2_4::IComposerCallback> const&)+34)
19. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#17 pc 00085627  /system/bin/surfaceflinger (android::Hwc2::impl::Composer::registerCallback(android::sp<android::hardware::graphics::composer::V2_4::IComposerCallback> const&)+98)
20. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#18 pc 00092d63  /system/bin/surfaceflinger (android::impl::HWComposer::setCallback(android::HWC2::ComposerCallback*)+2206)
21. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#19 pc 000cd35b  /system/bin/surfaceflinger (android::SurfaceFlinger::init()+438)
22. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#20 pc 000feb03  /system/bin/surfaceflinger (main+862)
23. 11-13 00:52:58.581   227   227 E BufferQueueProducer: stackdump:#21 pc 0003253b  /apex/com.android.runtime/lib/bionic/libc.so (__libc_init+54)
24. 11-13 00:52:58.582   227   227 D BufferQueueProducer: connect[1307] /vendor/bin/hw/android.hardware.graphics.composer@2.4-service end

复制代码

这里有一个小细节要留意下，由于SurfaceFlinger:nComposerHalHotplug是HWC回调过来的，以是代码实行是在android.hardware.graphics.composer@2.4-service这个进程中的。
BufferQueueProducer::connect中记载的mConnectedPid就是composer service的PID

1. [ /frameworks/native/libs/gui/BufferQueueProducer.cpp]
2. mCore->mConnectedPid = BufferQueueThreadState::getCallingPid();

复制代码

在dump BufferQueue的信息时，根据PID获取的 producer name 也就是 android.hardware.graphics.composer@2.4-service

1. [/frameworks/native/libs/gui/BufferQueueCore.cpp]
2. void BufferQueueCore::dumpState(const String8& prefix, String8* outResult) const {
3.     ...
4.     getProcessName(mConnectedPid, producerProcName);
5.     getProcessName(pid, consumerProcName);
6.     ....
7. }

复制代码

如下是我的平台dumpsys SurfaceFlinger的信息打印出来的Composition RenderSurface State的信息，看看是不是和代码的设置都有对应起来：

1. mConsumerName=FramebufferSurface
3. producer=[342:/vendor/bin/hw/android.hardware.graphics.composer@2.4-service]
5. consumer=[223:/system/bin/surfaceflinger])

复制代码

format/size/usage也都可以对应到代码的设置

1.    Composition RenderSurface State:
2.    size=[1920 1080] ANativeWindow=0xef2c3278 (format 1) flips=605
3.   FramebufferSurface: dataspace: Default(0)
4.    mAbandoned=0
5.    - BufferQueue mMaxAcquiredBufferCount=2 mMaxDequeuedBufferCount=1
6.      mDequeueBufferCannotBlock=0 mAsyncMode=0
7.      mQueueBufferCanDrop=0 mLegacyBufferDrop=1
8.      default-size=[1920x1080] default-format=1      transform-hint=00 frame-counter=580
9.      mTransformHintInUse=00 mAutoPrerotation=0
10.    FIFO(0):
11.    (mConsumerName=FramebufferSurface, mConnectedApi=1, mConsumerUsageBits=6656, mId=df00000000, producer=[342:/vendor/bin/hw/android.hardware.graphics.composer@2.4-service], consumer=[223:/system/bin/surfaceflinger])
12.    Slots:
13.     >[01:0xeec82110] state=ACQUIRED 0xef4429c0 frame=2 [1920x1080:1920,  1]
14.     >[02:0xeec806f0] state=ACQUIRED 0xef443100 frame=580 [1920x1080:1920,  1]
15.      [00:0xeec81f00] state=FREE     0xef440580 frame=579 [1920x1080:1920,  1]

复制代码

---

四.关于RenderSurface和FramebufferSurface小结

上述内容中出现的一些字眼，不禁令人”瞎想连篇“
SurfaceFlinger创建了BufferQueue ==> Producer & Consumer
创建了RenderSurface作为生产者，它持有Producer
创建了FramebufferSurface作为消耗者，它持有Consumer
前面分析BufferQueue的工作原理时，有讲过：
生产者不停的dequeueBuffer & queueBuffer ; 而消耗者不停的acquireBuffer & releaseBuffer ,这样图像缓存就在 生产者 – BufferQueue – 消耗者 间流转起来了。
看看作为生产者的RenderSurface中方法：

1. [/frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/RenderSurface.h]
2. /**
3. * Encapsulates everything for composing to a render surface with RenderEngine
4. */
5. class RenderSurface {
6.     ....
7.     // Allocates a buffer as scratch space for GPU composition
8.     virtual std::shared_ptr<renderengine::ExternalTexture> dequeueBuffer(
9.             base::unique_fd* bufferFence) = 0;
10.     // Queues the drawn buffer for consumption by HWC. readyFence is the fence
11.     // which will fire when the buffer is ready for consumption.
12.     virtual void queueBuffer(base::unique_fd readyFence) = 0;
13.     ...
14. };

复制代码

熟悉的味道：
dequeueBuffer : 分配一个缓冲区作为GPU合成的暂存空间
queueBuffer : 入队列已绘制好的图形缓存供HWC利用
同样如果去检察作为消耗者的FramebufferSurface也会看到acquireBuffer & releaseBuffer的调用，如下：

1. [/frameworks/native/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp]
2. status_t FramebufferSurface::nextBuffer(uint32_t& outSlot,
3.         sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence,
4.         Dataspace& outDataspace) {
5.     Mutex::Autolock lock(mMutex);
6.     BufferItem item;
7.     status_t err = acquireBufferLocked(&item, 0); // 获取待显示的buffer
8.     ...
9.     status_t result = mHwc.setClientTarget(mDisplayId, outSlot, outFence, outBuffer, outDataspace); // 传递给HWC进一步处理显示
10.     return NO_ERROR;
11. }

复制代码

以是，末了我们大概会有这样一种逻辑处置惩罚流程：

• 当必要GPU合成时，会通过生产者RenderSurface::dequeueBuffer请求一块图形缓存，然后GPU就合成/画图，把数据保存到这块图形缓存中，通过RenderSurface::queueBuffer提交这块缓存
  
• 调用mDisplaySurface->advanceFrame()通知消耗者来消耗:
  
  1. FramebufferSurface::advanceFrame ==>FramebufferSurface::nextBuffer ==> acquireBufferLocked

  复制代码
• 去请求可用的图形缓存，这个buffer中存储有GPU合成的结果，然后通过setClientTarget把这个buffer传递给HWC做处置惩罚表现。
  

---

五.SF处置惩罚GPU合成流程分析

还记得我们前面分析到的Output::prepareFrame吗，其如果存在GPU合成，会实行如下的相关逻辑:

1. Output::prepareFrame()
2.     Display::chooseCompositionStrategy
3.         Output::chooseCompositionStrategy()
4.         hwc.getDeviceCompositionChanges
5.         
6.         
7. status_t HWComposer::getDeviceCompositionChanges(
8.         DisplayId displayId, bool frameUsesClientComposition,
9.         std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
10.    
11.     ...
12.     if (!frameUsesClientComposition) {
13.         sp<Fence> outPresentFence;
14.         uint32_t state = UINT32_MAX;
15.         /**
16.          * @brief
17.          * 如果所有的layer都能走device合成
18.          * 则在hwc里面直接present，若有不支持
19.          * device合成的情况，则走GPU合成，会走validate逻辑
20.          */
21.         error = hwcDisplay->presentOrValidate(&numTypes, &numRequests, &outPresentFence , &state);
22.         if (!hasChangesError(error)) {
23.             RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
24.         }
25.         if (state == 1) { //Present Succeeded.
26.             //present成功，数据直接提交给了hwc
27.             std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
28.             error = hwcDisplay->getReleaseFences(&releaseFences);
29.             displayData.releaseFences = std::move(releaseFences);
30.             displayData.lastPresentFence = outPresentFence;
31.             displayData.validateWasSkipped = true;
32.             displayData.presentError = error;
33.             return NO_ERROR;
34.         }
35.         // Present failed but Validate ran.
36.     } else {
37.         error = hwcDisplay->validate(&numTypes, &numRequests);
38.     }
39.     ALOGV("SkipValidate failed, Falling back to SLOW validate/present");
40.     if (!hasChangesError(error)) {
41.         RETURN_IF_HWC_ERROR_FOR("validate", error, displayId, BAD_INDEX);
42.     }
44.     android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
45.     changedTypes.reserve(numTypes);
46.     error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
47.     RETURN_IF_HWC_ERROR_FOR("getChangedCompositionTypes", error, displayId, BAD_INDEX);
49.     auto displayRequests = static_cast<hal::DisplayRequest>(0);
50.     android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
51.     layerRequests.reserve(numRequests);
52.     error = hwcDisplay->getRequests(&displayRequests, &layerRequests);
53.     RETURN_IF_HWC_ERROR_FOR("getRequests", error, displayId, BAD_INDEX);
55.     DeviceRequestedChanges::ClientTargetProperty clientTargetProperty;
56.     error = hwcDisplay->getClientTargetProperty(&clientTargetProperty);
58.     outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes), std::move(displayRequests),
59.                                                std::move(layerRequests),
60.                                                std::move(clientTargetProperty)});
61.     //接收hwc反馈回来的，主要是支持device和gpu合成的情况
62.     error = hwcDisplay->acceptChanges();
63.     RETURN_IF_HWC_ERROR_FOR("acceptChanges", error, displayId, BAD_INDEX);
65.     return NO_ERROR;
66. }

复制代码

前面我们也分析到了Output::finishFrame，此中的composeSurfaces是GPU合成的核心：

1. void Output::finishFrame(const compositionengine::CompositionRefreshArgs& refreshArgs) {
2.     ...
3.     auto optReadyFence = composeSurfaces(Region::INVALID_REGION, refreshArgs);
4.     if (!optReadyFence) {
5.         return;
6.     }
8.     // swap buffers (presentation)
9.     mRenderSurface->queueBuffer(std::move(*optReadyFence));
10. }

复制代码

5.1 Output::composeSurfaces

这里我们先重点来看composeSurfaces这个函数，看下走GPU合成的逻辑:

1. 文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp
3. std::optional<base::unique_fd> Output::composeSurfaces(
4.         const Region& debugRegion, const compositionengine::CompositionRefreshArgs& refreshArgs) {
6. ...
7.     base::unique_fd fd;
8.     sp<GraphicBuffer> buf;
10.     // If we aren't doing client composition on this output, but do have a
11.     // flipClientTarget request for this frame on this output, we still need to
12.     // dequeue a buffer.
13.     if (hasClientComposition || outputState.flipClientTarget) {
14.         // dequeueBuffer一块Buffer，这块Buffer作为输出
15.         buf = mRenderSurface->dequeueBuffer(&fd);
16.         if (buf == nullptr) {
17.             ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
18.                   "client composition for this frame",
19.                   mName.c_str());
20.             return {};
21.         }
22.     }
24.     base::unique_fd readyFence;
25.     // GPU合成时不返回
26.     if (!hasClientComposition) {
27.         setExpensiveRenderingExpected(false);
28.         return readyFence;
29.     }
31.     ALOGV("hasClientComposition");
33.      // 设置clientCompositionDisplay，这个是display相关参数
35.     renderengine::DisplaySettings clientCompositionDisplay;
36.     clientCompositionDisplay.physicalDisplay = outputState.destinationClip;
37.     clientCompositionDisplay.clip = outputState.sourceClip;
38.     clientCompositionDisplay.orientation = outputState.orientation;
39.     clientCompositionDisplay.outputDataspace = mDisplayColorProfile->hasWideColorGamut()
40.        ? outputState.dataspace
41.             : ui::Dataspace::UNKNOWN;
42.     clientCompositionDisplay.maxLuminance =
43.             mDisplayColorProfile->getHdrCapabilities().getDesiredMaxLuminance();
44.     // Compute the global color transform matrix.
45.     if (!outputState.usesDeviceComposition && !getSkipColorTransform()) {
46.         clientCompositionDisplay.colorTransform = outputState.colorTransformMatrix;
47.     }
49.     // Note: Updated by generateClientCompositionRequests
50.     clientCompositionDisplay.clearRegion = Region::INVALID_REGION;
52.     // Generate the client composition requests for the layers on this output.
53.     // 设置clientCompositionLayers ， 这个是layer的相关参数
54.     std::vector<LayerFE::LayerSettings> clientCompositionLayers =
55.             generateClientCompositionRequests(supportsProtectedContent,
56.                                               clientCompositionDisplay.clearRegion,
57.                                               clientCompositionDisplay.outputDataspace);
58.     appendRegionFlashRequests(debugRegion, clientCompositionLayers);
60.     // Check if the client composition requests were rendered into the provided graphic buffer. If
61.     // so, we can reuse the buffer and avoid client composition.
63.     // 如果cache里有相同的Buffer，则不需要重复draw一次
64.     if (mClientCompositionRequestCache) {
65.         if (mClientCompositionRequestCache->exists(buf->getId(), clientCompositionDisplay,
66.                                                    clientCompositionLayers)) {
67.             outputCompositionState.reusedClientComposition = true;
68.             setExpensiveRenderingExpected(false);
69.             return readyFence;
70.         }
71.         mClientCompositionRequestCache->add(buf->getId(), clientCompositionDisplay,
72.                                             clientCompositionLayers);
73.     }
74.     // We boost GPU frequency here because there will be color spaces conversion
75.     // or complex GPU shaders and it's expensive. We boost the GPU frequency so that
76.     // GPU composition can finish in time. We must reset GPU frequency afterwards,
77.     // because high frequency consumes extra battery.
79.     // 针对有模糊layer和有复杂颜色空间转换的场景，给GPU进行提频
80.     const bool expensiveBlurs =
81.             refreshArgs.blursAreExpensive && mLayerRequestingBackgroundBlur != nullptr;
82.     const bool expensiveRenderingExpected =
83.             clientCompositionDisplay.outputDataspace == ui::Dataspace::DISPLAY_P3 || expensiveBlurs;
84.     if (expensiveRenderingExpected) {
85.         setExpensiveRenderingExpected(true);
86.     }
88.     // 将clientCompositionLayers 里面的内容插入到clientCompositionLayerPointers，实质内容相同
89.     std::vector<const renderengine::LayerSettings*> clientCompositionLayerPointers;
90.     clientCompositionLayerPointers.reserve(clientCompositionLayers.size());
91.     std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
92.                    std::back_inserter(clientCompositionLayerPointers),
93.                    [](LayerFE::LayerSettings& settings) -> renderengine::LayerSettings* {
94.                        return &settings;
95.                    });
97.     const nsecs_t renderEngineStart = systemTime();
98.     // GPU合成，主要逻辑在drawLayers里面
99.     status_t status =
100.             renderEngine.drawLayers(clientCompositionDisplay, clientCompositionLayerPointers,
101.                                     buf->getNativeBuffer(), /*useFramebufferCache=*/true,
102.                                     std::move(fd), &readyFence);
103.    ...
104. }
106. std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests(
107.         bool supportsProtectedContent, Region& clearRegion, ui::Dataspace outputDataspace) {
108.     std::vector<LayerFE::LayerSettings> clientCompositionLayers;
109.     ALOGV("Rendering client layers");
111.     const auto& outputState = getState();
112.     const Region viewportRegion(outputState.viewport);
113.     const bool useIdentityTransform = false;
114.     bool firstLayer = true;
115.     // Used when a layer clears part of the buffer.
116.     Region dummyRegion;
118.     for (auto* layer : getOutputLayersOrderedByZ()) {
119.         const auto& layerState = layer->getState();
120.         const auto* layerFEState = layer->getLayerFE().getCompositionState();
121.         auto& layerFE = layer->getLayerFE();
123.         const Region clip(viewportRegion.intersect(layerState.visibleRegion));
124.         ALOGV("Layer: %s", layerFE.getDebugName());
125.         if (clip.isEmpty()) {
126.             ALOGV("  Skipping for empty clip");
127.             firstLayer = false;
128.             continue;
129.         }
131.         const bool clientComposition = layer->requiresClientComposition();
133.         // We clear the client target for non-client composed layers if
134.         // requested by the HWC. We skip this if the layer is not an opaque
135.         // rectangle, as by definition the layer must blend with whatever is
136.         // underneath. We also skip the first layer as the buffer target is
137.         // guaranteed to start out cleared.
138.         const bool clearClientComposition =
139.                 layerState.clearClientTarget && layerFEState->isOpaque && !firstLayer;
141.         ALOGV("  Composition type: client %d clear %d", clientComposition, clearClientComposition);
143.         // If the layer casts a shadow but the content casting the shadow is occluded, skip
144.         // composing the non-shadow content and only draw the shadows.
145.         const bool realContentIsVisible = clientComposition &&
146.                 !layerState.visibleRegion.subtract(layerState.shadowRegion).isEmpty();
148.         if (clientComposition || clearClientComposition) {
149.             compositionengine::LayerFE::ClientCompositionTargetSettings targetSettings{
150.                     clip,
151.                     useIdentityTransform,
152.                     layer->needsFiltering() || outputState.needsFiltering,
153.                     outputState.isSecure,
154.                     supportsProtectedContent,
155.                     clientComposition ? clearRegion : dummyRegion,
156.                     outputState.viewport,
157.                     outputDataspace,
158.                     realContentIsVisible,
159.                     !clientComposition, /* clearContent  */
160.             };
161.             std::vector<LayerFE::LayerSettings> results =
162.                     layerFE.prepareClientCompositionList(targetSettings);
163.             if (realContentIsVisible && !results.empty()) {
164.                 layer->editState().clientCompositionTimestamp = systemTime();
165.             }
167.             clientCompositionLayers.insert(clientCompositionLayers.end(),
168.                                            std::make_move_iterator(results.begin()),
169.                                            std::make_move_iterator(results.end()));
170.             results.clear();
171.         }
173.         firstLayer = false;
174.     }
176.     return clientCompositionLayers;
177. }

复制代码

输入的Buffer是通过BufferLayer的prepareClientComposition 函数设到RenderEngine里面的，如下:

1. 文件：frameworks/native/services/surfaceflinger/BufferLayer.cpp
3. std::optional<compositionengine::LayerFE::LayerSettings> BufferLayer::prepareClientComposition(
4.         compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
5.     ATRACE_CALL();
7.     std::optional<compositionengine::LayerFE::LayerSettings> result =
8.             Layer::prepareClientComposition(targetSettings);
9.      ...
10.     const State& s(getDrawingState());
11.     // 应用queue过来的Buffer
12.     layer.source.buffer.buffer = mBufferInfo.mBuffer;
13.     layer.source.buffer.isOpaque = isOpaque(s);
14.      // acquire fence
15.     layer.source.buffer.fence = mBufferInfo.mFence;
16.     // 创建BufferQueueLayer时创建的texture ID
17.     layer.source.buffer.textureName = mTextureName;
18.     ...
19. }

复制代码

至此，SurfaceFlinger调到RenderEngine里面，SurfaceFlinger的display和outputlayer的信息传到了RenderEngine，这些都是GPU合成必要的信息，然后来看下drawLayers的流程。

5.2 GLESRenderEngine::drawLayers

1. 文件：frameworks/native/libs/renderengine/gl/GLESRenderEngine.cpp
3. status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,
4.                                       const std::vector<const LayerSettings*>& layers,
5.                                       ANativeWindowBuffer* const buffer,
6.                                       const bool useFramebufferCache, base::unique_fd&& bufferFence,
7.                                       base::unique_fd* drawFence) {
8.     ATRACE_CALL();
9.     if (layers.empty()) {
10.         ALOGV("Drawing empty layer stack");
11.         return NO_ERROR;
12.     }
13.      // 要等前一帧的release fence
14.     if (bufferFence.get() >= 0) {
15.         // Duplicate the fence for passing to waitFence.
16.         base::unique_fd bufferFenceDup(dup(bufferFence.get()));
17.         if (bufferFenceDup < 0 || !waitFence(std::move(bufferFenceDup))) {
18.             ATRACE_NAME("Waiting before draw");
19.             sync_wait(bufferFence.get(), -1);
20.         }
21.     }
23.     if (buffer == nullptr) {
24.         ALOGE("No output buffer provided. Aborting GPU composition.");
25.         return BAD_VALUE;
26.     }
28.     std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;
29.     ...
30.     if (blurLayersSize == 0) {
31.          // 将dequeue出来的buffer绑定到FB上面，作为fbo
32.         fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this, buffer, useFramebufferCache);
34. 文件：frameworks/native/libs/renderengine/gl/include/renderengine/RenderEngine.h
36. class BindNativeBufferAsFramebuffer {
37. public:
38.     BindNativeBufferAsFramebuffer(RenderEngine& engine, ANativeWindowBuffer* buffer,
39.                                   const bool useFramebufferCache)
40.           : mEngine(engine), mFramebuffer(mEngine.getFramebufferForDrawing()), mStatus(NO_ERROR) {
41.         mStatus = mFramebuffer->setNativeWindowBuffer(buffer, mEngine.isProtected(),
42.                                                       useFramebufferCache)
43.                 ? mEngine.bindFrameBuffer(mFramebuffer)
44.                 : NO_MEMORY;
45.     }
46.     ~BindNativeBufferAsFramebuffer() {
47.         mFramebuffer->setNativeWindowBuffer(nullptr, false, /*arbitrary*/ true);
48.         mEngine.unbindFrameBuffer(mFramebuffer);
49.     }
50.     status_t getStatus() const { return mStatus; }
52. private:
53.     RenderEngine& mEngine;
54.     Framebuffer* mFramebuffer;
55.     status_t mStatus;
56. };
58. 文件: frameworks/native/libs/renderengine/gl/GLFramebuffer.cpp
59. bool GLFramebuffer::setNativeWindowBuffer(ANativeWindowBuffer* nativeBuffer, bool isProtected,
60.                                           const bool useFramebufferCache) {
61.     ATRACE_CALL();
62.     if (mEGLImage != EGL_NO_IMAGE_KHR) {
63.         if (!usingFramebufferCache) {
64.             eglDestroyImageKHR(mEGLDisplay, mEGLImage);
65.             DEBUG_EGL_IMAGE_TRACKER_DESTROY();
66.         }
67.         mEGLImage = EGL_NO_IMAGE_KHR;
68.         mBufferWidth = 0;
69.         mBufferHeight = 0;
70.     }
72.     if (nativeBuffer) {
73.         mEGLImage = mEngine.createFramebufferImageIfNeeded(nativeBuffer, isProtected,
74.                                                            useFramebufferCache);
75.         if (mEGLImage == EGL_NO_IMAGE_KHR) {
76.             return false;
77.         }
78.         usingFramebufferCache = useFramebufferCache;
79.         mBufferWidth = nativeBuffer->width;
80.         mBufferHeight = nativeBuffer->height;
81.     }
82.     return true;
83. }
85. 文件:frameworks/native/libs/renderengine/gl/GLESRenderEngine.cpp
87. GLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer,
88.                                                              bool isProtected,
89.                                                              bool useFramebufferCache) {
90.     // buffer类型转换，将ANativeWindowBuffer 转换成 GraphicsBuffer
91.     sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer);
92.       //使用cache，如果有一样的image，就直接返回
93.      if (useFramebufferCache) {
94.         std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
95.         for (const auto& image : mFramebufferImageCache) {
96.             if (image.first == graphicBuffer->getId()) {
97.                 return image.second;
98.             }
99.         }
100.     }
101.     EGLint attributes[] = {
102.             isProtected ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
103.             isProtected ? EGL_TRUE : EGL_NONE,
104.             EGL_NONE,
105.     };
106.     // 将dequeue出来的buffer作为参数创建 EGLImage
107.     EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
108.                                           nativeBuffer, attributes);
109.     if (useFramebufferCache) {
110.         if (image != EGL_NO_IMAGE_KHR) {
111.             std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
112.             if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) {
113.                 EGLImageKHR expired = mFramebufferImageCache.front().second;
114.                 mFramebufferImageCache.pop_front();
115.                 eglDestroyImageKHR(mEGLDisplay, expired);
116.                 DEBUG_EGL_IMAGE_TRACKER_DESTROY();
117.             }
118.              // 把image放到mFramebufferImageCache 里面
119.             mFramebufferImageCache.push_back({graphicBuffer->getId(), image});
120.         }
121.     }
123.     if (image != EGL_NO_IMAGE_KHR) {
124.         DEBUG_EGL_IMAGE_TRACKER_CREATE();
125.     }
126.     return image;
127. }
129. status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {
130.     ATRACE_CALL();               
131.     GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);
132.     // 上一步创建的EGLImage
133.     EGLImageKHR eglImage = glFramebuffer->getEGLImage();
134.      // 创建RenderEngine 时就已经创建好的 texture id和 fb id
135.     uint32_t textureName = glFramebuffer->getTextureName();
136.     uint32_t framebufferName = glFramebuffer->getFramebufferName();
138.     // Bind the texture and turn our EGLImage into a texture
139.     // 绑定texture，后面的操作将作用在这上面
140.     glBindTexture(GL_TEXTURE_2D, textureName);
141.      // 根据EGLImage 创建一个 2D texture
142.     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)eglImage);
144.     // Bind the Framebuffer to render into
145.     glBindFramebuffer(GL_FRAMEBUFFER, framebufferName);
146.     // 将纹理附着在帧缓存上面，渲染到farmeBuffer
147.     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);
149.     uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
150.     ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d",
151.              glStatus);
153.     return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;
154. }

复制代码

起首将dequeue出来的buffer通过eglCreateImageKHR做成image，然后通过glEGLImageTargetTexture2DOES根据image创建一个2D的纹理，再通过glFramebufferTexture2D把纹理附着在帧缓存上面。setViewportAndProjection 设置视图和投影矩阵。

1. 文件：frameworks/native/libs/renderengine/gl/GLESRenderEngine.cpp
3. status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,
4.                                       const std::vector<const LayerSettings*>& layers,
5.                                       ANativeWindowBuffer* const buffer,
6.                                       const bool useFramebufferCache, base::unique_fd&& bufferFence,
7.                                       base::unique_fd* drawFence) {
8.          ...
9.          // 设置顶点和纹理坐标的size
10.          Mesh mesh = Mesh::Builder()
11.                         .setPrimitive(Mesh::TRIANGLE_FAN)
12.                         .setVertices(4 /* count */, 2 /* size */)
13.                         .setTexCoords(2 /* size */)
14.                         .setCropCoords(2 /* size */)
15.                         .build();
16.          for (auto const layer : layers) {
17.           //遍历outputlayer
18.              ...
19.           //获取layer的大小
20.         const FloatRect bounds = layer->geometry.boundaries;
21.         Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
22.         // 设置顶点的坐标，逆时针方向
23.         position[0] = vec2(bounds.left, bounds.top);
24.         position[1] = vec2(bounds.left, bounds.bottom);
25.         position[2] = vec2(bounds.right, bounds.bottom);
26.         position[3] = vec2(bounds.right, bounds.top);
27.          //设置crop的坐标
28.         setupLayerCropping(*layer, mesh);
29.         // 设置颜色矩阵
30.         setColorTransform(display.colorTransform * layer->colorTransform);
31.         ...
32.         // Buffer相关设置
33.         if (layer->source.buffer.buffer != nullptr) {
34.             disableTexture = false;
35.             isOpaque = layer->source.buffer.isOpaque;
36.              // layer的buffer，理解为输入的buffer
37.             sp<GraphicBuffer> gBuf = layer->source.buffer.buffer;
38.             // textureName是创建BufferQueuelayer时生成的，用来标识这个layer，
39.             // fence是acquire fence
40.             bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,
41.                                       layer->source.buffer.fence);
43.             ...
44.             // 设置纹理坐标，也是逆时针
45.             renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());
46.             texCoords[0] = vec2(0.0, 0.0);
47.             texCoords[1] = vec2(0.0, 1.0);
48.             texCoords[2] = vec2(1.0, 1.0);
49.             texCoords[3] = vec2(1.0, 0.0);
50.            // 设置纹理的参数，glTexParameteri
51.             setupLayerTexturing(texture);
52.         }
55. status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName,
56.                                                      const sp<GraphicBuffer>& buffer,
57.                                                      const sp<Fence>& bufferFence) {
58.     if (buffer == nullptr) {
59.         return BAD_VALUE;
60.     }
62.     ATRACE_CALL();
64.     bool found = false;
65.     {
66.         // 在ImageCache里面找有没有相同的buffer
67.         std::lock_guard<std::mutex> lock(mRenderingMutex);
68.         auto cachedImage = mImageCache.find(buffer->getId());
69.         found = (cachedImage != mImageCache.end());
70.     }
72.     // If we couldn't find the image in the cache at this time, then either
73.     // SurfaceFlinger messed up registering the buffer ahead of time or we got
74.     // backed up creating other EGLImages.
75.     if (!found) {
76.         //如果ImageCache里面没有则需要重新创建一个EGLImage，创建输入的EGLImage是在ImageManager线程里面，利用notify唤醒机制
77.         status_t cacheResult = mImageManager->cache(buffer);
78.         if (cacheResult != NO_ERROR) {
79.             return cacheResult;
80.         }
81.     }
83.     ...
84.         // 把EGLImage转换成纹理，类型为GL_TEXTURE_EXTERNAL_OES
85.         bindExternalTextureImage(texName, *cachedImage->second);
86.         mTextureView.insert_or_assign(texName, buffer->getId());
87.     }
88. }
90. void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {
91.     ATRACE_CALL();
92.     const GLImage& glImage = static_cast<const GLImage&>(image);
93.     const GLenum target = GL_TEXTURE_EXTERNAL_OES;
94.      //绑定纹理，纹理ID为texName
95.     glBindTexture(target, texName);
96.     if (glImage.getEGLImage() != EGL_NO_IMAGE_KHR) {
97.         // 把EGLImage转换成纹理，纹理ID为texName
98.         glEGLImageTargetTexture2DOES(target, static_cast<GLeglImageOES>(glImage.getEGLImage()));
99.     }
100. }

复制代码

至此，将输入和输出的Buffer都生成了纹理对应，以及设置了纹理的坐标和顶点的坐标，接下来就要利用shader举行绘制了。

1. 文件：frameworks/native/libs/renderengine/gl/GLESRenderEngine.cpp
3. void GLESRenderEngine::drawMesh(const Mesh& mesh) {
4.     ATRACE_CALL();
5.     if (mesh.getTexCoordsSize()) {
6.         //开启顶点着色器属性，，目的是能在顶点着色器中访问顶点的属性数据
7.         glEnableVertexAttribArray(Program::texCoords);
8.        // 给顶点着色器传纹理的坐标
9.         glVertexAttribPointer(Program::texCoords, mesh.getTexCoordsSize(), GL_FLOAT, GL_FALSE,
10.                               mesh.getByteStride(), mesh.getTexCoords());
11.     }
12.     //给顶点着色器传顶点的坐标
13.     glVertexAttribPointer(Program::position, mesh.getVertexSize(), GL_FLOAT, GL_FALSE,
14.                           mesh.getByteStride(), mesh.getPositions());
15.     ...
16.     // 创建顶点和片段着色器，将顶点属性设和一些常量参数设到shader里面
17.     ProgramCache::getInstance().useProgram(mInProtectedContext ? mProtectedEGLContext : mEGLContext,
18.                                            managedState);
19.     ...
20.     // 调GPU去draw
21.     glDrawArrays(mesh.getPrimitive(), 0, mesh.getVertexCount());
22.     ...
23. }
25. 文件：frameworks/native/libs/renderengine/gl/ProgramCache.cpp
27. void ProgramCache::useProgram(EGLContext context, const Description& description) {
28.     //设置key值，根据不同的key值创建不同的shader
29.     Key needs(computeKey(description));   
31.     // look-up the program in the cache
32.     auto& cache = mCaches[context];
33.     auto it = cache.find(needs);
34.     if (it == cache.end()) {
35.         // we didn't find our program, so generate one...
36.         nsecs_t time = systemTime();
37.         // 如果cache里面没有相同的program则重新创建一个
38.         it = cache.emplace(needs, generateProgram(needs)).first;
39.         time = systemTime() - time;
41.         ALOGV(">>> generated new program for context %p: needs=%08X, time=%u ms (%zu programs)",
42.               context, needs.mKey, uint32_t(ns2ms(time)), cache.size());
43.     }   
44.    
45.     // here we have a suitable program for this description
46.     std::unique_ptr<Program>& program = it->second;
47.     if (program->isValid()) {
48.         program->use();
49.         program->setUniforms(description);
50.     }
51. }
53. std::unique_ptr<Program> ProgramCache::generateProgram(const Key& needs) {
54.     ATRACE_CALL();
56.     // 创建顶点着色器
57.     String8 vs = generateVertexShader(needs);
59.     // 创建片段着色器
60.     String8 fs = generateFragmentShader(needs);
62.      // 链接和编译着色器
63.     return std::make_unique<Program>(needs, vs.string(), fs.string());
64. }
66. String8 ProgramCache::generateVertexShader(const Key& needs) {
67.     Formatter vs;
68.     if (needs.hasTextureCoords()) {
69.          // attribute属性通过glVertexAttribPointer设置，varying 表示输出给片段着色器的数据
70.         vs << "attribute vec4 texCoords;"
71.            << "varying vec2 outTexCoords;";
72.     }
73.     ...
74.     vs << "attribute vec4 position;"
75.        << "uniform mat4 projection;"
76.        << "uniform mat4 texture;"
77.        << "void main(void) {" << indent << "gl_Position = projection * position;";
78.     if (needs.hasTextureCoords()) {
79.         vs << "outTexCoords = (texture * texCoords).st;";
80.     }
81.     ...
82.     return vs.getString();
83. }
85. String8 ProgramCache::generateFragmentShader(const Key& needs) {
86.     Formatter fs;
87.     if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
88.         fs << "#extension GL_OES_EGL_image_external : require";
89.     }
91.     // default precision is required-ish in fragment shaders
92.     fs << "precision mediump float;";
94.     if (needs.getTextureTarget() == Key::TEXTURE_EXT) {
95.         fs << "uniform samplerExternalOES sampler;";
96.     } else if (needs.getTextureTarget() == Key::TEXTURE_2D) {
97.         fs << "uniform sampler2D sampler;";
98.     }
100.     if (needs.hasTextureCoords()) {
101.         fs << "varying vec2 outTexCoords;";
102.     }
103.     ...
104.     fs << "void main(void) {" << indent;
105.     ...
106.         if (needs.isTexturing()) {
107.             // 输出像素的颜色值
108.             fs << "gl_FragColor = texture2D(sampler, outTexCoords);"
109.     ...
110. }
111. 文件： frameworks/native/libs/renderengine/gl/Program.cpp
113. Program::Program(const ProgramCache::Key& /*needs*/, const char* vertex, const char* fragment)
114.       : mInitialized(false) {
115.     // 编译顶点和片段着色器
116.     GLuint vertexId = buildShader(vertex, GL_VERTEX_SHADER);
117.     GLuint fragmentId = buildShader(fragment, GL_FRAGMENT_SHADER);
118.     // 创建programID
119.     GLuint programId = glCreateProgram();
120.     // 将顶点和片段着色器链接到programe
121.     glAttachShader(programId, vertexId);
122.     glAttachShader(programId, fragmentId);
123.     // 将着色器里面的属性和自定义的属性变量绑定
124.     glBindAttribLocation(programId, position, "position");
125.     glBindAttribLocation(programId, texCoords, "texCoords");
126.     glBindAttribLocation(programId, cropCoords, "cropCoords");
127.     glBindAttribLocation(programId, shadowColor, "shadowColor");
128.     glBindAttribLocation(programId, shadowParams, "shadowParams");
129.     glLinkProgram(programId);
131.     GLint status;
132.     glGetProgramiv(programId, GL_LINK_STATUS, &status);
133.     ...
134.         mProgram = programId;
135.         mVertexShader = vertexId;
136.         mFragmentShader = fragmentId;
137.         mInitialized = true;
138.         //获得着色器里面uniform变量的位置
139.         mProjectionMatrixLoc = glGetUniformLocation(programId, "projection");
140.         mTextureMatrixLoc = glGetUniformLocation(programId, "texture");
141.         ...
142.         // set-up the default values for our uniforms
143.         glUseProgram(programId);
144.         glUniformMatrix4fv(mProjectionMatrixLoc, 1, GL_FALSE, mat4().asArray());
145.         glEnableVertexAttribArray(0);
146. }
148. void Program::use() {
149.     // Program生效
150.     glUseProgram(mProgram);
151. }
153. void Program::setUniforms(const Description& desc) {
154.     // TODO: we should have a mechanism here to not always reset uniforms that
155.     // didn't change for this program.
156.     // 根据uniform的位置，给uniform变量设置，设到shader里面
157.     if (mSamplerLoc >= 0) {
158.         glUniform1i(mSamplerLoc, 0);
159.         glUniformMatrix4fv(mTextureMatrixLoc, 1, GL_FALSE, desc.texture.getMatrix().asArray());
160.     }
161.    ...
162.        glUniformMatrix4fv(mProjectionMatrixLoc, 1, GL_FALSE, desc.projectionMatrix.asArray());
163.     }

复制代码

末了调用glDrawArrays，利用GPU来绘制，可见对于GPU来说，输入都是一幅幅纹理，然后在着色器里面控制末了pixel的位置坐标和颜色值。
利用GPU绘制往往伴随着一个acquire fence，看下acquire fence的生。

1. 文件: frameworks/native/libs/renderengine/gl/GLESRenderEngine.cpp
3. base::unique_fd GLESRenderEngine::flush() {
4.     ATRACE_CALL();
5.     if (!GLExtensions::getInstance().hasNativeFenceSync()) {
6.         return base::unique_fd();
7.     }
8.     // 创建一个EGLSync对象，用来标识GPU是否绘制完
9.     EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
10.     if (sync == EGL_NO_SYNC_KHR) {
11.         ALOGW("failed to create EGL native fence sync: %#x", eglGetError());
12.         return base::unique_fd();
13.     }
15.     // native fence fd will not be populated until flush() is done.
16.     // 将gl command命令全部刷给GPU
17.     glFlush();
19.     // get the fence fd
20.      //获得android 使用的fence fd
21.     base::unique_fd fenceFd(eglDupNativeFenceFDANDROID(mEGLDisplay, sync));
22.     eglDestroySyncKHR(mEGLDisplay, sync);
23.     if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
24.         ALOGW("failed to dup EGL native fence sync: %#x", eglGetError());
25.     }
27.     // Only trace if we have a valid fence, as current usage falls back to
28.     // calling finish() if the fence fd is invalid.
29.     if (CC_UNLIKELY(mTraceGpuCompletion && mFlushTracer) && fenceFd.get() >= 0) {
30.         mFlushTracer->queueSync(eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, nullptr));
31.     }
33.     return fenceFd;
34. }

复制代码

到这里，CPU将下令全部给到GPU了，然后GPU本身去draw，CPU继续往下运行。
回到finishFrame 函数，获得GPU合成的fence后，会实行queueBuffer操作。

5.3 Output::finishFrame

我们继续回到finishFrame，通过前面的composeSurfaces我们完成了对目标Buffer的GPU合成，此时我们会接着会实行queueBuffer操作，取出GPU合成之后的buffer:

1. 文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp
3. void Output::finishFrame(const compositionengine::CompositionRefreshArgs& refreshArgs) {
4.     ATRACE_CALL();
5.     ALOGV(__FUNCTION__);
7.     if (!getState().isEnabled) {
8.         return;
9.     }
11.     // Repaint the framebuffer (if needed), getting the optional fence for when
12.     // the composition completes.
13.     auto optReadyFence = composeSurfaces(Region::INVALID_REGION, refreshArgs);
14.     if (!optReadyFence) {
15.         return;
16.     }
18.     // swap buffers (presentation)
19.     mRenderSurface->queueBuffer(std::move(*optReadyFence));
20. }
22. 文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/RenderSurface.cpp
24. void RenderSurface::queueBuffer(base::unique_fd readyFence) {
25.     auto& state = mDisplay.getState();
27.          ...
28.    
29.         if (mGraphicBuffer == nullptr) {
30.             ALOGE("No buffer is ready for display [%s]", mDisplay.getName().c_str());
31.         } else {
32.             status_t result =
33.                     // mGraphicBuffer->getNativeBuffer() 是GPU输出的Buffer，可以理解为GPU将内容合成到该Buffer上
34.                     mNativeWindow->queueBuffer(mNativeWindow.get(),
35.                                                mGraphicBuffer->getNativeBuffer(), dup(readyFence));
36.             if (result != NO_ERROR) {
37.                 ALOGE("Error when queueing buffer for display [%s]: %d", mDisplay.getName().c_str(),
38.                       result);
39.                 // We risk blocking on dequeueBuffer if the primary display failed
40.                 // to queue up its buffer, so crash here.
41.                 if (!mDisplay.isVirtual()) {
42.                     LOG_ALWAYS_FATAL("ANativeWindow::queueBuffer failed with error: %d", result);
43.                 } else {
44.                     mNativeWindow->cancelBuffer(mNativeWindow.get(),
45.                                                 mGraphicBuffer->getNativeBuffer(), dup(readyFence));
46.                 }
47.             }
49.             mGraphicBuffer = nullptr;
50.         }
51.     }
52.     // 消费Buffer
53.     status_t result = mDisplaySurface->advanceFrame();
54.     if (result != NO_ERROR) {
55.         ALOGE("[%s] failed pushing new frame to HWC: %d", mDisplay.getName().c_str(), result);
56.     }
57. }
59. 文件:frameworks/native/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp
61. status_t FramebufferSurface::advanceFrame() {
62.     uint32_t slot = 0;
63.     sp<GraphicBuffer> buf;
64.     sp<Fence> acquireFence(Fence::NO_FENCE);   
65.     Dataspace dataspace = Dataspace::UNKNOWN;
66.     // 消费这块Buffer
67.     status_t result = nextBuffer(slot, buf, acquireFence, dataspace);
68.     mDataSpace = dataspace;
69.     if (result != NO_ERROR) {
70.         ALOGE("error latching next FramebufferSurface buffer: %s (%d)",
71.                 strerror(-result), result);
72.     }
73.     return result;
74. }
76. status_t FramebufferSurface::nextBuffer(uint32_t& outSlot,
77.         sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence,
78.         Dataspace& outDataspace) {
79.     Mutex::Autolock lock(mMutex);
81.     BufferItem item;
82.     // acquire Buffer
83.     status_t err = acquireBufferLocked(&item, 0);
84.     ...
85.     if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT &&
86.         item.mSlot != mCurrentBufferSlot) {
87.         mHasPendingRelease = true;
88.         mPreviousBufferSlot = mCurrentBufferSlot;
89.         mPreviousBuffer = mCurrentBuffer;
90.     }
91.     //更新当前的Buffer和fence信息
92.     mCurrentBufferSlot = item.mSlot;
93.     mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer;
94.     mCurrentFence = item.mFence;
96.     outFence = item.mFence;
97.     mHwcBufferCache.getHwcBuffer(mCurrentBufferSlot, mCurrentBuffer, &outSlot, &outBuffer);
98.     outDataspace = static_cast<Dataspace>(item.mDataSpace);
99.      // 将GPU输出的Buffer和fence给到hwc
100.     status_t result = mHwc.setClientTarget(mDisplayId, outSlot, outFence, outBuffer, outDataspace);
101.     if (result != NO_ERROR) {
102.         ALOGE("error posting framebuffer: %d", result);
103.         return result;
104.     }
106.     return NO_ERROR;
107. }

复制代码

GPU合成的Buffer通过setClientTarget 设给hwc，有GPU合成的layer必要先validate再present，以是还必要再present一次，逻辑在postFramebuffer 里面。

5.4 Output::postFramebuffer

1. 文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp
3. void Output::postFramebuffer() {
4.     ATRACE_CALL();
5.     ALOGV(__FUNCTION__);
6.    ...
7.     auto frame = presentAndGetFrameFences();
9.     mRenderSurface->onPresentDisplayCompleted();
10.     ...
11. }
12.    
14. 文件：frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp
15. status_t HWComposer::presentAndGetReleaseFences(DisplayId displayId) {
16.     ATRACE_CALL();
17.    
18.     RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
19.         
20.     auto& displayData = mDisplayData[displayId];
21.     auto& hwcDisplay = displayData.hwcDisplay;
22.    
23.      ...
24.     // GPU合成时执行present，返回present fence
25.     auto error = hwcDisplay->present(&displayData.lastPresentFence);
26.     RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);
28.     std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
29.     // 从hwc里面获得release fence
30.     error = hwcDisplay->getReleaseFences(&releaseFences);
31.     RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);
33.     displayData.releaseFences = std::move(releaseFences);
35.     return NO_ERROR;
36. }
38. 文件： frameworks/native/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp
40. void FramebufferSurface::onFrameCommitted() {
41.     if (mHasPendingRelease) {
42.         sp<Fence> fence = mHwc.getPresentFence(mDisplayId);
43.         if (fence->isValid()) {
44.             // 更新BufferSlot的 fence
45.             status_t result = addReleaseFence(mPreviousBufferSlot,
46.                     mPreviousBuffer, fence);
47.             ALOGE_IF(result != NO_ERROR, "onFrameCommitted: failed to add the"
48.                     " fence: %s (%d)", strerror(-result), result);
49.         }
50.         // 释放之前的Buffer
51.         status_t result = releaseBufferLocked(mPreviousBufferSlot, mPreviousBuffer);
52.         ALOGE_IF(result != NO_ERROR, "onFrameCommitted: error releasing buffer:"
53.                 " %s (%d)", strerror(-result), result);
54.    
55.         mPreviousBuffer.clear();
56.         mHasPendingRelease = false;
57.     }
58. }

复制代码

至此GPU合成的layer通过present调到hwc，hwc再实行commit上屏，此中有一些fence同步的代码，就先不分析了。

---

写在末了

好了今天的博客Android下SF合成流程重学习之GPU合成就到这里了。总之，青山不改绿水长流先到这里了。如果本博客对你有所资助，麻烦关注大概点个赞，如果觉得很烂也可以踩一脚！谢谢各位了！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。