Optimizes composition strategies for single HDR video layers

Backend::ValidateDisplay
Check for a single HDR video layer via IsHDRLayer().
If unique, attempt device composition and validate with a test commit.
On success, keep as device; else, fallback to client.
For multiple layers including HDR, force HDR to client.

HwcDisplay::CreateComposition
If single HDR device layer, disable HDR pipeline (identity CTM, no LUTs)
for direct scanout. For client or mixed cases, enable full pipeline.

Metadata and Capabilities:
Use EDID to fetch HDR types/luminance, with fallbacks for edge cases.
Sets SDR-like luminance (100 nits) if no HDR support;
for specific LG TV models ("LG TV SSCR"), overrides low/invalid max luminance
with typical HDR values (1000 nits) to handle EDID bugs.
Support HDR10 fully; HLG partially (no LUTs).

Tracked-On: OAM-134123
Change-Id: Ice8ed4c5f7bc433add6de7a645a84686b34319bf
Signed-off-by: Kanli Hu <kanli.hu@intel.com>

Author: kanlihu

backend/Backend.cpp

@@ -131,7 +131,8 @@ bool Backend::IsClientLayer(HwcDisplay *display, HwcLayer *layer) {
          !layer->IsLayerUsableAsDevice() || display->CtmByGpu() ||
          (layer->GetLayerData().pi.RequireScalingOrPhasing() &&
           display->GetHwc()->GetResMan().ForcedScalingWithGpu()) ||
-         (!display->IsInHeadlessMode() && display->GetPipe().device->IsIvshmDev());
+         (!display->IsInHeadlessMode() && display->GetPipe().device->IsIvshmDev()) ||
+         (!display->isSingleDeviceHdrLayer().first && layer->IsHDRLayer()); // only single hdrlayer will use device
 }
 
 bool Backend::IsVideoLayer(HwcLayer *layer) {

drm/DrmDevice.h

@@ -30,6 +30,7 @@
 namespace android {
 
 #define DRM_FORMAT_NV12_INTEL fourcc_code('9', '9', '9', '6')
+#define DRM_FORMAT_P010_INTEL fourcc_code('P', '0', '0', '9')
 class DrmFbImporter;
 class DrmPlane;
 class ResourceManager;

drm/DrmFbImporter.cpp

@@ -117,8 +117,10 @@ auto DrmFbIdHandle::CreateInstance(BufferInfo *bo, GemHandle first_gem_handle,
                         local->gem_handles_.data(), &bo->pitches[0],
                         &bo->offsets[0], &local->fb_id_, 0);
   } else {
-  if (bo->format == DRM_FORMAT_NV12_INTEL)
+    if (bo->format == DRM_FORMAT_NV12_INTEL)
       bo->format = DRM_FORMAT_NV12;
+    if (bo->format == DRM_FORMAT_P010_INTEL)
+      bo->format = DRM_FORMAT_P010;
     err = drmModeAddFB2WithModifiers(*drm.GetFd(), bo->width, bo->height,
                                      bo->format, local->gem_handles_.data(),
                                      &bo->pitches[0], &bo->offsets[0],

drm/HdrPipeline.cpp

@@ -12,6 +12,8 @@ std::vector<drm_color_lut> HdrPipeline::BuildSrgbDegamma(uint64_t size) {
     uint16_t v = static_cast<uint16_t>(std::lround(std::clamp(l, 0.0, 1.0) * 65535.0));
     lut[i].red = lut[i].green = lut[i].blue = v;
   }
+  // ensure black exactly 0
+  lut[0].red = lut[0].green = lut[0].blue = 0;
   return lut;
 }
 
@@ -86,4 +88,22 @@ std::shared_ptr<drm_color_ctm> HdrPipeline::BuildCtm709To2020() {
     }
   }
   return ctm;
+}
+
+std::shared_ptr<drm_color_ctm> HdrPipeline::BuildCtmIdentity() {
+  double m[3][3] = {
+      {1.0, 0.0, 0.0},
+      {0.0, 1.0, 0.0},
+      {0.0, 0.0, 1.0}
+  };
+  auto ctm = std::make_shared<drm_color_ctm>();
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      double v = m[i][j];
+      int64_t fp = (int64_t)llround(std::fabs(v) * (1LL << 32));
+      if (v < 0) fp |= (1ULL << 63);
+      ctm->matrix[i * 3 + j] = (uint64_t)fp;
+    }
+  }
+  return ctm;
 }

