Android下HWC以及drm_hwcomposer普法(上)

Android下HWC以及drm_hwcomposer普法(上)



引言

按摩得全套，错了，做事情得全套，普法分析也是如此。drm_hwcomposer如果对Android图形栈有一定研究的童鞋们应该知道它是Android提供的一个的图形后端合成处理HAL模块的实现。但是在分析这个之前我们非常有必要了解一下Android的HWC前世今生，然后再来看drm_hwcomposer是如何配合HWC框架的



一.普法HWC

这里我们对HWC的普法主要从如下接方面展开进行:

  • HWC的概述
  • HWC的进化
  • HWC中重要概念和实现逻辑

1.1 HWC概述

我们知道SurfaceFlinger可以使用OpenGLES合成Layer，但是这需要占用并消耗大量的GPU资源。大多数GPU都没有针对图层合成进行优化，当SurfaceFlinger通过GPU合成图层时，应用程序无法使用GPU进行自己的渲染。为了解放GPU的绘制能力，很多芯片厂家会提供硬件叠加合成，如果硬件叠加器支持的场景都可以走硬件叠加，解放GPU的绘制能力专心绘制，提升的渲染性能同时还能大幅度的降低功耗（GPU强绘制，叠加搬移并不擅长，高功耗）这个时候我们的HWC就登场了，HWC（hwcomposer）是Android中进行窗口（Layer）合成和显示的HAL层模块，其实现是特定于设备的，而且通常由显示设备制造商(OEM)完成，为SurfaceFlinger服务提供硬件支持。而HWC通过硬件设备进行图层合成，可以减轻GPU的合成压力。应用把要显示的layers交给SurfaceFlinger，SurfaceFlinger直接把这些layers交给hwc，hwc就可以在自己能力范围内做好合成，再把合成好的结果拿去显示。如果芯片显示硬件模块功能较弱，不支持某些合成场景，就会用CPU（纯软件合成）或者GPU去做。

在这里插入图片描述

显示设备的能力千差万别，很难直接用API表示硬件设备支持合成的Layer数量，Layer是否可以进行旋转和混合模式操作，以及对图层定位和硬件合成的限制等。因此HWC描述上述信息的流程是这样的：

  • SurfaceFlinger向HWC提供所有Layer的完整列表，让HWC根据其硬件能力，决定如何处理这些Layer。

  • HWC会为每个Layer标注合成方式，是通过GPU还是通过HWC合成。

  • SurfaceFlinger负责先把所有注明GPU合成的Layer合成到一个输出Buffer，然后把这个输出Buffer和其他Layer（注明HWC合成的Layer）一起交给HWC，让HWC完成剩余Layer的合成和显示。
    虽然每个显示设备的能力不同，但是官方要求每个HWC硬件模块都应该支持以下能力：

  • 至少支持4个叠加层：状态栏、系统栏、应用本身和壁纸或者背景。

  • 叠加层可以大于显示屏，例如：壁纸

  • 同时支持预乘每像素（per-pixel）Alpha混合和每平面（per-plane）Alpha混合。

  • 为了支持受保护的内容，必须提供受保护视频播放的硬件路径。
    RGBA packing order, YUV formats, and tiling, swizzling, and stride properties

虽然上述官网要求如此，但是，但是很多hwc是没有达到上述要求的，有的叠加只支持一层的primary plane,也不支持各种混合，各种特性，毕竟建议还是建议。
Tiling：可以把Image切割成MxN个小块，最后渲染时，再将这些小块拼接起来，就像铺瓷砖一样。
Swizzling：一种拌和技术，表示向量单元可以被任意地重排或重复。 但是并非所有情况下HWC都比GPU更高效，例如：当屏幕上没有任何变化时，尤其是叠加层有透明像素并且需要进行图层透明像素混合时。在这种情况下，HWC可以要求部分或者全部叠加层都进行GPU合成，然后HWC持有合成的结果Buffer，如果SurfaceFlinger要求合成相同的叠加图层列表，HWC可以直接显示之前合成的结果Buffer，这有助于提高待机设备的电池寿命。

HWC也提供了VSync事件，用于管理渲染和图层合成时机。


1.2 HWC的进化

Android的HWC模块经历了HWC和HWC2两个版本，现在高版本默认使用HWC2，然后其加载方式也由原来的的SurfaceFlinger直接通过loader加载HAL模块,变成现在的通过HIDL调用到composer service单独加载HAL模块实现。活是越来越整得复杂了。

无论通过和中方式加载HAL的实现，我们需要知道的一点就是HAL加载的流程是，先加载hwcomposer模块得到hw_module_t，再打开composer设备得到hw_device_t。hw_module_t和hw_device_t定义在hardware/libhardware/include/hardware/hardware.h，表示一个HAL层模块和属于该模块的一个实现设备。注意这里是先有HAL模块，再有实现此模块的硬件设备。

struct hw_module_t;
struct hw_module_methods_t;
struct hw_device_t;


typedef struct hw_module_t {
    uint32_t tag;

    uint16_t module_api_version;
#define version_major module_api_version
#define version_minor hal_api_version

    /** Identifier of module */
    const char *id;

    /** Name of this module */
    const char *name;

    /** Author/owner/implementor of the module */
    const char *author;

    /** Modules methods */
    struct hw_module_methods_t* methods;

    /** module's dso */
    void* dso;

#ifdef __LP64__
    uint64_t reserved[32-7];
#else
    /** padding to 128 bytes, reserved for future use */
    uint32_t reserved[32-7];
#endif

} hw_module_t;

typedef struct hw_module_methods_t {
    /** Open a specific device */
    int (*open)(const struct hw_module_t* module, const char* id,
            struct hw_device_t** device);

} hw_module_methods_t;


typedef struct hw_device_t {
    /** tag must be initialized to HARDWARE_DEVICE_TAG */
    uint32_t tag;


    uint32_t version;

    /** reference to the module this device belongs to */
    struct hw_module_t* module;

    /** padding reserved for future use */
#ifdef __LP64__
    uint64_t reserved[12];
#else
    uint32_t reserved[12];
#endif

    /** Close this device */
    int (*close)(struct hw_device_t* device);

} hw_device_t;

#ifdef __cplusplus
#define TO_HW_DEVICE_T_OPEN(x) reinterpret_cast<struct hw_device_t**>(x)
#else
#define TO_HW_DEVICE_T_OPEN(x) (struct hw_device_t**)(x)
#endif

/**
 * Name of the hal_module_info
 */
#define HAL_MODULE_INFO_SYM         HMI

/**
 * Name of the hal_module_info as a string
 */
#define HAL_MODULE_INFO_SYM_AS_STR  "HMI"


int hw_get_module(const char *id, const struct hw_module_t **module);


int hw_get_module_by_class(const char *class_id, const char *inst,
                           const struct hw_module_t **module);

__END_DECLS

#endif  /* ANDROID_INCLUDE_HARDWARE_HARDWARE_H */

我们是基于HWC2协议实现，则需要实现hwcomposer2.h中定义的hwc2_device_t接口，而我们后续要分析的drm_hwcomposer就是基于HWC2的实现。每个HAL层模块实现都要定义一个HAL_MODULE_INFO_SYM数据结构，并且该结构的第一个字段必须是hw_module_t。这里关于它们之间的对应关系，和一些数据结构这里暂时不分析，太多了，这里我们不做过多分析。


1.3 HWC中重要的概念和核心调用逻辑

这里我们的重点不是SurfaceFlinger里面HWC相关的代码部分分析，但是该有的概念和一些核心调用逻辑还是必须提前知道:

但是我们如下的几个重要的概念我们必须要有:

  • HWC2::Device:表示硬件合成显示设备
  • HWC2::Display:表示一个显示屏幕，可以是物理显示屏（可以热插拔接入或者移除），也可以是虚拟显示屏，现在的游戏录屏一般都是基于虚拟屏幕实现的。
  • HWC2::Layer:表示一个叠加图层，对应与应用侧的Surface。

