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

愛在花開的季節  金牌会员 | 2024-9-3 01:08:42 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 551|帖子 551|积分 1653

    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企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

愛在花開的季節

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表