Android下HWC以及drm_hwcomposer普法(下)

引言

不容易啊，写到这里。经过前面的普法(上)，我相信童鞋们对HWC和drm_hwcomposer已经有了一定的认知了。谷歌出品，必须精品。我们前面的篇章见分析到啥来了，对了分析到了HwcDisplay::init，然后设置Backend后端来着！

---

一.如何理解drm_hwcomposer的backend

在正式分析drm_hwcomposer的实现前，我们先看下drm_hwcomposer下backend文件夹目录，如下:

并且它们之间存在这如下的关系:

这里的BackendManager的比较好理解，即是用来管理Backend的，那么Backend和BackendClient我们要如何理解呢？通过上面的关系图可以看出来BackendClient继承了BackendClient，并且重写了ValidateDisplay，其它的基本都一致！

• Backend:一个后端的实现，注册为”generic”，主要是定义了ValidateDisplay方法，这个方法用来设置可见的HwcLayer应该采用什么合成方式

• BackendClient:一个后端的实现，注册为”client”，主要是定义了ValidateDisplay方法，它把所有HwcLayer都设置成立Client合成方式

• BackendManager:后端的管理器，用来根据Device name从已注册的backend列表中选择一个，设置给HwcDisplay；GetBackendByName就是通过Device name来从available_backends_中选择一个匹配的Backend构造函数来构建后端对象。

// backend/Backend.h
class Backend {
 public:
  virtual ~Backend() = default;
  // Validates the display and returns the number of supported display
  // types and the number of supported display requests.
  //
  // Returns:
  //   HWC2::Error::SUCCESS if the display is valid.
  //   HWC2::Error::BAD_DISPLAY if the display is invalid.
  virtual HWC2::Error ValidateDisplay(HwcDisplay *display, uint32_t *num_types,
                                      uint32_t *num_requests);
  //获取需要client(GPU)合成的Layer                                    
  virtual std::tuple<int, size_t> GetClientLayers(
      HwcDisplay *display, const std::vector<HwcLayer *> &layers);
  //判断是否是client合成
  virtual bool IsClientLayer(HwcDisplay *display, HwcLayer *layer);

 protected:
  // 判断当前的layerType是否支持合成
  static bool HardwareSupportsLayerType(HWC2::Composition comp_type);
  //计算像素数量
  static uint32_t CalcPixOps(const std::vector<HwcLayer *> &layers,
                             size_t first_z, size_t size);
  //标记相关layer合成状态
  static void MarkValidated(std::vector<HwcLayer *> &layers,
                            size_t client_first_z, size_t client_size);
  //计算扩大额外的需要为client合成的layers
  static std::tuple<int, int> GetExtraClientRange(
      HwcDisplay *display, const std::vector<HwcLayer *> &layers,
      int client_start, size_t client_size);
};

//backend/BackendClient.h
class BackendClient : public Backend {
 public:
  HWC2::Error ValidateDisplay(HwcDisplay *display, uint32_t *num_types,
                              uint32_t *num_requests) override;
};

//backend/BackendClient.cpp
HWC2::Error BackendClient::ValidateDisplay(HwcDisplay *display,
                                           uint32_t *num_types,
                                           uint32_t * /*num_requests*/) {
  for (auto &[layer_handle, layer] : display->layers()) {
    //设置所有的layer的合成方式都为client
    layer.SetValidatedType(HWC2::Composition::Client);
    ++*num_types;
  }
  return HWC2::Error::HasChanges;
}

好了，这里我们了解初步认知了backend了，我们接下来看看两种backend是如何注册到BackendManager进行管理的！

1.1 Backend是如何注册的

通过前面的分析我们知道了有两种backend，这里我们看下它们是如何注册到BackendManager然后被管理的！

namespace android {
    ...
    REGISTER_BACKEND("client", BackendClient);
    ...

}  // namespace android

//backend/Backend.cpp
namespace android {
    ...
    REGISTER_BACKEND("generic", Backend);
    ...

}  // namespace android



//backend/BackendManager.h
#define REGISTER_BACKEND(name_str_, backend_)                               \
  static int                                                                \
      backend = BackendManager::GetInstance()                               \
                    .RegisterBackend(name_str_,                             \
                                     []() -> std::unique_ptr<Backend> {     \
                                       return std::make_unique<backend_>(); \
                                     });

//std::map<std::string, BackendConstructorT> available_backends_;
//using BackendConstructorT = std::function<std::unique_ptr<Backend>()>;
int BackendManager::RegisterBackend(const std::string &name,
                                    BackendConstructorT backend_constructor) {
  //将backend_constructor函数指针存入available_backends_中
  available_backends_[name] = std::move(backend_constructor);
  return 0;
}