drm/HdrPipeline.h

@@ -1,14 +1,15 @@
 #pragma once
-#include <vector>
-#include <stdint.h>
 #include <drm_mode.h>
+#include <stdint.h>
+#include <vector>
 
 class HdrPipeline {
-public:
-
+ public:
   static std::vector<drm_color_lut> BuildSrgbDegamma(uint64_t size);
   static std::vector<drm_color_lut> BuildPqGamma(uint64_t size,
-    float max_luminance, float max_average_luminance,
-    float min_luminance);
+                                                 float max_luminance,
+                                                 float max_average_luminance,
+                                                 float min_luminance);
   static std::shared_ptr<drm_color_ctm> BuildCtm709To2020();
+  static std::shared_ptr<drm_color_ctm> BuildCtmIdentity();
 };

hwc2_device/HwcDisplay.cpp

@@ -782,6 +782,45 @@ AtomicCommitArgs HwcDisplay::CreateModesetCommit(
   return args;
 }
 
+auto HwcDisplay::isSingleDeviceHdrLayer() -> std::pair<bool, HwcLayer*> const {
+    uint32_t hdr_layer_count = 0;
+    uint32_t total_layer_count = 0;
+    HwcLayer* hdr_layer = nullptr;
+    for (auto& pair : layers_) {
+      auto& layer = pair.second;
+        total_layer_count++;
+        if (layer.IsHDRLayer()) {
+          hdr_layer_count++;
+          hdr_layer = &layer;
+        } else {
+          // Non-HDR layer found, return false immediately
+          return std::make_pair(false, nullptr);
+        }
+    }
+    return std::make_pair(
+      (hdr_layer_count == 1) && (total_layer_count == 1),
+      hdr_layer
+    );
+  }
+
+void HwcDisplay::resetHdrPipeLineWhenSingleDeviceHDRLayer(
+	AtomicCommitArgs &a_args) {
+  // HDR video layer logic
+  auto only_hdr_layer = isSingleDeviceHdrLayer();
+
+  if (only_hdr_layer.first && only_hdr_layer.second
+    && only_hdr_layer.second->GetValidatedType() == HWC2::Composition::Device) {
+    // Disable all HDR pipeline for direct device scanout
+    a_args.color_matrix = HdrPipeline::BuildCtmIdentity();
+    a_args.degamma_lut.reset();
+    a_args.gamma_lut.reset();
+  } else {
+    // Enable HDR pipeline for client composition
+    // (Assume SetHdrOutputMetadata or similar already set up these)
+    // If not, you can explicitly set them here as needed.
+  }
+}
+
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
 HWC2::Error HwcDisplay::CreateComposition(AtomicCommitArgs &a_args) {
   ATRACE_CALL();
@@ -860,6 +899,7 @@ HWC2::Error HwcDisplay::CreateComposition(AtomicCommitArgs &a_args) {
   if (z_map.empty())
     return HWC2::Error::BadLayer;
 
+  resetHdrPipeLineWhenSingleDeviceHDRLayer(a_args);
   std::vector<LayerData> composition_layers;
 
   /* Import & populate */
@@ -1214,22 +1254,33 @@ HWC2::Error HwcDisplay::SetHdrOutputMetadata(ui::Hdr type) {
   m->white_point.y = ToU16ColorValue(whitePoint.y);
 
   // build LUT/CTM
-  uint64_t gsize1 = 256;
-  uint64_t gsize2 = 256;
+  uint64_t gsize_gamma = 256;
+  uint64_t gsize_degamma = 256;
   if (pipeline_) {
       auto [ret1, sz1] =
           GetPipe().crtc->Get()->GetGammaLutSizeProperty().value();
-      if (ret1 == 0 && sz1) gsize1 = sz1;
+      if (ret1 == 0 && sz1) gsize_gamma = sz1;
       auto [ret2, sz2] =
           GetPipe().crtc->Get()->GetDeGammaLutSizeProperty().value();
-      if (ret2 == 0 && sz2) gsize2 = sz2;
-  }
-  hdr_degamma_lut_ = std::make_shared<std::vector<drm_color_lut>>(
-          HdrPipeline::BuildSrgbDegamma(gsize2));
-  hdr_gamma_lut_   = std::make_shared<std::vector<drm_color_lut>>(
-          HdrPipeline::BuildPqGamma(gsize1,
-              hdr_luminance[0], hdr_luminance[1], hdr_luminance[2]));
-  color_matrix_    = HdrPipeline::BuildCtm709To2020();
+      if (ret2 == 0 && sz2) gsize_degamma = sz2;
+  }
+
+  if (type == ui::Hdr::HDR10) {
+    hdr_degamma_lut_ = std::make_shared<std::vector<drm_color_lut>>(
+        HdrPipeline::BuildSrgbDegamma(gsize_degamma));
+    hdr_gamma_lut_ = std::make_shared<std::vector<drm_color_lut>>(
+        HdrPipeline::BuildPqGamma(gsize_gamma,
+                                  hdr_luminance[0],
+                                  hdr_luminance[1],
+                                  hdr_luminance[2]
+                                ));
+    color_matrix_ = HdrPipeline::BuildCtm709To2020();
+  } else if (type == ui::Hdr::HLG) {
+    hdr_degamma_lut_.reset();
+    hdr_gamma_lut_.reset();
+    SetColorMatrixToIdentity();
+  }
+
   return HWC2::Error::None;
 }
 

hwc2_device/HwcDisplay.h

@@ -252,6 +252,9 @@ class HwcDisplay {
 
   bool NeedsClientLayerUpdate() const;
 
+  auto isSingleDeviceHdrLayer() -> std::pair<bool, HwcLayer*> const;
+  void resetHdrPipeLineWhenSingleDeviceHDRLayer(AtomicCommitArgs &a_args);
+
  private:
   AtomicCommitArgs CreateModesetCommit(
       const HwcDisplayConfig *config,

hwc2_device/HwcLayer.cpp

@@ -16,6 +16,7 @@
 
 #define LOG_TAG "drmhwc"
 #include <xf86drm.h>
+#include <xf86drmMode.h>
 #include <linux/dma-buf.h>
 #include "HwcLayer.h"
 
@@ -111,6 +112,12 @@ bool HwcLayer::IsVideoLayer() {
       slots_[*active_slot_id_].bi.usage & GRALLOC_USAGE_HW_VIDEO_ENCODER;
 }
 
+bool HwcLayer::IsHDRLayer() {
+  return active_slot_id_.has_value() &&
+      (slots_[*active_slot_id_].bi.format == DRM_FORMAT_P010_INTEL ||
+       slots_[*active_slot_id_].bi.format == DRM_FORMAT_P010);
+}
+
 void HwcLayer::ImportFb() {
   if (!IsLayerUsableAsDevice() || !buffer_updated_ ||
       !active_slot_id_.has_value()) {

hwc2_device/HwcLayer.h

@@ -155,6 +155,7 @@ class HwcLayer {
   void PopulateLayerData();
   void ClearSlots();
   bool IsVideoLayer();
+  bool IsHDRLayer();
   bool IsLayerUsableAsDevice() const {
     return !fb_import_failed_ && active_slot_id_.has_value() &&
            slots_.count(*active_slot_id_) > 0;

utils/LibdisplayEdidWrapper.cpp

@@ -45,23 +45,48 @@ void LibdisplayEdidWrapper::GetSupportedHdrTypes(std::vector<ui::Hdr> &types) {
   const auto *colorimetries = di_info_get_supported_signal_colorimetry(info_);
   if (colorimetries->bt2020_cycc || colorimetries->bt2020_ycc ||
       colorimetries->bt2020_rgb) {
+#if 0
     if (hdr_static_meta->hlg)
       types.emplace_back(ui::Hdr::HLG);
+#endif
     if (hdr_static_meta->pq)
       types.emplace_back(ui::Hdr::HDR10);
   }
 }
 
-void LibdisplayEdidWrapper::GetHdrCapabilities(
-    std::vector<ui::Hdr> &types, float *max_luminance,
-    float *max_average_luminance, float *min_luminance) {
+void LibdisplayEdidWrapper::GetHdrCapabilities(std::vector<ui::Hdr> &types,
+                                               float *max_luminance,
+                                               float *max_average_luminance,
+                                               float *min_luminance) {
   GetSupportedHdrTypes(types);
 
   const auto *hdr_static_meta = di_info_get_hdr_static_metadata(info_);
   *max_luminance = hdr_static_meta->desired_content_max_luminance;
   *max_average_luminance = hdr_static_meta
                                ->desired_content_max_frame_avg_luminance;
   *min_luminance = hdr_static_meta->desired_content_min_luminance;
+
+  if (types.empty()) {
+    // No HDR support, set luminance to SDR values.
+    *max_luminance = 100.0f;
+    *max_average_luminance = 100.0f;
+    *min_luminance = 0.0f;
+    return;
+  }
+
+  /* hack for LG TV */
+  char *str = di_info_get_model(info_);
+  std::string make_str = str ? str : "";
+  free(str);
+  if (make_str.find("LG TV SSCR") != std::string::npos) {
+    if (*max_luminance <= 1.0f) {
+      // Fallback to typical values if not provided.
+      *max_luminance = 1000.0f;
+      *max_average_luminance = 1000.0f;
+      *min_luminance = 0.0001f;
+      return;
+    }
+  }
 }
 
 void LibdisplayEdidWrapper::GetColorModes(std::vector<Colormode> &color_modes) {
@@ -141,44 +166,43 @@ auto LibdisplayEdidWrapper::GetDpi() -> std::pair<int32_t, int32_t> {
           dtd->vert_video * kUmPerInch / dtd->vert_image_mm};
 }
 
-void LibdisplayEdidWrapper::GetColorGamut(
-        std::array<float2, 3> &primaries, float2 &whitepoint) {
-
-    const struct di_color_primaries *primaries_info;
-    primaries_info = di_info_get_default_color_primaries(info_);
-    if (!primaries_info) {
-        /*
-         * https://www.w3.org/Graphics/Color/sRGB.html
-         * ITU-R BT.709 sRGB
-         */
-        primaries[0].x = 0.640;
-        primaries[0].y = 0.330;
-        primaries[1].x = 0.300;
-        primaries[1].y = 0.600;
-        primaries[2].x = 0.150;
-        primaries[2].y = 0.060;
-
-        whitepoint.x = 0.313;
-        whitepoint.y = 0.329;
-    } else {
-        primaries[0].x = primaries_info->primary[0].x;
-        primaries[0].y = primaries_info->primary[0].y;
-        primaries[1].x = primaries_info->primary[1].x;
-        primaries[1].y = primaries_info->primary[1].y;
-        primaries[2].x = primaries_info->primary[2].x;
-        primaries[2].y = primaries_info->primary[2].y;
-
-        whitepoint.x = primaries_info->default_white.x;
-        whitepoint.y = primaries_info->default_white.y;
-    }
+void LibdisplayEdidWrapper::GetColorGamut(std::array<float2, 3> &primaries,
+                                          float2 &whitepoint) {
+  const struct di_color_primaries *primaries_info;
+  primaries_info = di_info_get_default_color_primaries(info_);
+  if (!primaries_info) {
+    /*
+     * https://www.w3.org/Graphics/Color/sRGB.html
+     * ITU-R BT.709 sRGB
+     */
+    primaries[0].x = 0.640;
+    primaries[0].y = 0.330;
+    primaries[1].x = 0.300;
+    primaries[1].y = 0.600;
+    primaries[2].x = 0.150;
+    primaries[2].y = 0.060;
+
+    whitepoint.x = 0.313;
+    whitepoint.y = 0.329;
+  } else {
+    primaries[0].x = primaries_info->primary[0].x;
+    primaries[0].y = primaries_info->primary[0].y;
+    primaries[1].x = primaries_info->primary[1].x;
+    primaries[1].y = primaries_info->primary[1].y;
+    primaries[2].x = primaries_info->primary[2].x;
+    primaries[2].y = primaries_info->primary[2].y;
+
+    whitepoint.x = primaries_info->default_white.x;
+    whitepoint.y = primaries_info->default_white.y;
+  }
 
-    ALOGI("print ColorGamut:");
-    ALOGI("    red %f %f"  ,primaries[0].x, primaries[0].y);
-    ALOGI("  grean %f %f"  ,primaries[1].x, primaries[1].y);
-    ALOGI("   blue %f %f"  ,primaries[2].x, primaries[2].y);
-    ALOGI("  white %f %f"  ,whitepoint.x, whitepoint.y);
+  ALOGI("print ColorGamut:");
+  ALOGI("    red %f %f", primaries[0].x, primaries[0].y);
+  ALOGI("  grean %f %f", primaries[1].x, primaries[1].y);
+  ALOGI("   blue %f %f", primaries[2].x, primaries[2].y);
+  ALOGI("  white %f %f", whitepoint.x, whitepoint.y);
 
-    return;
+  return;
 }
 
 }  // namespace android