在进行接下来的分析前，我们先来一个Layer的合成方式是怎么确定的那？大致流程如下所示！

在这里插入图片描述

其基本流程可以归纳总结为如下:

  • 当VSync信号到来时，SurfaceFlinger被唤醒，处理Layer的新建，销毁和更新，并且为相应Layer设置期望的合成方式。
  • 所有Layer更新后，SurfaceFlinger调用validateDisplay，让HWC决定每个Layer的合成方式。
  • SurfaceFlinger调用getChangedCompositionTypes检查HWC是否对任何Layer的合成方式做出了改变，若是，那么SurfaceFlinger则调整对应Layer的合成方式，并且调用acceptDisplayChanges通知HWC。
  • SurfaceFlinger把所有Client类型的Layer合成到Target图形缓冲区，然后调用setClientTarget把Target Buffer设置给HWC。（如果没有Client类型的Layer，则可以跳过该方法）
  • 最后，SurfaceFlinger调用presentDisplay，让HWC完成剩余Layer的合成，并且在显示屏上展示出最终的合成结果。

  • HWC2::Layer的创建流程
SurfaceFlinger::onMessageReceived
  onMessageRefresh()//Android 13上面是通过andler::handleMessage compositor.composite
    mCompositionEngine->present(refreshArgs)
      output->prepare(args, latchedLayers)
        Output::rebuildLayerStacks
          Output::collectVisibleLayers
            Output::ensureOutputLayerIfVisible
              BaseOutput::createOutputLayer(layerFE)
                Display::createOutputLayer
                  hwc.createLayer
                    mComposer.createLayer
                        HwcDisplay::CreateLayer//drm_hwcomposer

05-26 01:57:17.427  2264  2264 D createOutputLayer: #00 pc 000000000013f994  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Display::createOutputLayer(android::sp<android::compositionengine::LayerFE> const&) const+84)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #01 pc 0000000000140dfc  /system/lib64/libsurfaceflinger.so (std::__1::shared_ptr<android::compositionengine::impl::Display> android::compositionengine::impl::createOutputTemplated<android::compositionengine::impl::Display, android::compositionengine::CompositionEngine>(android::compositionengine::CompositionEngine const&)::Output::ensureOutputLayer(std::__1::optional<unsigned long>, android::sp<android::compositionengine::LayerFE> const&)+80)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #02 pc 00000000001475e0  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Output::ensureOutputLayerIfVisible(android::sp<android::compositionengine::LayerFE>&, android::compositionengine::Output::CoverageState&)+1692)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #03 pc 0000000000146e60  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Output::collectVisibleLayers(android::compositionengine::CompositionRefreshArgs const&, android::compositionengine::Output::CoverageState&)+128)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #04 pc 0000000000146d38  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Output::rebuildLayerStacks(android::compositionengine::CompositionRefreshArgs const&, std::__1::unordered_set<android::sp<android::compositionengine::LayerFE>, android::compositionengine::LayerFESpHash, std::__1::equal_to<android::sp<android::compositionengine::LayerFE> >, std::__1::allocator<android::sp<android::compositionengine::LayerFE> > >&)+340)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #05 pc 0000000000146a3c  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Output::prepare(android::compositionengine::CompositionRefreshArgs const&, std::__1::unordered_set<android::sp<android::compositionengine::LayerFE>, android::compositionengine::LayerFESpHash, std::__1::equal_to<android::sp<android::compositionengine::LayerFE> >, std::__1::allocator<android::sp<android::compositionengine::LayerFE> > >&)+56)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #06 pc 000000000013eb3c  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::CompositionEngine::present(android::compositionengine::CompositionRefreshArgs&)+116)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #07 pc 0000000000111c08  /system/lib64/libsurfaceflinger.so (android::SurfaceFlinger::onMessageRefresh()+1524)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #08 pc 000000000010ee5c  /system/lib64/libsurfaceflinger.so (android::SurfaceFlinger::onMessageReceived(int, long)+88)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #09 pc 0000000000019b8c  /system/lib64/libutils.so (android::Looper::pollInner(int)+372)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #10 pc 00000000000199b0  /system/lib64/libutils.so (android::Looper::pollOnce(int, int*, int*, void**)+112)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #11 pc 00000000000f7850  /system/lib64/libsurfaceflinger.so (android::impl::MessageQueue::waitMessage()+84)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #12 pc 0000000000108594  /system/lib64/libsurfaceflinger.so (android::SurfaceFlinger::run()+20)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #13 pc 0000000000002394  /system/bin/surfaceflinger (main+844)
05-26 01:57:17.428  2264  2264 D createOutputLayer: #14 pc 000000000008506c  /apex/com.android.runtime/lib64/bionic/libc.so (__libc_init+108)


  • HWC2::Layer设置buffer的流程
//通过Composer::setLayerBuffer调用堆栈,将buffer\_handle\_t信息传递到hwc2的HAL层实现的
onMessageRefresh()
  mCompositionEngine->present(refreshArgs)
    output->present(args)  //Output.cpp
      Output::updateAndWriteCompositionState(refreshArgs)
        layer->writeStateToHWC
          writeOutputIndependentPerFrameStateToHWC
             OutputLayer.cpp:471 writeBufferStateToHWC
              HwcLayer::SetLayerBuffer //drm_hwcomposer

05-26 01:57:51.122  2280  2280 D setLayerBuffer: #00 pc 00000000000b4028  /system/lib64/libsurfaceflinger.so (android::Hwc2::impl::Composer::setLayerBuffer(unsigned long, unsigned long, unsigned int, android::sp<android::GraphicBuffer> const&, int)+96)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #01 pc 00000000001514c8  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::OutputLayer::writeBufferStateToHWC(android::HWC2::Layer*, android::compositionengine::LayerFECompositionState const&)+344)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #02 pc 0000000000150e74  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::OutputLayer::writeOutputIndependentPerFrameStateToHWC(android::HWC2::Layer*, android::compositionengine::LayerFECompositionState const&)+484) OutputLayer.cpp:471 writeBufferStateToHWC
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #03 pc 00000000001500ac  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::OutputLayer::writeStateToHWC(bool)+180) OutputLayer.cpp:342 writeOutputIndependentPerFrameStateToHWC
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #04 pc 00000000001479a4  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Output::updateAndWriteCompositionState(android::compositionengine::CompositionRefreshArgs const&)+356) Output.cpp:607 layer->writeStateToHWC
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #05 pc 0000000000146b2c  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::Output::present(android::compositionengine::CompositionRefreshArgs const&)+64) Output.cpp:313  updateAndWriteCompositionState(refreshArgs)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #06 pc 000000000013ebe8  /system/lib64/libsurfaceflinger.so (android::compositionengine::impl::CompositionEngine::present(android::compositionengine::CompositionRefreshArgs&)+220) CompositionEngine.cpp output->present(args)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #07 pc 0000000000111c4c  /system/lib64/libsurfaceflinger.so (android::SurfaceFlinger::onMessageRefresh()+1524) mCompositionEngine->present(refreshArgs);
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #08 pc 000000000010eea0  /system/lib64/libsurfaceflinger.so (android::SurfaceFlinger::onMessageReceived(int, long)+88)   onMessageRefresh()
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #09 pc 0000000000019b8c  /system/lib64/libutils.so (android::Looper::pollInner(int)+372)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #10 pc 00000000000199b0  /system/lib64/libutils.so (android::Looper::pollOnce(int, int*, int*, void**)+112)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #11 pc 00000000000f7894  /system/lib64/libsurfaceflinger.so (android::impl::MessageQueue::waitMessage()+84)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #12 pc 00000000001085d8  /system/lib64/libsurfaceflinger.so (android::SurfaceFlinger::run()+20)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #13 pc 0000000000002394  /system/bin/surfaceflinger (main+844)
05-26 01:57:51.122  2280  2280 D setLayerBuffer: #14 pc 000000000008506c  /apex/com.android.runtime/lib64/bionic/libc.so (__libc_init+108)


二. drm_hwcomposer普法