通过上述源码可以看到BackendManager对backend的注册管理比较简单，就是将backend实存入现available_backends_中！

1.2 HwcDisplay如何选择合适的Backend

还记得我们前面已经创建好了HwcDisplay，然后也进行Init初始化了了，在Init中会设置它的Backend后端，我们看下是如何选择Backend！

//hwc2_device/HwcDisplay.cpp
HWC2::Error HwcDisplay::Init() {
  if (!IsInHeadlessMode()) {
    //通过后端管理为HwcDisplay设置后端，这个后端是干什么的呢  
    ret = BackendManager::GetInstance().SetBackendForDisplay(this);
  }
}



//backend/BackendManager.cpp
int BackendManager::SetBackendForDisplay(HwcDisplay *display) {
  std::string driver_name(display->GetPipe().device->GetName());
  char backend_override[PROPERTY_VALUE_MAX];
  property_get("vendor.hwc.backend_override", backend_override,
               driver_name.c_str());
  //如果backend_override为空，则使用默认的backend
  //如果backend_override不为空，则使用backend_override
  std::string backend_name(backend_override);

  //根据backend_name获取对应的backend
  //如果找不到，则使用默认的backend
  //如果找不到默认的backend，则返回错误
  //如果成功，则将backend设置给display
  display->set_backend(GetBackendByName(backend_name));
  ...
  return 0;
}

这里我们只要明白的一点就是，绝大部分情况下使用的backend都是"generic"而不是"client"。

---

二. HWC的实现drm_hwcomposer是如何为Layer选择合适的合成方式的

怎么这个标题这么拗口呢，通俗的说就是如何为每个图层选择合成方式，比如壁纸啊，状态栏啊，导航栏啊，应用啊这些图层是如何合成的，是GPU呢还是hwc硬件合成呢。

2.1 合成策略的选择如何从SurfaceFlinger传递到drm_hwcomposer

说到这个得从SurfaceFlinger中Output::prepareFrame说起来了。

它的核心逻辑是选择合成策略，判断是device还是GPU合成，如果是device合成，直接present，如果要走GPU合成则需要validate。让我们通过代码具体分析:

文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

void Output::prepareFrame() {

    ...
    const auto& outputState = getState();
    if (!outputState.isEnabled) {
        return;
    }
    // 选择合成类型，如果是device合成，则跳过validate，直接present送显
    chooseCompositionStrategy();
    // 把合成类型送到frameBufferSurface，没啥逻辑
    mRenderSurface->prepareFrame(outputState.usesClientComposition,
                                 outputState.usesDeviceComposition);
}

void Output::chooseCompositionStrategy() {
    // The base output implementation can only do client composition
    // 默认使用GPU合成,针对没有hwc的设备
    auto& outputState = editState();
    outputState.usesClientComposition = true;
    outputState.usesDeviceComposition = false;
    outputState.reusedClientComposition = false;
}

文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp

void Display::chooseCompositionStrategy() {

    ...
    // Default to the base settings -- client composition only.
    Output::chooseCompositionStrategy();

    ...

    // Get any composition changes requested by the HWC device, and apply them.
    std::optional<android::HWComposer::DeviceRequestedChanges> changes;
    auto& hwc = getCompositionEngine().getHwComposer();
    // 从HWC device获得合成类型的改变，这个根据hwc能力来选择device还是GPU合成
    if (status_t result = hwc.getDeviceCompositionChanges(*mId, anyLayersRequireClientComposition(),
                                                          &changes);
        result != NO_ERROR) {
        ALOGE("chooseCompositionStrategy failed for %s: %d (%s)", getName().c_str(), result,
              strerror(-result));
        return;
    }
    //如果有变化则设置给对应的layer
    if (changes) {
        applyChangedTypesToLayers(changes->changedTypes);
        applyDisplayRequests(changes->displayRequests);
        applyLayerRequestsToLayers(changes->layerRequests);
        applyClientTargetRequests(changes->clientTargetProperty);
    }

    // Determine what type of composition we are doing from the final state
    // 决定最后的合成类型
    auto& state = editState();
    state.usesClientComposition = anyLayersRequireClientComposition();
    state.usesDeviceComposition = !allLayersRequireClientComposition();
}

文件：frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp

status_t HWComposer::getDeviceCompositionChanges(
        DisplayId displayId, bool frameUsesClientComposition,
        std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {


    ...
    if (!frameUsesClientComposition) {
        sp<Fence> outPresentFence;
        uint32_t state = UINT32_MAX;
         // 如果所有的layer都能走device合成，则在hwc里面直接present，若有不支持device合成的情况，则走GPU合成，会走validate逻辑
        error = hwcDisplay->presentOrValidate(&numTypes, &numRequests, &outPresentFence , &state);
        if (!hasChangesError(error)) {
            RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
        }
        if (state == 1) { //Present Succeeded.
            // present成功，数据直接提交给了hwc
            std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
            error = hwcDisplay->getReleaseFences(&releaseFences);
            displayData.releaseFences = std::move(releaseFences);
            displayData.lastPresentFence = outPresentFence;
            displayData.validateWasSkipped = true;
            displayData.presentError = error;
            return NO_ERROR;
        }
 // Present failed but Validate ran.
    } else {
        // 这个分支走不到
        error = hwcDisplay->validate(&numTypes, &numRequests);
    }
   // 接收hwc过来的change，对于device合成不走，GPU合成走的逻辑，这个后续GPU合成专门分析
   ...

prepareFrame 的作用是根据hwc的能力选择合成方式，如果是device能全部合成所有的则直接走hwc present上屏，如果是只能接收部分layer进行device，则会将部分layer进行GPU合成然后将合成后的layer传递给hwc。那我们接下来看看hwc的实现是如何决定layer的合成方式的。

2.2 drm_hwcomposer如何决定layer的合成方式

我们先梳理下drm_hwcomposer是如何相应上层ssurfaceflinger的presentOrValidate的！

    case HWC2::FunctionDescriptor::ValidateDisplay:
      return ToHook<HWC2_PFN_VALIDATE_DISPLAY>(
          DisplayHook<decltype(&HwcDisplay::ValidateDisplay),
                      &HwcDisplay::ValidateDisplay, uint32_t *, uint32_t *>);
                      
 
 
HWC2::Error HwcDisplay::ValidateDisplay(uint32_t *num_types,
                                        uint32_t *num_requests) {
  if (IsInHeadlessMode()) {
    *num_types = *num_requests = 0;
    return HWC2::Error::None;
  }
  //通过后端来决定layer的合成方式
  return backend_->ValidateDisplay(this, num_types, num_requests);
}                

去调用到HwcDisplay绑定的后端的具体validate方法，根据前面的分析这个后端通常是Backend::ValidateDisplay，并且这个方法代码有一定的长度，所以童鞋们一定要有耐心，让我们慢慢来进行分析！

//backend/Backend.cpp
HWC2::Error Backend::ValidateDisplay(HwcDisplay *display, uint32_t *num_types,
                                     uint32_t *num_requests) {
  *num_types = 0;//表示多少layer需要client合成
  *num_requests = 0;

  // 按Z-order顺序排列的HwcLayer的集合,这些layer是怎么生成的，这个前面源码已经分析过了
  auto layers = display->GetOrderLayersByZPos();

  int client_start = -1;//表示所有layres中需要client合成layer的起始位置
  size_t client_size = 0;//表示所有layres中需要client合成layer的数量

  //通常不会进入这个分支
  if (display->ProcessClientFlatteningState(layers.size() <= 1)) {
    display->total_stats().frames_flattened_++;
    client_start = 0;
    client_size = layers.size();
    //设置合成类型，client_start到client_start+client_size之间的设置为client,其它的设置为device
    MarkValidated(layers, client_start, client_size);
  } else {
    std::tie(client_start, client_size) = GetClientLayers(display, layers);//核心实现，标记那些layer需要client合成
    //设置合成类型，client_start到client_start+client_size之间的设置为Client,其它的设置为Device
    MarkValidated(layers, client_start, client_size);
    //只有一个情况testing_needed为flase，所有的layers都是client_layer
    bool testing_needed = !(client_start == 0 && client_size == layers.size());

    AtomicCommitArgs a_args = {.test_only = true};
    //尝试送显示一次，如果失败，则将所有的layer都标记为client合成，有点你device不行的话，那我就让gpu全部干了算了味道
    if (testing_needed &&
        display->CreateComposition(a_args) != HWC2::Error::None) {
      ++display->total_stats().failed_kms_validate_;
      client_start = 0;
      client_size = layers.size();
      MarkValidated(layers, 0, client_size);
    }
  }

  *num_types = client_size;

  display->total_stats().gpu_pixops_ += CalcPixOps(layers, client_start,
                                                   client_size);
  display->total_stats().total_pixops_ += CalcPixOps(layers, 0, layers.size());
  //如果需要client合成，则返回HWC2::Error::HasChanges
  //否则返回HWC2::Error::None，然后上层SurfaceFlinger根据这个返回值
  //来判断是否需要进行gpu介入对其它标记为client layer通过GPU合成
  return *num_types != 0 ? HWC2::Error::HasChanges : HWC2::Error::None;
}

std::tuple<int, size_t> Backend::GetClientLayers(
    HwcDisplay *display, const std::vector<HwcLayer *> &layers) {
  int client_start = -1;
  size_t client_size = 0;
  //遍历所有的layer，判断那些layer需要强制client合成
  //client_start表示所有layer中需要client合成layer的起始位置
  //client_size表示所有layer中需要client合成layer的数量
  //client_start和client_size的计算逻辑是：
  //1. 遍历所有layer，找到第一个需要client合成layer的起始位置
  //2. 遍历所有layer，找到最后一个需要client合成layer的结束位置
  //3. 计算client_size = 最后一个需要client合成layer的结束位置 - 第一个需要client合成layer的起始位置 + 1
  //4. 得到client_start和client_size
  //并且这里可以看到如果clinet_start和被其它标记为client layer之间有间隔，间隔的layer也会被标记为client_layer
  for (size_t z_order = 0; z_order < layers.size(); ++z_order) {
    if (IsClientLayer(display, layers[z_order])) {
      if (client_start < 0)
        client_start = (int)z_order;
      client_size = (z_order - client_start) + 1;
    }
  }
  //扩大额外的需要为client的layers
  return GetExtraClientRange(display, layers, client_start, client_size);
}

//判断layer是不是必须为client合成或者已经指定了client合成
/**
 * @brief 
判断指定的Layer是否要Client合成，满足其中一个条件即可：
  1. HardwareSupportsLayerType硬件不支持的合成方式
  2. IsHandleUsable buffer handle无法转为DRM要求的buffer object
  3. color_transform_hint !=HAL_COLOR_TRANSFORM_IDENTITY
  4. 需要scale or phase,但hwc强制GPU来处理
 */
bool Backend::IsClientLayer(HwcDisplay *display, HwcLayer *layer) {
  return !HardwareSupportsLayerType(layer->GetSfType()) ||
         !BufferInfoGetter::GetInstance()->IsHandleUsable(layer->GetBuffer()) ||
         display->color_transform_hint() != HAL_COLOR_TRANSFORM_IDENTITY ||
         (layer->RequireScalingOrPhasing() &&
          display->GetHwc2()->GetResMan().ForcedScalingWithGpu());
}

bool Backend::HardwareSupportsLayerType(HWC2::Composition comp_type) {
  return comp_type == HWC2::Composition::Device ||
         comp_type == HWC2::Composition::Cursor;
}
//计算连续几个layer的像素点之和
uint32_t Backend::CalcPixOps(const std::vector<HwcLayer *> &layers,
                             size_t first_z, size_t size) {
  uint32_t pixops = 0;
  for (size_t z_order = 0; z_order < layers.size(); ++z_order) {
    if (z_order >= first_z && z_order < first_z + size) {
      hwc_rect_t df = layers[z_order]->GetDisplayFrame();
      pixops += (df.right - df.left) * (df.bottom - df.top);
    }
  }
  return pixops;
}

//根据start和size标记那些layer需要client合成，那些需要device合成
void Backend::MarkValidated(std::vector<HwcLayer *> &layers,
                            size_t client_first_z, size_t client_size) {
  for (size_t z_order = 0; z_order < layers.size(); ++z_order) {
    if (z_order >= client_first_z && z_order < client_first_z + client_size)
      //标记该layer的合成方式是client
      layers[z_order]->SetValidatedType(HWC2::Composition::Client);
    else
      //标记该layer的合成方式是device
      layers[z_order]->SetValidatedType(HWC2::Composition::Device);
  }
}

std::tuple<int, int> Backend::GetExtraClientRange(
    HwcDisplay *display, const std::vector<HwcLayer *> &layers,
    int client_start, size_t client_size) {
  auto planes = display->GetPipe().GetUsablePlanes();//获取整个drm支持的planes的数量
  size_t avail_planes = planes.size();

  /*
   * If more layers then planes, save one plane
   * for client composited layers
   */
  //如果layer的数量大于plane的数量，则保留一个plane用于target client layer
  //这个target client layer是用来存放所有被client layer通过GPU合成后的layer的
  if (avail_planes < display->layers().size())
    avail_planes--;//保留一个用于存放所有client合成的layer

  int extra_client = int(layers.size() - client_size) - int(avail_planes);//计算剩余需要成为client的数量

  if (extra_client > 0) {
    int start = 0;
    size_t steps = 0;
    if (client_size != 0) {//有layer指定了client合成
      int prepend = std::min(client_start, extra_client);//计算可以从前面插入的layer的数量
      int append = std::min(int(layers.size()) -
                                int(client_start + client_size),
                            extra_client);//计算可以从后面插入的layer的数量
      start = client_start - (int)prepend;//计算插入的起始位置
      client_size += extra_client;//计算client合成的layer数量
      steps = 1 + std::min(std::min(append, prepend),
                           int(layers.size()) - int(start + client_size));
    } else {//没有layer指定了client合成。代码分析
      client_size = extra_client;//剩余的都是client
      steps = 1 + layers.size() - extra_client;//计算可以移动计算的step范围
    }
    //选择像素之和最少的连续layers
    uint32_t gpu_pixops = UINT32_MAX;
    for (size_t i = 0; i < steps; i++) {
      uint32_t po = CalcPixOps(layers, start + i, client_size);
      if (po < gpu_pixops) {
        gpu_pixops = po;
        client_start = start + int(i);
      }
    }
  }
  //返回client合成的起始位置和layer数量
  return std::make_tuple(client_start, client_size);
}

上述标记逻辑已经给出来了比较详细的源码解释，就不过多阐述了。我们只需要抓住几个重点的方法，了解清楚其功能就问题不大了:

• IsClientLayer：判断指定的Layer是否强制要Client合成

• GetExtraClientRange： 进一步标记client layer, 当layer的数量多于hwc支持的planes时，需要留出一个给 client target

• CalcPixOps:计算相邻layer之间的像素和

---

三. drm_hwcomposer最终如何输出到显示设备

葵花宝典终于要练成了，要想成功必须自宫，错了重来，要想成功必须发狠。革命尚未成功，通知仍需努力！

我们接着看drm_hwcomposer是如何接收HWC命令，将最终图层layer显示到输出设备的。那么这个就得从Output::postFramebuffer说起了！

3.1 drm_hwcomposer是如何接收到显示命令的

我们接着看drm_hwcomposer是如何接收HWC命令，将最终图层layer显示到输出设备的。那么这个就得从Output::postFramebuffer说起了！

文件：frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

void Output::postFramebuffer() {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);
   ...
    auto frame = presentAndGetFrameFences();

    mRenderSurface->onPresentDisplayCompleted();
    ...
}
   

文件：frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp
status_t HWComposer::presentAndGetReleaseFences(DisplayId displayId) {
    ATRACE_CALL();
    
    RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);
        
    auto& displayData = mDisplayData[displayId];
    auto& hwcDisplay = displayData.hwcDisplay;
    
     ...
    // GPU合成时执行present，返回present fence
    auto error = hwcDisplay->present(&displayData.lastPresentFence);
    RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);

    std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
    // 从hwc里面获得release fence
    error = hwcDisplay->getReleaseFences(&releaseFences);
    RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);

    displayData.releaseFences = std::move(releaseFences);

    return NO_ERROR;
}

