drm_hwcomposer: Move hw_module related code out of DrmHwcTwo.* files
... to reduce complexity of DrmHwcTwo class.
Create "hwc2_device" directory that will be later used to fit
all frontend-related code.
Signed-off-by: Roman Stratiienko <roman.o.stratiienko@globallogic.com>
diff --git a/hwc2_device/hwc2_device.cpp b/hwc2_device/hwc2_device.cpp
new file mode 100644
index 0000000..24edda7
--- /dev/null
+++ b/hwc2_device/hwc2_device.cpp
@@ -0,0 +1,406 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "hwc2-device"
+
+#include "DrmHwcTwo.h"
+#include "backend/Backend.h"
+#include "utils/log.h"
+
+namespace android {
+
+struct Drmhwc2Device : hwc2_device {
+ DrmHwcTwo drmhwctwo;
+};
+
+static DrmHwcTwo *ToDrmHwcTwo(hwc2_device_t *dev) {
+ // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast):
+ return &static_cast<Drmhwc2Device *>(dev)->drmhwctwo;
+}
+
+template <typename PFN, typename T>
+static hwc2_function_pointer_t ToHook(T function) {
+ static_assert(std::is_same<PFN, T>::value, "Incompatible fn pointer");
+ // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast):
+ return reinterpret_cast<hwc2_function_pointer_t>(function);
+}
+
+template <typename T, typename HookType, HookType func, typename... Args>
+static T DeviceHook(hwc2_device_t *dev, Args... args) {
+ DrmHwcTwo *hwc = ToDrmHwcTwo(dev);
+ return static_cast<T>(((*hwc).*func)(std::forward<Args>(args)...));
+}
+
+template <typename HookType, HookType func, typename... Args>
+static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle,
+ Args... args) {
+ DrmHwcTwo::HwcDisplay *display = DrmHwcTwo::GetDisplay(ToDrmHwcTwo(dev),
+ display_handle);
+ if (!display)
+ return static_cast<int32_t>(HWC2::Error::BadDisplay);
+
+ return static_cast<int32_t>((display->*func)(std::forward<Args>(args)...));
+}
+
+template <typename HookType, HookType func, typename... Args>
+static int32_t LayerHook(hwc2_device_t *dev, hwc2_display_t display_handle,
+ hwc2_layer_t layer_handle, Args... args) {
+ DrmHwcTwo::HwcDisplay *display = DrmHwcTwo::GetDisplay(ToDrmHwcTwo(dev),
+ display_handle);
+ if (!display)
+ return static_cast<int32_t>(HWC2::Error::BadDisplay);
+
+ DrmHwcTwo::HwcLayer *layer = display->get_layer(layer_handle);
+ if (!layer)
+ return static_cast<int32_t>(HWC2::Error::BadLayer);
+
+ return static_cast<int32_t>((layer->*func)(std::forward<Args>(args)...));
+}
+
+static int HookDevClose(hw_device_t *dev) {
+ // NOLINTNEXTLINE (cppcoreguidelines-pro-type-reinterpret-cast): Safe
+ auto *hwc2_dev = reinterpret_cast<hwc2_device_t *>(dev);
+ std::unique_ptr<DrmHwcTwo> ctx(ToDrmHwcTwo(hwc2_dev));
+ return 0;
+}
+
+static void HookDevGetCapabilities(hwc2_device_t * /*dev*/, uint32_t *out_count,
+ int32_t * /*out_capabilities*/) {
+ *out_count = 0;
+}
+
+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::CreateVirtualDisplay:
+ return ToHook<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
+ DeviceHook<int32_t, decltype(&DrmHwcTwo::CreateVirtualDisplay),
+ &DrmHwcTwo::CreateVirtualDisplay, uint32_t, uint32_t,
+ int32_t *, hwc2_display_t *>);
+ case HWC2::FunctionDescriptor::DestroyVirtualDisplay:
+ return ToHook<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
+ DeviceHook<int32_t, decltype(&DrmHwcTwo::DestroyVirtualDisplay),
+ &DrmHwcTwo::DestroyVirtualDisplay, hwc2_display_t>);
+ case HWC2::FunctionDescriptor::Dump:
+ return ToHook<HWC2_PFN_DUMP>(
+ DeviceHook<void, decltype(&DrmHwcTwo::Dump), &DrmHwcTwo::Dump,
+ uint32_t *, char *>);
+ case HWC2::FunctionDescriptor::GetMaxVirtualDisplayCount:
+ return ToHook<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
+ DeviceHook<uint32_t, decltype(&DrmHwcTwo::GetMaxVirtualDisplayCount),
+ &DrmHwcTwo::GetMaxVirtualDisplayCount>);
+ 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(&DrmHwcTwo::HwcDisplay::AcceptDisplayChanges),
+ &DrmHwcTwo::HwcDisplay::AcceptDisplayChanges>);
+ case HWC2::FunctionDescriptor::CreateLayer:
+ return ToHook<HWC2_PFN_CREATE_LAYER>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::CreateLayer),
+ &DrmHwcTwo::HwcDisplay::CreateLayer, hwc2_layer_t *>);
+ case HWC2::FunctionDescriptor::DestroyLayer:
+ return ToHook<HWC2_PFN_DESTROY_LAYER>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::DestroyLayer),
+ &DrmHwcTwo::HwcDisplay::DestroyLayer, hwc2_layer_t>);
+ case HWC2::FunctionDescriptor::GetActiveConfig:
+ return ToHook<HWC2_PFN_GET_ACTIVE_CONFIG>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetActiveConfig),
+ &DrmHwcTwo::HwcDisplay::GetActiveConfig,
+ hwc2_config_t *>);
+ case HWC2::FunctionDescriptor::GetChangedCompositionTypes:
+ return ToHook<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
+ DisplayHook<
+ decltype(&DrmHwcTwo::HwcDisplay::GetChangedCompositionTypes),
+ &DrmHwcTwo::HwcDisplay::GetChangedCompositionTypes, uint32_t *,
+ hwc2_layer_t *, int32_t *>);
+ case HWC2::FunctionDescriptor::GetClientTargetSupport:
+ return ToHook<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetClientTargetSupport),
+ &DrmHwcTwo::HwcDisplay::GetClientTargetSupport, uint32_t,
+ uint32_t, int32_t, int32_t>);
+ case HWC2::FunctionDescriptor::GetColorModes:
+ return ToHook<HWC2_PFN_GET_COLOR_MODES>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetColorModes),
+ &DrmHwcTwo::HwcDisplay::GetColorModes, uint32_t *,
+ int32_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayAttribute:
+ return ToHook<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayAttribute),
+ &DrmHwcTwo::HwcDisplay::GetDisplayAttribute,
+ hwc2_config_t, int32_t, int32_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayConfigs:
+ return ToHook<HWC2_PFN_GET_DISPLAY_CONFIGS>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayConfigs),
+ &DrmHwcTwo::HwcDisplay::GetDisplayConfigs, uint32_t *,
+ hwc2_config_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayName:
+ return ToHook<HWC2_PFN_GET_DISPLAY_NAME>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayName),
+ &DrmHwcTwo::HwcDisplay::GetDisplayName, uint32_t *,
+ char *>);
+ case HWC2::FunctionDescriptor::GetDisplayRequests:
+ return ToHook<HWC2_PFN_GET_DISPLAY_REQUESTS>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayRequests),
+ &DrmHwcTwo::HwcDisplay::GetDisplayRequests, int32_t *,
+ uint32_t *, hwc2_layer_t *, int32_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayType:
+ return ToHook<HWC2_PFN_GET_DISPLAY_TYPE>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayType),
+ &DrmHwcTwo::HwcDisplay::GetDisplayType, int32_t *>);
+ case HWC2::FunctionDescriptor::GetDozeSupport:
+ return ToHook<HWC2_PFN_GET_DOZE_SUPPORT>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDozeSupport),
+ &DrmHwcTwo::HwcDisplay::GetDozeSupport, int32_t *>);
+ case HWC2::FunctionDescriptor::GetHdrCapabilities:
+ return ToHook<HWC2_PFN_GET_HDR_CAPABILITIES>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetHdrCapabilities),
+ &DrmHwcTwo::HwcDisplay::GetHdrCapabilities, uint32_t *,
+ int32_t *, float *, float *, float *>);
+ case HWC2::FunctionDescriptor::GetReleaseFences:
+ return ToHook<HWC2_PFN_GET_RELEASE_FENCES>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetReleaseFences),
+ &DrmHwcTwo::HwcDisplay::GetReleaseFences, uint32_t *,
+ hwc2_layer_t *, int32_t *>);
+ case HWC2::FunctionDescriptor::PresentDisplay:
+ return ToHook<HWC2_PFN_PRESENT_DISPLAY>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::PresentDisplay),
+ &DrmHwcTwo::HwcDisplay::PresentDisplay, int32_t *>);
+ case HWC2::FunctionDescriptor::SetActiveConfig:
+ return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetActiveConfig),
+ &DrmHwcTwo::HwcDisplay::SetActiveConfig, hwc2_config_t>);
+ case HWC2::FunctionDescriptor::SetClientTarget:
+ return ToHook<HWC2_PFN_SET_CLIENT_TARGET>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetClientTarget),
+ &DrmHwcTwo::HwcDisplay::SetClientTarget, buffer_handle_t,
+ int32_t, int32_t, hwc_region_t>);
+ case HWC2::FunctionDescriptor::SetColorMode:
+ return ToHook<HWC2_PFN_SET_COLOR_MODE>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetColorMode),
+ &DrmHwcTwo::HwcDisplay::SetColorMode, int32_t>);
+ case HWC2::FunctionDescriptor::SetColorTransform:
+ return ToHook<HWC2_PFN_SET_COLOR_TRANSFORM>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetColorTransform),
+ &DrmHwcTwo::HwcDisplay::SetColorTransform, const float *,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetOutputBuffer:
+ return ToHook<HWC2_PFN_SET_OUTPUT_BUFFER>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetOutputBuffer),
+ &DrmHwcTwo::HwcDisplay::SetOutputBuffer, buffer_handle_t,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetPowerMode:
+ return ToHook<HWC2_PFN_SET_POWER_MODE>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetPowerMode),
+ &DrmHwcTwo::HwcDisplay::SetPowerMode, int32_t>);
+ case HWC2::FunctionDescriptor::SetVsyncEnabled:
+ return ToHook<HWC2_PFN_SET_VSYNC_ENABLED>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetVsyncEnabled),
+ &DrmHwcTwo::HwcDisplay::SetVsyncEnabled, int32_t>);
+ case HWC2::FunctionDescriptor::ValidateDisplay:
+ return ToHook<HWC2_PFN_VALIDATE_DISPLAY>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::ValidateDisplay),
+ &DrmHwcTwo::HwcDisplay::ValidateDisplay, uint32_t *,
+ uint32_t *>);
+#if PLATFORM_SDK_VERSION > 27
+ case HWC2::FunctionDescriptor::GetRenderIntents:
+ return ToHook<HWC2_PFN_GET_RENDER_INTENTS>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetRenderIntents),
+ &DrmHwcTwo::HwcDisplay::GetRenderIntents, int32_t,
+ uint32_t *, int32_t *>);
+ case HWC2::FunctionDescriptor::SetColorModeWithRenderIntent:
+ return ToHook<HWC2_PFN_SET_COLOR_MODE_WITH_RENDER_INTENT>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetColorModeWithIntent),
+ &DrmHwcTwo::HwcDisplay::SetColorModeWithIntent, int32_t,
+ int32_t>);
+#endif
+#if PLATFORM_SDK_VERSION > 28
+ case HWC2::FunctionDescriptor::GetDisplayIdentificationData:
+ return ToHook<HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA>(
+ DisplayHook<
+ decltype(&DrmHwcTwo::HwcDisplay::GetDisplayIdentificationData),
+ &DrmHwcTwo::HwcDisplay::GetDisplayIdentificationData, uint8_t *,
+ uint32_t *, uint8_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayCapabilities:
+ return ToHook<HWC2_PFN_GET_DISPLAY_CAPABILITIES>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayCapabilities),
+ &DrmHwcTwo::HwcDisplay::GetDisplayCapabilities,
+ uint32_t *, uint32_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayBrightnessSupport:
+ return ToHook<HWC2_PFN_GET_DISPLAY_BRIGHTNESS_SUPPORT>(
+ DisplayHook<
+ decltype(&DrmHwcTwo::HwcDisplay::GetDisplayBrightnessSupport),
+ &DrmHwcTwo::HwcDisplay::GetDisplayBrightnessSupport, bool *>);
+ case HWC2::FunctionDescriptor::SetDisplayBrightness:
+ return ToHook<HWC2_PFN_SET_DISPLAY_BRIGHTNESS>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetDisplayBrightness),
+ &DrmHwcTwo::HwcDisplay::SetDisplayBrightness, float>);
+#endif /* PLATFORM_SDK_VERSION > 28 */
+#if PLATFORM_SDK_VERSION > 29
+ case HWC2::FunctionDescriptor::GetDisplayConnectionType:
+ return ToHook<HWC2_PFN_GET_DISPLAY_CONNECTION_TYPE>(
+ DisplayHook<
+ decltype(&DrmHwcTwo::HwcDisplay::GetDisplayConnectionType),
+ &DrmHwcTwo::HwcDisplay::GetDisplayConnectionType, uint32_t *>);
+ case HWC2::FunctionDescriptor::GetDisplayVsyncPeriod:
+ return ToHook<HWC2_PFN_GET_DISPLAY_VSYNC_PERIOD>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::GetDisplayVsyncPeriod),
+ &DrmHwcTwo::HwcDisplay::GetDisplayVsyncPeriod,
+ hwc2_vsync_period_t *>);
+ case HWC2::FunctionDescriptor::SetActiveConfigWithConstraints:
+ return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS>(
+ DisplayHook<
+ decltype(&DrmHwcTwo::HwcDisplay::SetActiveConfigWithConstraints),
+ &DrmHwcTwo::HwcDisplay::SetActiveConfigWithConstraints,
+ hwc2_config_t, hwc_vsync_period_change_constraints_t *,
+ hwc_vsync_period_change_timeline_t *>);
+ case HWC2::FunctionDescriptor::SetAutoLowLatencyMode:
+ return ToHook<HWC2_PFN_SET_AUTO_LOW_LATENCY_MODE>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetAutoLowLatencyMode),
+ &DrmHwcTwo::HwcDisplay::SetAutoLowLatencyMode, bool>);
+ case HWC2::FunctionDescriptor::GetSupportedContentTypes:
+ return ToHook<HWC2_PFN_GET_SUPPORTED_CONTENT_TYPES>(
+ DisplayHook<
+ decltype(&DrmHwcTwo::HwcDisplay::GetSupportedContentTypes),
+ &DrmHwcTwo::HwcDisplay::GetSupportedContentTypes, uint32_t *,
+ uint32_t *>);
+ case HWC2::FunctionDescriptor::SetContentType:
+ return ToHook<HWC2_PFN_SET_CONTENT_TYPE>(
+ DisplayHook<decltype(&DrmHwcTwo::HwcDisplay::SetContentType),
+ &DrmHwcTwo::HwcDisplay::SetContentType, int32_t>);
+#endif
+ // Layer functions
+ case HWC2::FunctionDescriptor::SetCursorPosition:
+ return ToHook<HWC2_PFN_SET_CURSOR_POSITION>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetCursorPosition),
+ &DrmHwcTwo::HwcLayer::SetCursorPosition, int32_t, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerBlendMode:
+ return ToHook<HWC2_PFN_SET_LAYER_BLEND_MODE>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerBlendMode),
+ &DrmHwcTwo::HwcLayer::SetLayerBlendMode, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerBuffer:
+ return ToHook<HWC2_PFN_SET_LAYER_BUFFER>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerBuffer),
+ &DrmHwcTwo::HwcLayer::SetLayerBuffer, buffer_handle_t,
+ int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerColor:
+ return ToHook<HWC2_PFN_SET_LAYER_COLOR>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerColor),
+ &DrmHwcTwo::HwcLayer::SetLayerColor, hwc_color_t>);
+ case HWC2::FunctionDescriptor::SetLayerCompositionType:
+ return ToHook<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerCompositionType),
+ &DrmHwcTwo::HwcLayer::SetLayerCompositionType, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerDataspace:
+ return ToHook<HWC2_PFN_SET_LAYER_DATASPACE>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerDataspace),
+ &DrmHwcTwo::HwcLayer::SetLayerDataspace, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerDisplayFrame:
+ return ToHook<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerDisplayFrame),
+ &DrmHwcTwo::HwcLayer::SetLayerDisplayFrame, hwc_rect_t>);
+ case HWC2::FunctionDescriptor::SetLayerPlaneAlpha:
+ return ToHook<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha),
+ &DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha, float>);
+ case HWC2::FunctionDescriptor::SetLayerSidebandStream:
+ return ToHook<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerSidebandStream),
+ &DrmHwcTwo::HwcLayer::SetLayerSidebandStream,
+ const native_handle_t *>);
+ case HWC2::FunctionDescriptor::SetLayerSourceCrop:
+ return ToHook<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerSourceCrop),
+ &DrmHwcTwo::HwcLayer::SetLayerSourceCrop, hwc_frect_t>);
+ case HWC2::FunctionDescriptor::SetLayerSurfaceDamage:
+ return ToHook<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage),
+ &DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage, hwc_region_t>);
+ case HWC2::FunctionDescriptor::SetLayerTransform:
+ return ToHook<HWC2_PFN_SET_LAYER_TRANSFORM>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerTransform),
+ &DrmHwcTwo::HwcLayer::SetLayerTransform, int32_t>);
+ case HWC2::FunctionDescriptor::SetLayerVisibleRegion:
+ return ToHook<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerVisibleRegion),
+ &DrmHwcTwo::HwcLayer::SetLayerVisibleRegion, hwc_region_t>);
+ case HWC2::FunctionDescriptor::SetLayerZOrder:
+ return ToHook<HWC2_PFN_SET_LAYER_Z_ORDER>(
+ LayerHook<decltype(&DrmHwcTwo::HwcLayer::SetLayerZOrder),
+ &DrmHwcTwo::HwcLayer::SetLayerZOrder, uint32_t>);
+ case HWC2::FunctionDescriptor::Invalid:
+ default:
+ return nullptr;
+ }
+}
+
+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>();
+ 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;
+
+ HWC2::Error err = ctx->drmhwctwo.Init();
+ if (err != HWC2::Error::None) {
+ ALOGE("Failed to initialize DrmHwcTwo err=%d\n", err);
+ return -EINVAL;
+ }
+
+ *dev = &ctx.release()->common;
+
+ return 0;
+}
+
+} // namespace android
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static struct hw_module_methods_t hwc2_module_methods = {
+ .open = android::HookDevOpen,
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+hw_module_t HAL_MODULE_INFO_SYM = {
+ .tag = HARDWARE_MODULE_TAG,
+ .module_api_version = HARDWARE_MODULE_API_VERSION(2, 0),
+ .id = HWC_HARDWARE_MODULE_ID,
+ .name = "DrmHwcTwo module",
+ .author = "The Android Open Source Project",
+ .methods = &hwc2_module_methods,
+ .dso = nullptr,
+ .reserved = {0},
+};