drm_hwcomposer作为HWC框架的HAL实现，它是怎么承接HWC的接口，并且实现相关逻辑的呢。这就离不开它的设计逻辑了，分为frontend前端和backend后端处理逻辑。

  • frontend 是对外提供调用的接口，，外部使用者呼叫 front end 暴漏出的接口来呼叫某一功能；
  • backend 主要是调用内核的实现逻辑，是前端接口功能的内部实现，是真正做事的地方

其中最最重要的就是后端的设计逻辑,分为三种情况

  • Backend: 一个后端的实现，注册为"generic"，主要是定义了ValidateDisplay方法，这个方法用来设置可见的HwcLayer应该采用什么合成方式
  • BackendClient: 一个后端的实现，注册为"client"，主要是定义了ValidateDisplay方法，它把所有HwcLayer都设置成立Client合成方式
  • BackendManager:后端的管理器，用来根据Device name从已注册的backend列表中选择一个，设置给HwcDisplay；GetBackendByName就是通过Device name来从available_backends_中选择一个匹配的Backend构造函数来构建后端对象。

接下来我们就从代码触发，看看它是如何使用上述的框架实现的！


2.1 drm_hwcomposer源码初探

这块我们只分析其核心实现，对于具体的一些逻辑我们带过！有些具体代码逻辑，臣妾真的是心有余而力不足啊，分析不了啊。路漫漫啊，不知道能不能走到终点！ 在分析源码前，我们来看下drm_hwcomposer的目录，如下:

drm_hwcomposer
├── Android.bp   //编译脚本
├── backend      //hwcomposer后端，是前端接口功能的内部实现，是真正做事的地方
├── bufferinfo  //对应不同vendor的buffer接口
├── build_deploy.sh
├── compositor  //kms处理送显逻辑代码
├── drm         //drm，各个子模块代码
├── hwc2_device //对接Android hwc相关源码
├── include     //头文件
├── MODULE_LICENSE_APACHE2
├── NOTICE
├── presubmit.sh
├── README.md
└── utils

2.2 drm_hwcomposer的HAL模块实现

HAL是个很神秘的东东，经常会看到一些求职网站显示需要招聘会HAL开发的Android工程师，但是绝大部分的Android开发人员只会使用，很少能独立开发一个属于自己的HAL。幸运的是我也是其中的绝大部分，不幸的是我也么有开发过属于自己的HAL实现。

//hwc2_device/hwc2_device.cpp
/**
 * @brief 
 * 
 * @param module 
 * @param name 
 * @param dev 
 * @return int 
 *  HookDevOpen，该方法中会去实例化一个Drmhwc2Device对象，其中去创建了一个DrmHwcTwo对象
 */
static int HookDevOpen(const struct hw_module_t *module, const char *name,
                       struct hw_device_t **dev) {
  if (strcmp(name, HWC_HARDWARE_COMPOSER) != 0) {
    ALOGE("Invalid module name- %s", name);
    return -EINVAL;
  }

  auto ctx = std::make_unique<Drmhwc2Device>();//详见章节5.6
  if (!ctx) {
    ALOGE("Failed to allocate DrmHwcTwo");
    return -ENOMEM;
  }

  ctx->common.tag = HARDWARE_DEVICE_TAG;
  ctx->common.version = HWC_DEVICE_API_VERSION_2_0;
  ctx->common.close = HookDevClose;
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
  ctx->common.module = (hw_module_t *)module;
  ctx->getCapabilities = HookDevGetCapabilities;
  ctx->getFunction = HookDevGetFunction;//核心接口，详见5.5

  *dev = &ctx.release()->common;

  return 0;
}

static struct hw_module_methods_t hwc2_module_methods = {
    .open = android::HookDevOpen,
};

/**
 * @brief 
 * HAL标准化实现流程
 */
hw_module_t HAL_MODULE_INFO_SYM = {//注册HAL
    .tag = HARDWARE_MODULE_TAG,
    .module_api_version = HARDWARE_MODULE_API_VERSION(2, 0),
    .id = HWC_HARDWARE_MODULE_ID,//hwcomposer
    .name = "DrmHwcTwo module",
    .author = "The Android Open Source Project",
    .methods = &hwc2_module_methods,
    .dso = nullptr,
    .reserved = {0},
};

这一块的逻辑比较简单，就是上层hwcomposer服务加载HAL模块的时候，通过套路化的HAL编程实现加载HWC HAL的功能，并且上层调用open时候会初始化一个Drmhwc2Device返回给hwcomposer服务。其调用堆栈如下:

01-01 00:00:18.617  2262  2262 D HWC_DRM : #00 pc 000000000002bfd4  /vendor/lib64/hw/hwcomposer.drm.so (android::HookDevOpen(hw_module_t const*, char const*, hw_device_t**)+80)
01-01 00:00:18.617  2262  2262 D HWC_DRM : #01 pc 0000000000006684  /vendor/bin/hw/android.hardware.graphics.composer@2.1-service (android::hardware::graphics::composer::V2_1::passthrough::HwcLoader::openDeviceWithAdapter(hw_module_t const*, bool*)+376)
01-01 00:00:18.617  2262  2262 D HWC_DRM : #02 pc 000000000000639c  /vendor/bin/hw/android.hardware.graphics.composer@2.1-service (android::hardware::graphics::composer::V2_1::passthrough::HwcLoader::createHalWithAdapter(hw_module_t const*)+48)
01-01 00:00:18.617  2262  2262 D HWC_DRM : #03 pc 00000000000062cc  /vendor/bin/hw/android.hardware.graphics.composer@2.1-service (android::hardware::graphics::composer::V2_1::passthrough::HwcLoader::load()+164)
01-01 00:00:18.617  2262  2262 D HWC_DRM : #04 pc 0000000000006138  /vendor/bin/hw/android.hardware.graphics.composer@2.1-service (main+240)
01-01 00:00:18.617  2262  2262 D HWC_DRM : #05 pc 000000000008506c  /apex/com.android.runtime/lib64/bionic/libc.so (__libc_init+108)

其中Drmhwc2Device的层级关系如下:

在这里插入图片描述

其代码定义如下:


//hardware/libhardware/include/hardware/hwcomposer2.h
typedef struct hwc2_device {
/* Must be the first member of this struct, since a pointer to this struct
     * will be generated by casting from a hw_device_t* */
    struct hw_device_t common;
    void (*getCapabilities)(struct hwc2_device* device, uint32_t* outCount,
            int32_t* /*hwc2_capability_t*/ outCapabilities);
    hwc2_function_pointer_t (*getFunction)(struct hwc2_device* device,
            int32_t /*hwc2_function_descriptor_t*/ descriptor);
} hwc2_device_t;

//hardware/libhardware/include/hardware/hardware.h
typedef struct hw_device_t {
    tag; /** tag must be initialized to HARDWARE_DEVICE_TAG */
    uint32_t version;
    struct hw_module_t* module;
    uint64_t reserved[12];
    int (*close)(struct hw_device_t* device);
} hw_device_t;


hwc2_device/hwc2_device.cpp
struct Drmhwc2Device : hwc2_device {
  DrmHwcTwo drmhwctwo;
};

这里可以看到hwc2_device在hw_device_t的基础上扩展了，两个函数接口，其中最最核心的就是getFunction，原来在HWC时代，上层调用HAL是直接通过固化的函数硬对接上去的，现在通过getFunction可以进行许多扩展，增强可实用性。


2.3 HookDevGetFunction功能

HookDevGetFunction，我们可以把它理解为是HAL层对上提供的功能函数接口表。这些函数具体可以分为三类:

  • Device functions:其核心功能函数包括:

    • 注册回调事件 registerCallback
    • 创建虚拟通路（非显示通路，如录屏）createVirtualDisplay
    • 热拔插事件onHotplug

  • Display functions:其核心功能函数包括:

    • 输入layer的管理createLayer / destroyLayer
    • 叠加输出buffer设置setClientTarget / setOutputBuffer
    • 显示触发present
    • 设置vsync使能setVsyncEnabled

  • Layer functions:其核心功能函数包括:

    • 设置层的buffer setBuffer：
    • 设置层的属性 setBlendMode/setColor/setDataspace/setDisplayFrame（显示区域）/setPlaneAlpha/setSourceCrop/setZOrder
    • 设置层的sidband流 setSidebandStream
    • 设置叠加方式setCompositionType：Device表示硬件叠加，Client表示GPU叠加