文件： frameworks/native/services/surfaceflinger/DisplayHardware/FramebufferSurface.cpp

void FramebufferSurface::onFrameCommitted() {
    if (mHasPendingRelease) {
        sp<Fence> fence = mHwc.getPresentFence(mDisplayId);
        if (fence->isValid()) {
            // 更新BufferSlot的 fence
            status_t result = addReleaseFence(mPreviousBufferSlot,
                    mPreviousBuffer, fence);
            ALOGE_IF(result != NO_ERROR, "onFrameCommitted: failed to add the"
                    " fence: %s (%d)", strerror(-result), result);
        }
        // 释放之前的Buffer
        status_t result = releaseBufferLocked(mPreviousBufferSlot, mPreviousBuffer);
        ALOGE_IF(result != NO_ERROR, "onFrameCommitted: error releasing buffer:"
                " %s (%d)", strerror(-result), result);
    
        mPreviousBuffer.clear();
        mHasPendingRelease = false;
    }
}

3.2 drm_hwcomposer是如何处理到显示逻辑的

有了前面的铺垫，我们应该很容易找到drm_hwcomposer处理present的入口，我们看看:

//hwc2_device/hwc2_device.cpp
    case HWC2::FunctionDescriptor::PresentDisplay:
      return ToHook<HWC2_PFN_PRESENT_DISPLAY>(
          DisplayHook<decltype(&HwcDisplay::PresentDisplay),
                      &HwcDisplay::PresentDisplay, int32_t *>);
                      
                      
