Android下HWC以及drm_hwcomposer普法(下)

2024-05-31 18:20

本文主要是介绍Android下HWC以及drm_hwcomposer普法(下),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

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合成的layersstatic 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的合成方式都为clientlayer.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_overridestd::string backend_name(backend_override);//根据backend_name获取对应的backend//如果找不到,则使用默认的backend//如果找不到默认的backend,则返回错误//如果成功,则将backend设置给displaydisplay->set_backend(GetBackendByName(backend_name));...return 0;
}

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




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

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


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

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

image

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

文件:frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cppvoid 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.cppvoid 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;}//如果有变化则设置给对应的layerif (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.cppstatus_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成功,数据直接提交给了hwcstd::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,其它的设置为deviceMarkValidated(layers, client_start, client_size);} else {std::tie(client_start, client_size) = GetClientLayers(display, layers);//核心实现,标记那些layer需要client合成//设置合成类型,client_start到client_start+client_size之间的设置为Client,其它的设置为DeviceMarkValidated(layers, client_start, client_size);//只有一个情况testing_needed为flase,所有的layers都是client_layerbool 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_layerfor (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的layersreturn GetExtraClientRange(display, layers, client_start, client_size);
}//判断layer是不是必须为client合成或者已经指定了client合成
/*** @brief 
判断指定的Layer是否要Client合成,满足其中一个条件即可:1. HardwareSupportsLayerType硬件不支持的合成方式2. IsHandleUsable buffer handle无法转为DRM要求的buffer object3. color_transform_hint !=HAL_COLOR_TRANSFORM_IDENTITY4. 需要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的合成方式是clientlayers[z_order]->SetValidatedType(HWC2::Composition::Client);else//标记该layer的合成方式是devicelayers[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合成的layerint 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;//剩余的都是clientsteps = 1 + layers.size() - extra_client;//计算可以移动计算的step范围}//选择像素之和最少的连续layersuint32_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说起了!


image


文件:frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cppvoid 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 fenceauto 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 fenceerror = 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.cppvoid FramebufferSurface::onFrameCommitted() {if (mHasPendingRelease) {sp<Fence> fence = mHwc.getPresentFence(mDisplayId);if (fence->isValid()) {// 更新BufferSlot的 fencestatus_t result = addReleaseFence(mPreviousBufferSlot,mPreviousBuffer, fence);ALOGE_IF(result != NO_ERROR, "onFrameCommitted: failed to add the"" fence: %s (%d)", strerror(-result), result);}// 释放之前的Bufferstatus_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.cppcase 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 refreshArgsret = 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-orderbool 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 compositionfor (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接口进行相关操作,这块的具体逻辑可以看何小龙相关bugint 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 duplicationlayer->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;}//核心逻辑是调用drmPrimeFDToHandlefb_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...");}
#endifif (!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>();//获取可用的planeauto 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填充DrmKmsPlaneplan->plan.emplace_back(std::move(joining));}return plan;
}}  // namespace android



四. 写在最后

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

这篇关于Android下HWC以及drm_hwcomposer普法(下)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1018690

相关文章

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸(两张壁纸可不一致)

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸: 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  (注意不能是bmp格式) 替换默认锁屏壁纸: 将图片资源放入vendo

Android平台播放RTSP流的几种方案探究(VLC VS ExoPlayer VS SmartPlayer)

技术背景 好多开发者需要遴选Android平台RTSP直播播放器的时候,不知道如何选的好,本文针对常用的方案,做个大概的说明: 1. 使用VLC for Android VLC Media Player(VLC多媒体播放器),最初命名为VideoLAN客户端,是VideoLAN品牌产品,是VideoLAN计划的多媒体播放器。它支持众多音频与视频解码器及文件格式,并支持DVD影音光盘,VCD影

android-opencv-jni

//------------------start opencv--------------------@Override public void onResume(){ super.onResume(); //通过OpenCV引擎服务加载并初始化OpenCV类库,所谓OpenCV引擎服务即是 //OpenCV_2.4.3.2_Manager_2.4_*.apk程序包,存

从状态管理到性能优化:全面解析 Android Compose

文章目录 引言一、Android Compose基本概念1.1 什么是Android Compose?1.2 Compose的优势1.3 如何在项目中使用Compose 二、Compose中的状态管理2.1 状态管理的重要性2.2 Compose中的状态和数据流2.3 使用State和MutableState处理状态2.4 通过ViewModel进行状态管理 三、Compose中的列表和滚动

Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

1.前言 在10.0的系统rom定制化开发中,在进行一些平板等默认横屏的设备开发的过程中,需要在进入camera2的 时候,默认预览图像也是需要横屏显示的,在上一篇已经实现了横屏预览功能,然后发现横屏预览后,拍照保存的图片 依然是竖屏的,所以说同样需要将图片也保存为横屏图标了,所以就需要看下mtk的camera2的相关横屏保存图片功能, 如何实现实现横屏保存图片功能 如图所示: 2.mtk

android应用中res目录说明

Android应用的res目录是一个特殊的项目,该项目里存放了Android应用所用的全部资源,包括图片、字符串、颜色、尺寸、样式等,类似于web开发中的public目录,js、css、image、style。。。。 Android按照约定,将不同的资源放在不同的文件夹中,这样可以方便的让AAPT(即Android Asset Packaging Tool , 在SDK的build-tools目

Android fill_parent、match_parent、wrap_content三者的作用及区别

这三个属性都是用来适应视图的水平或者垂直大小,以视图的内容或尺寸为基础的布局,比精确的指定视图的范围更加方便。 1、fill_parent 设置一个视图的布局为fill_parent将强制性的使视图扩展至它父元素的大小 2、match_parent 和fill_parent一样,从字面上的意思match_parent更贴切一些,于是从2.2开始,两个属性都可以使用,但2.3版本以后的建议使

Android Environment 获取的路径问题

1. 以获取 /System 路径为例 /*** Return root of the "system" partition holding the core Android OS.* Always present and mounted read-only.*/public static @NonNull File getRootDirectory() {return DIR_ANDR

Android逆向(反调,脱壳,过ssl证书脚本)

文章目录 总结 基础Android基础工具 定位关键代码页面activity定位数据包参数定位堆栈追踪 编写反调脱壳好用的脚本过ssl证书校验抓包反调的脚本打印堆栈bilibili反调的脚本 总结 暑假做了两个月的Android逆向,记录一下自己学到的东西。对于app渗透有了一些思路。 这两个月主要做的是代码分析,对于分析完后的持久化等没有学习。主要是如何反编译源码,如何找到

android系统源码12 修改默认桌面壁纸--SRO方式

1、aosp12修改默认桌面壁纸 代码路径 :frameworks\base\core\res\res\drawable-nodpi 替换成自己的图片即可,不过需要覆盖所有目录下的图片。 由于是静态修改,则需要make一下,重新编译。 2、方法二Overlay方式 由于上述方法有很大缺点,修改多了之后容易遗忘自己修改哪些文件,为此我们采用另外一种方法,使用Overlay方式。