//hwc2_device/hwc2_device.cpp

static hwc2_function_pointer_t HookDevGetFunction(struct hwc2_device * /*dev*/,
                                                  int32_t descriptor) {
  auto func = static_cast<HWC2::FunctionDescriptor>(descriptor);
  switch (func) {
    // Device functions
    ...
    case HWC2::FunctionDescriptor::RegisterCallback://注册回调，热插拔事件就是通过它回调上去的
      return ToHook<HWC2_PFN_REGISTER_CALLBACK>(
          DeviceHook<int32_t, decltype(&DrmHwcTwo::RegisterCallback),
                     &DrmHwcTwo::RegisterCallback, int32_t,
                     hwc2_callback_data_t, hwc2_function_pointer_t>);    
    // Display functions
    case HWC2::FunctionDescriptor::AcceptDisplayChanges:
      return ToHook<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
          DisplayHook<decltype(&HwcDisplay::AcceptDisplayChanges),
                      &HwcDisplay::AcceptDisplayChanges>);
    case HWC2::FunctionDescriptor::CreateLayer:
      return ToHook<HWC2_PFN_CREATE_LAYER>(
          DisplayHook<decltype(&HwcDisplay::CreateLayer),
                      &HwcDisplay::CreateLayer, hwc2_layer_t *>);
    case HWC2::FunctionDescriptor::DestroyLayer:
    ...
    // Layer functions
    case HWC2::FunctionDescriptor::SetCursorPosition:
      return ToHook<HWC2_PFN_SET_CURSOR_POSITION>(
          LayerHook<decltype(&HwcLayer::SetCursorPosition),
                    &HwcLayer::SetCursorPosition, int32_t, int32_t>);
    case HWC2::FunctionDescriptor::SetLayerBlendMode:
      return ToHook<HWC2_PFN_SET_LAYER_BLEND_MODE>(
          LayerHook<decltype(&HwcLayer::SetLayerBlendMode),
                    &HwcLayer::SetLayerBlendMode, int32_t>);
    case HWC2::FunctionDescriptor::SetLayerBuffer:
      return ToHook<HWC2_PFN_SET_LAYER_BUFFER>(
          LayerHook<decltype(&HwcLayer::SetLayerBuffer),
                    &HwcLayer::SetLayerBuffer, buffer_handle_t, int32_t>);
    ...
  }
}

在这里插入图片描述


2.4 DrmHwcTwo的构建和初始化

兄弟你为啥叫DrmHwcTwo而不是叫DrmHwc2呢！你到底是李鬼还是李逵，让人傻傻分不清楚啊！让我们看看DrmHwcTwo的构造究竟干了些啥！

//drm-hwcomposer/hwc2_device/DrmHwcTwo.h
class DrmHwcTwo : public PipelineToFrontendBindingInterface {
 public:
  DrmHwcTwo();
  ~DrmHwcTwo() override = default;

  std::pair<HWC2_PFN_HOTPLUG, hwc2_callback_data_t> hotplug_callback_{};
  std::pair<HWC2_PFN_VSYNC, hwc2_callback_data_t> vsync_callback_{};
#if PLATFORM_SDK_VERSION > 29
  std::pair<HWC2_PFN_VSYNC_2_4, hwc2_callback_data_t> vsync_2_4_callback_{};
  std::pair<HWC2_PFN_VSYNC_PERIOD_TIMING_CHANGED, hwc2_callback_data_t>
      period_timing_changed_callback_{};
#endif
  std::pair<HWC2_PFN_REFRESH, hwc2_callback_data_t> refresh_callback_{};

  // Device functions
  HWC2::Error CreateVirtualDisplay(uint32_t width, uint32_t height,
                                   int32_t *format, hwc2_display_t *display);
  HWC2::Error DestroyVirtualDisplay(hwc2_display_t display);
  void Dump(uint32_t *outSize, char *outBuffer);
  uint32_t GetMaxVirtualDisplayCount();
  HWC2::Error RegisterCallback(int32_t descriptor, hwc2_callback_data_t data,
                               hwc2_function_pointer_t function);

  auto GetDisplay(hwc2_display_t display_handle) {
    return displays_.count(display_handle) != 0
               ? displays_[display_handle].get()
               : nullptr;
  }

  auto &GetResMan() {
    return resource_manager_;
  }

  void ScheduleHotplugEvent(hwc2_display_t displayid, bool connected) {
    deferred_hotplug_events_[displayid] = connected;
  }

  // PipelineToFrontendBindingInterface
  bool BindDisplay(DrmDisplayPipeline *pipeline) override;
  bool UnbindDisplay(DrmDisplayPipeline *pipeline) override;
  void FinalizeDisplayBinding() override;

  void SendVsyncEventToClient(hwc2_display_t displayid, int64_t timestamp,
                              uint32_t vsync_period) const;
  void SendVsyncPeriodTimingChangedEventToClient(hwc2_display_t displayid,
                                                 int64_t timestamp) const;

 private:
  void SendHotplugEventToClient(hwc2_display_t displayid, bool connected);

  //ResourceManager是个非常重要的核心类，他应该管理着DRM的资源
  ResourceManager resource_manager_;// DrmHwcTwo类中的成员
  std::map<hwc2_display_t, std::unique_ptr<HwcDisplay>> displays_;
  std::map<DrmDisplayPipeline *, hwc2_display_t> display_handles_;

  std::string mDumpString;

  std::map<hwc2_display_t, bool> deferred_hotplug_events_;
  std::vector<hwc2_display_t> displays_for_removal_list_;

  uint32_t last_display_handle_ = kPrimaryDisplay;
};


//drm-hwcomposer/hwc2_device/DrmHwcTwo.cpp
DrmHwcTwo::DrmHwcTwo() : resource_manager_(this){}; // DrmHwcTwo的构造函数定义

//hwc2_device/hwc2_device.cpp
struct Drmhwc2Device : hwc2_device {
  DrmHwcTwo drmhwctwo;
};

auto ctx = std::make_unique<Drmhwc2Device>();

DrmHwcTwo它是如此的潇洒，非常简单就是实例化了一个ResourceManager对象，然后将自己传递给了ResourceManager。


2.5 ResourceManager构造以及初始化流程

这里我们直接上代码，客官请看:

//drm/ResourceManager.cpp
ResourceManager::ResourceManager(
    PipelineToFrontendBindingInterface *p2f_bind_interface)
    : frontend_interface_(p2f_bind_interface) {
  //p2f_bind_interface指向DrmHwcTwo对象
  if (uevent_listener_.Init() != 0) {
    ALOGE("Can't initialize event listener");
  }
}

很简单，就是去实例化一个ResourceManager对象，其构造函数中处理初始化了uevent_listener等成员，也没啥了frontend_interface_指向DrmHwcTwo对象。到这里,是不是读者感觉到一脸懵逼，Resourceanager感觉啥也木有做啊，其实它是个非常重要的核心类，它管理着DRM的资源(对于libdrm编程熟悉的小伙伴，应该对于Resource肯定很熟悉了)。

那这里的ResourceManager::Init啥时候被调用呢！其实是在SurfaceFlinger的初始化过程时，设置callback给HWC，层层传递后就会调用到DrmHwcTwo::RegisterCallback进而调用到了 resource_manager_.Init();

//hwc2_device/hwc2_device.cpp
    case HWC2::FunctionDescriptor::RegisterCallback:
      return ToHook<HWC2_PFN_REGISTER_CALLBACK>(
          DeviceHook<int32_t, decltype(&DrmHwcTwo::RegisterCallback),
                     &DrmHwcTwo::RegisterCallback, int32_t,
                     hwc2_callback_data_t, hwc2_function_pointer_t>);
                     