//
HWC2::Error HwcDisplay::PresentDisplay(int32_t *present_fence) {
    ...
      //是不是好像SurfaceFlinger里面的compositionengine::CompositionRefreshArgs refreshArgs
      ret = CreateComposition(a_args);    
    ...
}


//drm_hwcomposer处理合成显示的核心方法
HWC2::Error HwcDisplay::CreateComposition(AtomicCommitArgs &a_args) {
  if (IsInHeadlessMode()) {//无头模式，即该HwcDisplay对应的drmpipe显示管线为空
    ALOGE("%s: Display is in headless mode, should never reach here", __func__);
    return HWC2::Error::None;
  }

  int PrevModeVsyncPeriodNs = static_cast<int>(
      1E9 / GetPipe().connector->Get()->GetActiveMode().v_refresh());

  auto mode_update_commited_ = false; // 是否需要更新/提交
  if (staged_mode_ && // staged_mode_ 当前所处的显示模式
      staged_mode_change_time_ <= ResourceManager::GetTimeMonotonicNs()) {
    //这里的client_layer_是HwcDisplay的成员变量，它是一个HwcLayer对象，是用来存储前面标记为cleint合成layer使用gpu合成后的图层
    //client_layer_的成员变量SetLayerDisplayFrame()用于设置图层的显示区域
    //SetLayerDisplayFrame()的参数是一个hwc_rect_t类型的对象，该对象包含四个成员变量：left, top, right, bottom
    //left, top, right, bottom分别表示图层的左上角、右上角、右下角、左下角的坐标
    client_layer_.SetLayerDisplayFrame(
        (hwc_rect_t){.left = 0,
                     .top = 0,
                     .right = static_cast<int>(staged_mode_->h_display()),
                     .bottom = static_cast<int>(staged_mode_->v_display())});

    configs_.active_config_id = staged_mode_config_id_;

    a_args.display_mode = *staged_mode_;
    if (!a_args.test_only) {
      mode_update_commited_ = true;
    }
  }

  // order the layers by z-order
  bool use_client_layer = false;
  uint32_t client_z_order = UINT32_MAX;
  std::map<uint32_t, HwcLayer *> z_map;
  for (std::pair<const hwc2_layer_t, HwcLayer> &l : layers_) {
    switch (l.second.GetValidatedType()) {//获取layer合成方式
      case HWC2::Composition::Device:
        // z_map中是按照z-order排序的，Device合成的图层
        z_map.emplace(std::make_pair(l.second.GetZOrder(), &l.second));
        break;
      case HWC2::Composition::Client:
        // Place it at the z_order of the lowest client layer
        // 找到GPU合成图层中最小的z-order值
        use_client_layer = true;
        client_z_order = std::min(client_z_order, l.second.GetZOrder());
        break;
      default:
        continue;
    }
  }
  if (use_client_layer)//将GPU合成的图层添加到z_map中
    z_map.emplace(std::make_pair(client_z_order, &client_layer_));

  if (z_map.empty())//z_map为空，没有需要显示或者刷新显示的图层
    return HWC2::Error::BadLayer;

  std::vector<DrmHwcLayer> composition_layers;

  // now that they're ordered by z, add them to the composition
  for (std::pair<const uint32_t, HwcLayer *> &l : z_map) {
    DrmHwcLayer layer;
    /**
     * @brief 
     * HwcLayer转为DrmHwcLayer  
     * 1. 调用HwcLayer的PopulateDrmLayer()方法，将HwcLayer的成员变量拷贝到DrmHwcLayer的成员变量中
     * 2. 调用DrmHwcLayer的ImportBuffer()方法，做drmPrimeFDToHandle处理，并且这块会根据gralloc的具体
     * 实现来决定如何获取buffer_info信息
     */
    l.second->PopulateDrmLayer(&layer);
    int ret = layer.ImportBuffer(GetPipe().device);
    if (ret) {
      ALOGE("Failed to import layer, ret=%d", ret);
      return HWC2::Error::NoResources;
    }
    composition_layers.emplace_back(std::move(layer));//将所有需要通过kms显示的图层添加到composition_layers中
  }

  /* Store plan to ensure shared planes won't be stolen by other display
   * in between of ValidateDisplay() and PresentDisplay() calls
   */
  //创建DrmKms显示计划 这里的composition_layers就是需要通过kms显示的图层
  current_plan_ = DrmKmsPlan::CreateDrmKmsPlan(GetPipe(),
                                               std::move(composition_layers));
  if (!current_plan_) {
    if (!a_args.test_only) {
      ALOGE("Failed to create DrmKmsPlan");
    }
    return HWC2::Error::BadConfig;
  }

  a_args.composition = current_plan_;
  //提交显示，将显示输出到屏幕，这块主要就是调用libdrm的相关API接口进行相关操作，这块的具体逻辑可以看何小龙相关bug
  int ret = GetPipe().atomic_state_manager->ExecuteAtomicCommit(a_args);



  return HWC2::Error::None;
}