//hwc2_device/DrmHwcTwo.cpp                   
HWC2::Error DrmHwcTwo::RegisterCallback(int32_t descriptor,
                                        hwc2_callback_data_t data,
                                        hwc2_function_pointer_t function) {
  switch (static_cast<HWC2::Callback>(descriptor)) {
    case HWC2::Callback::Hotplug: {
      hotplug_callback_ = std::make_pair(HWC2_PFN_HOTPLUG(function), data);
      if (function != nullptr) {
        //  ResourceManager resource_manager_;
        resource_manager_.Init();
      } else {
        resource_manager_.DeInit();
        /* Headless display may still be here, remove it */
        displays_.erase(kPrimaryDisplay);
      }
      break;
    }
    case HWC2::Callback::Refresh: {
      refresh_callback_ = std::make_pair(HWC2_PFN_REFRESH(function), data);
      break;
    }
    case HWC2::Callback::Vsync: {
      vsync_callback_ = std::make_pair(HWC2_PFN_VSYNC(function), data);
      break;
    }
#if PLATFORM_SDK_VERSION > 29
    case HWC2::Callback::Vsync_2_4: {
      vsync_2_4_callback_ = std::make_pair(HWC2_PFN_VSYNC_2_4(function), data);
      break;
    }
    case HWC2::Callback::VsyncPeriodTimingChanged: {
      period_timing_changed_callback_ = std::
          make_pair(HWC2_PFN_VSYNC_PERIOD_TIMING_CHANGED(function), data);
      break;
    }
#endif
    default:
      break;
  }
  return HWC2::Error::None;
}

我们看下ResourceManager::Init实现:

ResourceManager 初始化到底初始化了什么呢？

[drm-hwcomposer/drm/ResourceManager.cpp]
void ResourceManager::Init() {
  if (initialized_) {
    ALOGE("Already initialized"); // 已经初始化了，避免重复初始化
    return;
  }
  char path_pattern[PROPERTY_VALUE_MAX];
  // Could be a valid path or it can have at the end of it the wildcard %
  // which means that it will try open all devices until an error is met.
  int path_len = property_get("vendor.hwc.drm.device", path_pattern,
                              "/dev/dri/card%");
  if (path_pattern[path_len - 1] != '%') {
    AddDrmDevice(std::string(path_pattern));//详见章节2.6
  } else {
    path_pattern[path_len - 1] = '\0';
    for (int idx = 0;; ++idx) {
      std::ostringstream path;
      path << path_pattern << idx;
      struct stat buf {};
      if (stat(path.str().c_str(), &buf) != 0)
        break;
      if (DrmDevice::IsKMSDev(path.str().c_str())) {
        AddDrmDevice(path.str());
      }
    }
  }
    /**上面一大坨代码，简单理解就是找到DRM的设备节点，然后打开它，在我的设备上是/dev/dri/card0 */
    /** AddDrmDevice中去初始化DRM各种各样的资源 **/

  char scale_with_gpu[PROPERTY_VALUE_MAX];
  property_get("vendor.hwc.drm.scale_with_gpu", scale_with_gpu, "0");
  scale_with_gpu_ = bool(strncmp(scale_with_gpu, "0", 1));// 使用GPU缩放的标志
  if (BufferInfoGetter::GetInstance() == nullptr) {
    ALOGE("Failed to initialize BufferInfoGetter"); 
       // 初始化BufferInfoGetter，用于从Gralloc Mapper中获取buffer的属性信息
    return;
  }
  uevent_listener_.RegisterHotplugHandler([this] {// 注册热插拔的回调
    const std::lock_guard<std::mutex> lock(GetMainLock());
    UpdateFrontendDisplays();
  });
  //详见章节2.7
  UpdateFrontendDisplays();//这里会Send Hotplug Event To Client，SF会收到一次onComposerHalHotplug
                                                  // attached_pipelines_的初始化、更新
  initialized_ = true; // 设置标记，表明已经初始化过了
}

重点来看下AddDrmDevice:

AddDrmDevice

[drm-hwcomposer/drm/ResourceManager.cpp]
int ResourceManager::AddDrmDevice(const std::string &path) {
  auto drm = std::make_unique<DrmDevice>();//创建DrmDevice对象
  int ret = drm->Init(path.c_str());//初始化DrmDevice，path一般就是/dev/dri/card0
  drms_.push_back(std::move(drm));//保存到drms_中，便于后续的DeleteDrmDevices删除
  return ret;
}

2.6 DrmDevice的实现

一个重要的角色登场DrmDevice，我们可以理解它是对DRM设备进行抽象描述的一个类，用来后续的送显示，如下是其定义:

image

这里我们先看DrmDevice的实现，DrmDevice的构造函数中创建一个 DrmFbImporter 对象

[drm-hwcomposer/drm/DrmDevice.cpp]
DrmDevice::DrmDevice() {
  drm_fb_importer_ = std::make_unique<DrmFbImporter>(*this);
}

这里的DrmFbImporter后面会用到，用于后续DRM/KMS显示流程！

接下来我们继续往下看，看看DrmDevice::Init的实现逻辑，它主要完成了完成了获取DRM资源的初始化，CRTC、Encoder、Connector、Plane这些资源都获取到了!完美抽象出下面的框图!

image

//drm/DrmDevice.cpp
auto DrmDevice::Init(const char *path) -> int {
  /* TODO: Use drmOpenControl here instead */
  fd_ = UniqueFd(open(path, O_RDWR | O_CLOEXEC));//打开设备，一般是/dev/dri/card0
  if (!fd_) {//异常处理
    // NOLINTNEXTLINE(concurrency-mt-unsafe): Fixme
    ALOGE("Failed to open dri %s: %s", path, strerror(errno));
    return -ENODEV;
  }
  //通用设置  设置DRM_CLIENT_CAP_UNIVERSAL_PLANES，获取所有支持的Plane资源
  int ret = drmSetClientCap(GetFd(), DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
  if (ret != 0) {
    ALOGE("Failed to set universal plane cap %d", ret);
    return ret;
  }
  //通用设置 设置DRM_CLIENT_CAP_ATOMIC，告知DRM驱动该应用程序支持Atomic操作
  ret = drmSetClientCap(GetFd(), DRM_CLIENT_CAP_ATOMIC, 1);
  if (ret != 0) {
    ALOGE("Failed to set atomic cap %d", ret);
    return ret;
  }

#ifdef DRM_CLIENT_CAP_WRITEBACK_CONNECTORS
  // 设置开启 writeback
  ret = drmSetClientCap(GetFd(), DRM_CLIENT_CAP_WRITEBACK_CONNECTORS, 1);
  if (ret != 0) {
    ALOGI("Failed to set writeback cap %d", ret);
  }
#endif

  uint64_t cap_value = 0;
  if (drmGetCap(GetFd(), DRM_CAP_ADDFB2_MODIFIERS, &cap_value) != 0) {
    ALOGW("drmGetCap failed. Fallback to no modifier support.");
    cap_value = 0;
  }
  HasAddFb2ModifiersSupport_ = cap_value != 0;//是否支持Add Fb2 Modifiers

  drmSetMaster(GetFd());
  if (drmIsMaster(GetFd()) == 0) {
    ALOGE("DRM/KMS master access required");
    return -EACCES;
  }
  //获取DrmModeRes
  auto res = MakeDrmModeResUnique(GetFd());
  if (!res) {
    ALOGE("Failed to get DrmDevice resources");
    return -ENODEV;
  }
  // 最小和最大的分辨率
  min_resolution_ = std::pair<uint32_t, uint32_t>(res->min_width,
                                                  res->min_height);
  max_resolution_ = std::pair<uint32_t, uint32_t>(res->max_width,
                                                  res->max_height);
 // 获取所有的CRTC，创建DrmCrtc对象，并加入crtcs_这个vector<unique_ptr<DrmCrtc>> 
  for (int i = 0; i < res->count_crtcs; ++i) {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
    auto crtc = DrmCrtc::CreateInstance(*this, res->crtcs[i], i);
    if (crtc) {
      crtcs_.emplace_back(std::move(crtc));
    }
  }
  //获取Encoder 建DrmEncoder对象，并加入encoders_这个vector<unique_ptr<DrmEncoder>>
  for (int i = 0; i < res->count_encoders; ++i) {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
    auto enc = DrmEncoder::CreateInstance(*this, res->encoders[i], i);
    if (enc) {
      encoders_.emplace_back(std::move(enc));
    }
  }
   // 获取所有的Connector，创建DrmConnector对象，并加入connectors_这个vector<unique_ptr<DrmConnector>>
  // 或放入writeback_connectors_这个vector中
  for (int i = 0; i < res->count_connectors; ++i) {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
    auto conn = DrmConnector::CreateInstance(*this, res->connectors[i], i);

    if (!conn) {
      continue;
    }

    if (conn->IsWriteback()) {
      writeback_connectors_.emplace_back(std::move(conn));
    } else {
      connectors_.emplace_back(std::move(conn));
    }
  }
  // 获取drmModePlaneRes
  auto plane_res = MakeDrmModePlaneResUnique(GetFd());
  if (!plane_res) {
    ALOGE("Failed to get plane resources");
    return -ENOENT;
  }
  // 获取所有的Plane，创建DrmPlane对象，并加入planes_这个vector<unique_ptr<DrmPlane>>
  for (uint32_t i = 0; i < plane_res->count_planes; ++i) {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
    auto plane = DrmPlane::CreateInstance(*this, plane_res->planes[i]);

    if (plane) {
      planes_.emplace_back(std::move(plane));
    }
  }

  return 0;
}

2.7 UpdateFrontendDisplays

让我们梦回大唐，错了让我们回到ResourceManager::Init()中，在最后的逻辑中调用了UpdateFrontendDisplays方法.

//drm/ResourceManager.cpp

auto ResourceManager::GetOrderedConnectors() -> std::vector<DrmConnector *> {
  /* Put internal displays first then external to
   * ensure Internal will take Primary slot
   */

  std::vector<DrmConnector *> ordered_connectors;

  for (auto &drm : drms_) {
    for (const auto &conn : drm->GetConnectors()) {
      // 判断当前连接器是否为内部连接器
      // 如果是内部连接器，则将其添加到ordered_connectors中
      if (conn->IsInternal()) {
        ordered_connectors.emplace_back(conn.get());
      }
    }
  }

  for (auto &drm : drms_) {
    for (const auto &conn : drm->GetConnectors()) {
      // 判断当前连接器是否为外部连接器
      // 如果是外部连接器，则将其添加到ordered_connectors中
      if (conn->IsExternal()) {
        ordered_connectors.emplace_back(conn.get());
      }
    }
  }

  return ordered_connectors;
}

void ResourceManager::UpdateFrontendDisplays() {
  //获取所有的连接器，并按照连接器的优先级进行排序  internal displays放前面，external放后面的排序connectors
  auto ordered_connectors = GetOrderedConnectors();

  for (auto *conn : ordered_connectors) {
    conn->UpdateModes();
    bool connected = conn->IsConnected();
    // std::map<DrmConnector *, std::unique_ptr<DrmDisplayPipeline>>attached_pipelines_;
    bool attached = attached_pipelines_.count(conn) != 0;// 判断map中是否存在key为conn的元素

    if (connected != attached) {
      ALOGI("%s connector %s", connected ? "Attaching" : "Detaching",
            conn->GetName().c_str());

      if (connected) {// connected==true and attached == false，
        // 说明当前连接器需要被绑定到frontend上
        // 创建一个DrmDisplayPipeline对象，并将其绑定到frontend_interface_上
        // 然后将该对象添加到attached_pipelines_中
        // 最后调用frontend_interface_的BindDisplay方法将该对象绑定到frontend上
        auto pipeline = DrmDisplayPipeline::CreatePipeline(*conn);
        //frontend_interface_指向DrmHwcTwo对象
        frontend_interface_->BindDisplay(pipeline.get());
        attached_pipelines_[conn] = std::move(pipeline);
      } else {// connected==false and attached == true，解除
        // 当前连接器与frontend的绑定关系
        // 首先从attached_pipelines_中移除该连接器
        // 然后调用frontend_interface_的UnbindDisplay方法解除绑定
        auto &pipeline = attached_pipelines_[conn];
        frontend_interface_->UnbindDisplay(pipeline.get());
        attached_pipelines_.erase(conn);
      }
    }
  }
  // 最后调用frontend_interface_的FinalizeDisplayBinding方法完成绑定操作
  frontend_interface_->FinalizeDisplayBinding();
}

我们接着继续看下DrmDisplayPipeline::CreatePipeline是如何构建DrmDisplayPipeline的，以及它DrmDisplayPipeline的定义！

//drm/DrmDisplayPipeline.h
/**
 * @brief 
 * 主要用于封装drm相关的组件，包括plane、encoder、crtc等
 * 1. 创建一个DrmDisplayPipeline对象
 * 2. 获取可用的planes
 * 3. 返回一个DrmDisplayPipeline对象
 */
struct DrmDisplayPipeline {
  static auto CreatePipeline(DrmConnector &connector)
      -> std::unique_ptr<DrmDisplayPipeline>;

  auto GetUsablePlanes()
      -> std::vector<std::shared_ptr<BindingOwner<DrmPlane>>>;

  DrmDevice *device;

  std::shared_ptr<BindingOwner<DrmConnector>> connector;
  std::shared_ptr<BindingOwner<DrmEncoder>> encoder;
  std::shared_ptr<BindingOwner<DrmCrtc>> crtc;
  std::shared_ptr<BindingOwner<DrmPlane>> primary_plane;

  std::unique_ptr<DrmAtomicStateManager> atomic_state_manager;
};

//drm/DrmDisplayPipeline.cpp
DrmDisplayPipeline::CreatePipeline
    TryCreatePipelineUsingEncoder
        TryCreatePipeline
   
static auto TryCreatePipeline(DrmDevice &dev, DrmConnector &connector,
                              DrmEncoder &enc, DrmCrtc &crtc)
    -> std::unique_ptr<DrmDisplayPipeline> {
  /* Check if resources are available */

  auto pipe = std::make_unique<DrmDisplayPipeline>();
  pipe->device = &dev;

  pipe->connector = connector.BindPipeline(pipe.get());
  pipe->encoder = enc.BindPipeline(pipe.get());
  pipe->crtc = crtc.BindPipeline(pipe.get());

  if (!pipe->connector || !pipe->encoder || !pipe->crtc) {
    return {};
  }

这里的DrmDisplayPipeline，就是drm下kms显示通路的一个管道，将crtc，encoder，connector组合起来的一个类！


2.8 DrmHwcTwo如何处理HwcDisplay的构建

我们接着接续看下DrmHwcTwo是如何继续处理HwcDisplay，这其中牵涉到几个重要的成员和方法:

//hwc2_device/DrmHwcTwo.h
inline constexpr uint32_t kPrimaryDisplay = 0;   
  
class HwcDisplay {    
      uint32_t last_display_handle_ = kPrimaryDisplay;
      //typedef uint64_t hwc2_display_t;
      //typedef uint64_t hwc2_display_t;
      std::map<hwc2_display_t, std::unique_ptr<HwcDisplay>> displays_;
      std::map<DrmDisplayPipeline *, hwc2_display_t> display_handles_;
    
      // PipelineToFrontendBindingInterface
      //创建HwcDisplay
      bool BindDisplay(DrmDisplayPipeline *pipeline) override;
      //销毁HwcDisplay
      bool UnbindDisplay(DrmDisplayPipeline *pipeline) override;
      //完成显示绑定，发送display插拔事件给SurfaceFlinger，告知SurfaceFlinger当前显示设备的状态
      void FinalizeDisplayBinding() override;
}

我们先看看BindDisplay和UnbindDisplay的实现！

//hwc2_device/DrmHwcTwo.cpp
bool DrmHwcTwo::BindDisplay(DrmDisplayPipeline *pipeline) {
  if (display_handles_.count(pipeline) != 0) {
    ALOGE("%s, pipeline is already used by another display, FIXME!!!: %p",
          __func__, pipeline);
    return false;
  }

  uint32_t disp_handle = kPrimaryDisplay;

  if (displays_.count(kPrimaryDisplay) != 0 &&
      !displays_[kPrimaryDisplay]->IsInHeadlessMode()) {
    disp_handle = ++last_display_handle_;
  }

  if (displays_.count(disp_handle) == 0) {
    /* Create a new HwcDisplay */
    auto disp = std::make_unique<HwcDisplay>(disp_handle,
                                             HWC2::DisplayType::Physical, this);
    //填充displays_容器
    displays_[disp_handle] = std::move(disp);
  }

  ALOGI("Attaching pipeline '%s' to the display #%d%s",
        pipeline->connector->Get()->GetName().c_str(), (int)disp_handle,
        disp_handle == kPrimaryDisplay ? " (Primary)" : "");
  //给HwcDisplay设置pipeline
  displays_[disp_handle]->SetPipeline(pipeline);
  //填充display_handles_容器
  display_handles_[pipeline] = disp_handle;

  return true;
}

bool DrmHwcTwo::UnbindDisplay(DrmDisplayPipeline *pipeline) {
  if (display_handles_.count(pipeline) == 0) {
    ALOGE("%s, can't find the display, pipeline: %p", __func__, pipeline);
    return false;
  }
  auto handle = display_handles_[pipeline];
  display_handles_.erase(pipeline);

  ALOGI("Detaching the pipeline '%s' from the display #%i%s",
        pipeline->connector->Get()->GetName().c_str(), (int)handle,
        handle == kPrimaryDisplay ? " (Primary)" : "");

  if (displays_.count(handle) == 0) {
    ALOGE("%s, can't find the display, handle: %" PRIu64, __func__, handle);
    return false;
  }
  displays_[handle]->SetPipeline(nullptr);

  /* We must defer display disposal and removal, since it may still have pending
   * HWC_API calls scheduled and waiting until ueventlistener thread releases
   * main lock, otherwise transaction may fail and SF may crash
   */
  if (handle != kPrimaryDisplay) {
    displays_for_removal_list_.emplace_back(handle);
  }
  return true;
}

上述的主要逻辑就是通过前面构建出来的DrmDisplayPipeline和新构建的HwcDisplay填充displays_和display_handles_容器。这里我们接着看下HwcDisplay的实现！

//hwc2_device/HwcDisplay.h
/**
 * @brief 
 * 这里的HwcDisplay是HWC2::Display在HAL层的实现，
 * 它负责管理一个Display的配置和状态，
 * 包括创建和销毁Layer，
 * 以及处理Display的配置和状态变化。
 * 
 * 它还负责处理Display的HWC Hooks，
 * 例如AcceptDisplayChanges、CreateLayer、DestroyLayer等。
 * 
 * 它还负责处理Display的VSync事件，
 * 例如处理VSync事件、发送VSync事件等。
 * 
 * 它还负责处理Display的HWC2::Error，
 * 例如处理HWC2::Error等。
 *
 */
class HwcDisplay {
    HwcDisplay(hwc2_display_t handle, HWC2::DisplayType type, DrmHwcTwo *hwc2);
    
    /* SetPipeline should be carefully used only by DrmHwcTwo hotplug handlers */
   void SetPipeline(DrmDisplayPipeline *pipeline);
   
  HWC2::Error CreateComposition(AtomicCommitArgs &a_args);
  std::vector<HwcLayer *> GetOrderLayersByZPos();
  
  // HWC Hooks
  HWC2::Error AcceptDisplayChanges();
  HWC2::Error CreateLayer(hwc2_layer_t *layer);  

  const Backend *backend() const;
  void set_backend(std::unique_ptr<Backend> backend);  
}

这里要怎么理解这个HwcDisplay呢?这里的HwcDisplay是HWC2::Display在HAL层的实现,它的核心功能主要是:

  • 它负责管理一个Display的配置和状态，包括创建和销毁Layer，以及处理Display的配置和状态变化。
  • 它还负责处理Display的HWC Hooks，例如AcceptDisplayChanges、CreateLayer、DestroyLayer等。
  • 它还负责处理Display的VSync事件，例如处理VSync事件、发送VSync事件等。
  • 它还负责处理Display的HWC2::Error，例如处理HWC2::Error等。

我们接着继续看下HwcDisplay的构造,比较简单:

HwcDisplay::HwcDisplay(hwc2_display_t handle, HWC2::DisplayType type,
                       DrmHwcTwo *hwc2)
    : hwc2_(hwc2),//关联的DrmHwcTwo对象
      handle_(handle),//typedef uint64_t hwc2_display_t;   handle本质就是一个uint64_t整数值
      type_(type),// Physical 物理屏幕
      color_transform_hint_(HAL_COLOR_TRANSFORM_IDENTITY) {
    ...
}

接着继续来看下HwcDisplay::SetPipeline

void HwcDisplay::SetPipeline(DrmDisplayPipeline *pipeline) {
  pipeline_ = pipeline;

  if (pipeline != nullptr) {//会进入这个分支
    ChosePreferredConfig();
    Init();//调用HwcDisplay::Init()逻辑

    hwc2_->ScheduleHotplugEvent(handle_, /*connected = */ true);
  } else {
    ...
  }
}


HWC2::Error HwcDisplay::Init() {
  if (!IsInHeadlessMode()) {
    //通过后端管理为HwcDisplay设置后端，这个后端是干什么的呢  
    ret = BackendManager::GetInstance().SetBackendForDisplay(this);
    if (ret) {
      ALOGE("Failed to set backend for d=%d %d\n", int(handle_), ret);
      return HWC2::Error::BadDisplay;
    }
  }
}

这里又是后端管理BackendManager，又是后端Backend！要怎么理解呢？

既然有了backend，那么肯定有frontend，那么谁是backend ，谁是frontend? 扮演的角色功能分别是什么？

初步看起来貌似是：

  • frontend 对外提供调用的接口，外部使用者呼叫 front end 暴漏出的接口来呼叫某一功能；
  • backend 内部的实现逻辑，是前端接口功能的内部实现，是真正做事的地方；

太多了，太多了。完全放在一篇里面不够。今天先这样了，后续drm_hwcomposer另起一篇完成余下的相关分析！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/670443.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

yolov8使用：数据格式转换（目标检测、图像分类）多目标跟踪

yolov8使用：数据格式转换（目标检测、图像分类）多目标跟踪

安装 yolov8地址&#xff1a;https://github.com/ultralytics/ultralytics git clone https://github.com/ultralytics/ultralytics.git安装环境&#xff1a; pip install ultralytics -i https://pypi.tuna.tsinghua.edu.cn/simple目标检测 标注格式转换 若使用 labelimg…
阅读更多...
sql注入-布尔盲注

sql注入-布尔盲注

布尔盲注&#xff08;Boolean Blind SQL Injection&#xff09;是一种SQL注入攻击技术&#xff0c;用于在无法直接获得查询结果的情况下推断数据库信息&#xff1b;它通过发送不同的SQL查询来观察应用程序的响应&#xff0c;进而判断查询的真假&#xff0c;并逐步推断出有用的信…
阅读更多...
微服务学习Day9

微服务学习Day9

文章目录 分布式事务seata引入理论基础CAP定理BASE理论 初识Seata动手实践XA模式AT模式TCC模式SAGA模式 高可用 分布式事务seata 引入 理论基础 CAP定理 BASE理论 初识Seata 动手实践 XA模式 AT模式 TCC模式 Service Slf4j public class AccountTCCServiceImpl implements A…
阅读更多...
C语言 | Leetcode C语言题解之第126题单词接龙II

C语言 | Leetcode C语言题解之第126题单词接龙II

题目&#xff1a; 题解&#xff1a; char** list; int** back; int* backSize;// DFS uses backtrack information to construct results void dfs(char*** res, int* rSize, int** rCSizes, int* ans, int last, int retlevel) {int i ans[last];if (i 0) {res[*rSize] (c…
阅读更多...
DALL·E 2详解：人工智能如何将您的想象力变为现实！

DALL·E 2详解：人工智能如何将您的想象力变为现实！

引言 DALLE 2是一个基于人工智能的图像生成模型&#xff0c;它通过理解自然语言描述来生成匹配这些描述的图像。这一模型的核心在于其创新的两阶段工作流程&#xff0c;首先是将文本描述转换为图像表示&#xff0c;然后是基于这个表示生成具体的图像。 下面详细介绍DALL-E2的功…
阅读更多...
Vivado Design Suite一级物件

Vivado Design Suite一级物件

Vivado Design Suite一级物件 按设计过程导航内容 Xilinx文档围绕一组标准设计流程进行组织&#xff0c;以帮助您 查找当前开发任务的相关内容。本文件涵盖 以下设计过程&#xff1a; •硬件、IP和平台开发&#xff1a;为硬件创建PL IP块 平台&#xff0c;创建PL内核&#xff0…
阅读更多...
HTML的标签（标题、段落、文本、图片、列表）

HTML的标签（标题、段落、文本、图片、列表）

HTML的标签1 标题标签&#xff1a;段落标签&#xff1a;文本标签&#xff1a;图片标签:列表标签&#xff1a;有序列表&#xff1a;无序列表&#xff1a;定义列表&#xff1a;列表案例&#xff1a; 标题标签&#xff1a; 标签&#xff1a;h1~h6 注意&#xff1a;如果使用无效标…
阅读更多...
C语言怎样写数据⽂件，使之可以在不同字⼤⼩、 字节顺序或浮点格式的机器上读⼊？

C语言怎样写数据⽂件，使之可以在不同字⼤⼩、 字节顺序或浮点格式的机器上读⼊？

一、问题 怎样写数据⽂件&#xff0c;使之可以在不同字⼤⼩、字节顺序或浮点格式的机器上读⼊&#xff0c;也就是说怎样写⼀个可移植性好的数据⽂件&#xff1f; 二、解答 最好的移植⽅法是使⽤⽂本⽂件&#xff0c;它的每⼀字节放⼀个 ASCII 代码&#xff0c;代表⼀个字符。 …
阅读更多...
从JS角度直观理解递归的本质

从JS角度直观理解递归的本质

让我们写一个函数 pow(x, n)&#xff0c;它可以计算 x 的 n 次方。换句话说就是&#xff0c;x 乘以自身 n 次。 有两种实现方式。 迭代思路&#xff1a;使用 for 循环&#xff1a; function pow(x, n) {let result 1;// 在循环中&#xff0c;用 x 乘以 result n 次for (let i…
阅读更多...
短时间内如何顺利通过 Java 面试？

短时间内如何顺利通过 Java 面试？

今天我们来探讨一个重要的话题&#xff1a;短时间内如何顺利通过 Java 面试&#xff1f; 在此之前&#xff0c;我正在精心编写一套完全面向小白的 Java 自学教程&#xff0c;我相信这套教程会非常适合正在努力提升的你。教程里面涵盖了丰富全面的编程教学内容、详细生动的视频…
阅读更多...
2.8Flowmap的实现

2.8Flowmap的实现

一、Flowmap 是什么 半条命2中水的流动 求生之路2中的水的流动 这种方式原理简单&#xff0c;容易实现&#xff0c;运算量少&#xff0c;如今也还在使用 1.flowmap的实质 Flow map(流向图) &#xff0c;一张记录了2D向量信息的纹理&#xff0c;Flow map上的颜色(通常为RG通道…
阅读更多...
Python知识点14---被规定的资源

Python知识点14---被规定的资源

提前说一点&#xff1a;如果你是专注于Python开发&#xff0c;那么本系列知识点只是带你入个门再详细的开发点就要去看其他资料了&#xff0c;而如果你和作者一样只是操作其他技术的Python API那就足够了。 在Python中被规定的东西不止有常识中的那些关键字、构造器等编程语言…
阅读更多...
Vue3-Ref Reactive toRef toRefs对比学习、标签ref与组件ref

Vue3-Ref Reactive toRef toRefs对比学习、标签ref与组件ref

响应式数据&#xff1a; Ref 作用&#xff1a;定义响应式变量。 语法&#xff1a;let xxx ref(初始值)(里面可以是任何规定内类型、数组等)。 返回值&#xff1a;一个RefImpl的实例对象&#xff0c;简称ref对象或ref&#xff0c;ref对象的value属性是响应式的。 注意点&am…
阅读更多...
公网如何访问内网？

公网如何访问内网？

公网和内网已经成为我们生活中不可或缺的存在。由于内网的安全性考虑&#xff0c;公网无法直接访问内网资源。如何实现公网访问内网呢&#xff1f;本文将介绍一种名为【天联】的私有通道技术&#xff0c;通过安全加密&#xff0c;保障数据传输的安全性。 【天联】私有通道技术 …
阅读更多...
利用Python处理DAX多条件替换

利用Python处理DAX多条件替换

小A&#xff1a;白茶&#xff0c;救命啊~~~ 白茶&#xff1a;什么情况&#xff1f; 小A&#xff1a;是这样的&#xff0c;最近不是临近项目上线嘛&#xff0c;有一大波度量值需要进行类似的调整&#xff0c;一个两个倒没啥&#xff0c;600多个&#xff0c;兄弟&#xff0c;救命…
阅读更多...
STM32_FSMC_HAL（介绍）

STM32_FSMC_HAL（介绍）

FSMC&#xff08;Flexible Static Memory Controller&#xff09;是STM32微控制器中的一种内存控制器&#xff0c;它允许微控制器与外部存储器接口&#xff0c;如SRAM、NOR Flash、NAND Flash和PSRAM等。FSMC特别适用于需要高速数据交换和大量数据存储的应用场景。 典型应用&a…
阅读更多...
06.持久化存储

06.持久化存储

6.持久化存储 pv: persistent volume 全局的资源 pv&#xff0c;node pvc: persistent volume claim 局部的资源&#xff08;namespace&#xff09;pod&#xff0c;rc&#xff0c;svc 6.1:安装nfs服务端(192.168.111.11) yum install nfs-utils.x86_64 -y mkdir /data vim /…
阅读更多...
Linux——多线程(二)

Linux——多线程(二)

在上一篇博客中我们已经介绍到了线程控制以及对应的函数调用接口&#xff0c;接下来要讲的是真正的多线程&#xff0c;线程安全、线程互斥、同步以及锁。 一、多线程 简单写个多线程的创建、等待的代码 #include<iostream> #include<pthread.h> #include<un…
阅读更多...
【案例实操】银河麒麟桌面操作系统实例分享，V10SP1重启后网卡错乱解决方法

【案例实操】银河麒麟桌面操作系统实例分享，V10SP1重启后网卡错乱解决方法

1.问题现象 8 个网口&#xff0c; 命名从 eth1 开始到 eth8。 目前在系统 grub 里面加了 net.ifnames0 biosdevname0 参数&#xff0c; 然后在 udev 规则中加了一条固定网卡和硬件 pci 设备号的规则文件。 最后在 rc.local 中加了两条重新安装网卡驱动的命令&#xff08; rmmod…
阅读更多...
yolov10模块

yolov10模块

yolov10模块 1 C2f2 C2fCIB2.1 CIB2.2 RepVGGDW 3 PSA4 SCDown5 v10Detect 论文代码&#xff1a;https://github.com/THU-MIG/yolov10 论文链接&#xff1a;https://arxiv.org/abs/2405.14458 Conv是Conv2dBNSiLU PW是Pointwise Convolution(逐点卷积) DW是Depthwise Convolut…
阅读更多...
最新文章

Copyright @ 2022~2023