内容有点多啊，核心的源码已经注释了。我们这里重点看下HwcLayer::PopulateDrmLayer和DrmHwcLayer::ImportBuffer的实现！

HwcLayer::PopulateDrmLayer

//include/drmhwcomposer.h
struct DrmHwcLayer {
  buffer_handle_t sf_handle = nullptr;
  hwc_drm_bo_t buffer_info{};
  std::shared_ptr<DrmFbIdHandle> fb_id_handle;

  int gralloc_buffer_usage = 0;
  DrmHwcTransform transform{};
  DrmHwcBlending blending = DrmHwcBlending::kNone;
  uint16_t alpha = UINT16_MAX;
  hwc_frect_t source_crop;
  hwc_rect_t display_frame;
  DrmHwcColorSpace color_space;
  DrmHwcSampleRange sample_range;

  UniqueFd acquire_fence;

  int ImportBuffer(DrmDevice *drm_device);

  bool IsProtected() const {
    return (gralloc_buffer_usage & GRALLOC_USAGE_PROTECTED) ==
           GRALLOC_USAGE_PROTECTED;
  }
};



//hwc2_device/HwcLayer.cpp
//将HwcLayer的属性转移到DrmHwcLayre中
void HwcLayer::PopulateDrmLayer(DrmHwcLayer *layer) {
  layer->sf_handle = buffer_;//buffer_handle_t buffer_
  // TODO(rsglobal): Avoid extra fd duplication
  layer->acquire_fence = UniqueFd(fcntl(acquire_fence_.Get(), F_DUPFD_CLOEXEC));
  layer->display_frame = display_frame_;
  layer->alpha = std::lround(alpha_ * UINT16_MAX);
  layer->blending = blending_;
  layer->source_crop = source_crop_;
  layer->transform = transform_;
  layer->color_space = color_space_;
  layer->sample_range = sample_range_;
}

DrmHwcLayer::ImportBuffer

我们接着看下它的实现逻辑:

//utils/hwcutils.cpp
int DrmHwcLayer::ImportBuffer(DrmDevice *drm_device) {
  buffer_info = hwc_drm_bo_t{};
  //核心逻辑把buffer_handle_t对象转换成hwc_drm_bo_t对象
  //sf_handle是buffer_handle_t对象
  //buffer_info是hwc_drm_bo_t对象，并且这块和gralloc的具体实现有关系，那么就会对饮不同的BufferInfo
  //有好几个类实现了ConvertBoInfo，那么最终调用的是那个呢
  int ret = BufferInfoGetter::GetInstance()->ConvertBoInfo(sf_handle,
                                                           &buffer_info);
  if (ret != 0) {
    ALOGE("Failed to convert buffer info %d", ret);
    return ret;
  }
  //核心逻辑是调用drmPrimeFDToHandle
  fb_id_handle = drm_device->GetDrmFbImporter().GetOrCreateFbId(&buffer_info);
  if (!fb_id_handle) {
    ALOGE("Failed to import buffer");
    return -EINVAL;
  }

  return 0;
}


//bufferinfo/BufferInfoGetter.cpp
BufferInfoGetter *BufferInfoGetter::GetInstance() {
  static std::unique_ptr<BufferInfoGetter> inst;
  if (!inst) {
//这块逻辑只有配置ro.hardware.hwcomposer=drm且Android SDK版本大于等于30时才会执行
#if PLATFORM_SDK_VERSION >= 30 && defined(USE_IMAPPER4_METADATA_API)
    inst.reset(BufferInfoMapperMetadata::CreateInstance());
    if (!inst) {
      ALOGW(
          "Generic buffer getter is not available. Falling back to legacy...");
    }
#endif
    if (!inst) {
      //这里会创建一个LegacyBufferInfoGetter的实例，但是在当前类中返回的是null，那么只有一个可能是在子类中实现了
      inst = LegacyBufferInfoGetter::CreateInstance();
    }
  }

  return inst.get();
}


__attribute__((weak)) std::unique_ptr<LegacyBufferInfoGetter>
LegacyBufferInfoGetter::CreateInstance() {
  ALOGE("No legacy buffer info getters available");
  return nullptr;
}

那么是谁重重写实现了LegacyBufferInfoGetter::CreateInstance()呢，这个就要从ro.hardware.hwcomposer的配置说起了，这里我们配置为minigbm，所以编译的就是hwcomposer.drm_minigbm，如下:

//Android.bp
cc_library_shared {
    name: "hwcomposer.drm_minigbm",
    defaults: ["hwcomposer.drm_defaults"],
    srcs: [
        ":drm_hwcomposer_common",
        "bufferinfo/legacy/BufferInfoMinigbm.cpp",
    ],
}

我们进入到BufferInfoMinigbm瞧瞧看看:

//
namespace android {
LEGACY_BUFFER_INFO_GETTER(BufferInfoMinigbm);
}


//bufferinfo/BufferInfoGetter.h
#define LEGACY_BUFFER_INFO_GETTER(getter_)                             \
  std::unique_ptr<LegacyBufferInfoGetter>                              \
  LegacyBufferInfoGetter::CreateInstance() {                           \
    auto instance = std::make_unique<getter_>();                       \
    if (instance) {                                                    \
      int err = instance->Init(); //初始化                             \
      if (err) {                                                       \
        ALOGE("Failed to initialize the " #getter_ " getter %d", err); \
        instance.reset();                                              \
      }                                                                \
      err = instance->ValidateGralloc();                               \
      if (err) {                                                       \
        instance.reset();                                              \
      }                                                                \
    }                                                                  \
    return std::move(instance);                                        \
  }

那我们接着看下minigbm的ConvertBoInfo实现:

//bufferinfo/BufferInfoGetter.cpp
int LegacyBufferInfoGetter::Init() {
  //加载gralloc模块
  int ret = hw_get_module(
      GRALLOC_HARDWARE_MODULE_ID,
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      reinterpret_cast<const hw_module_t **>(&gralloc_));
  if (ret != 0) {
    ALOGE("Failed to open gralloc module");
    return ret;
  }

  ALOGI("Using %s gralloc module: %s\n", gralloc_->common.name,
        gralloc_->common.author);

  return 0;
}


//bufferinfo/legacy/BufferInfoMinigbm.cpp
int BufferInfoMinigbm::ConvertBoInfo(buffer_handle_t handle, hwc_drm_bo_t *bo) {
  if (handle == nullptr) {
    return -EINVAL;
  }

  uint32_t width{};
  uint32_t height{};
  //通过gralloc_->perform来获取buffer的信息
  if (gralloc_->perform(gralloc_, CROS_GRALLOC_DRM_GET_DIMENSIONS, handle,
                        &width, &height) != 0) {
    ALOGE(
        "CROS_GRALLOC_DRM_GET_DIMENSIONS operation has failed. "
        "Please ensure you are using the latest minigbm.");
    return -EINVAL;
  }

  int32_t droid_format{};
  if (gralloc_->perform(gralloc_, CROS_GRALLOC_DRM_GET_FORMAT, handle,
                        &droid_format) != 0) {
    ALOGE(
        "CROS_GRALLOC_DRM_GET_FORMAT operation has failed. "
        "Please ensure you are using the latest minigbm.");
    return -EINVAL;
  }

  uint32_t usage{};
  if (gralloc_->perform(gralloc_, CROS_GRALLOC_DRM_GET_USAGE, handle, &usage) !=
      0) {
    ALOGE(
        "CROS_GRALLOC_DRM_GET_USAGE operation has failed. "
        "Please ensure you are using the latest minigbm.");
    return -EINVAL;
  }

  struct cros_gralloc0_buffer_info info {};
  if (gralloc_->perform(gralloc_, CROS_GRALLOC_DRM_GET_BUFFER_INFO, handle,
                        &info) != 0) {
    ALOGE(
        "CROS_GRALLOC_DRM_GET_BUFFER_INFO operation has failed. "
        "Please ensure you are using the latest minigbm.");
    return -EINVAL;
  }

  bo->width = width;
  bo->height = height;

  bo->hal_format = droid_format;

  bo->format = info.drm_fourcc;
  bo->usage = usage;

  for (int i = 0; i < info.num_fds; i++) {
    bo->modifiers[i] = info.modifier;
    bo->prime_fds[i] = info.fds[i];
    bo->pitches[i] = info.stride[i];
    bo->offsets[i] = info.offset[i];
  }

  return 0;
}

DrmKmsPlan::CreateDrmKmsPlan

最后我们看下CreateDrmKmsPlan的实现

//compositor/DrmKmsPlan.cpp
namespace android {
auto DrmKmsPlan::CreateDrmKmsPlan(DrmDisplayPipeline &pipe,
                                  std::vector<DrmHwcLayer> composition)
    -> std::unique_ptr<DrmKmsPlan> {
  auto plan = std::make_unique<DrmKmsPlan>();
  //获取可用的plane
  auto avail_planes = pipe.GetUsablePlanes();

  int z_pos = 0;
  for (auto &dhl : composition) {
    std::shared_ptr<BindingOwner<DrmPlane>> plane;

    /* Skip unsupported planes */
    do {
      if (avail_planes.empty()) {
        return {};
      }
      //这个地方有疑问，为啥要erase掉plane，万一它能匹配后面遍历的plane呢
      plane = *avail_planes.begin();
      avail_planes.erase(avail_planes.begin());
    } while (!plane->Get()->IsValidForLayer(&dhl));

    LayerToPlaneJoining joining = {
        .layer = std::move(dhl),
        .plane = plane,
        .z_pos = z_pos++,
    };
    //使用构建的joining填充DrmKmsPlane
    plan->plan.emplace_back(std::move(joining));
  }

  return plan;
}

}  // namespace android

---

四. 写在最后

好了今天的博客Android下HWC以及drm_hwcomposer普法(下)就到这里了。总之，青山不改绿水长流先到这里了。如果本博客对你有所帮助，麻烦关注或者点个赞，如果觉得很烂也可以踩一脚！谢谢各位了！！