Optimizes composition strategies for single HDR video layers

Backend::ValidateDisplay
Check for a single HDR video layer via IsHdrVideoLayer().
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 all layers to client.

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

Author: kanlihu

backend/Backend.cpp

@@ -127,12 +127,21 @@ std::tuple<int, size_t> Backend::GetClientLayers(
 }
 
 bool Backend::IsClientLayer(HwcDisplay *display, HwcLayer *layer) {
+  // if display has hdr layer
+  if (display->HasHdrLayer()) {
+    auto [has_single_hdr_video, hdr_layer] = display->HasSingleHdrVideoLayer();
+    // if display have single hdr layer, try to set layer to device mode
+    // else set all layers to client
+    if (!(has_single_hdr_video && layer == hdr_layer)) {
+      return true;
+    }
+    //only single hdr video layer passthrough
+  }
   return !HardwareSupportsLayerType(layer->GetSfType()) ||
          !layer->IsLayerUsableAsDevice() || display->CtmByGpu() ||
          (layer->GetLayerData().pi.RequireScalingOrPhasing() &&
           display->GetHwc()->GetResMan().ForcedScalingWithGpu()) ||
-         (!display->IsInHeadlessMode() && display->GetPipe().device->IsIvshmDev()) ||
-         (!display->isSingleDeviceHdrLayer().first && layer->IsHDRLayer()); // only single hdrlayer will use device
+         (!display->IsInHeadlessMode() && display->GetPipe().device->IsIvshmDev());
 }
 
 bool Backend::IsVideoLayer(HwcLayer *layer) {

hwc2_device/HwcDisplay.cpp

@@ -782,14 +782,14 @@ AtomicCommitArgs HwcDisplay::CreateModesetCommit(
   return args;
 }
 
-auto HwcDisplay::isSingleDeviceHdrLayer() -> std::pair<bool, HwcLayer*> const {
+auto HwcDisplay::HasSingleHdrVideoLayer() -> 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()) {
+        if (layer.IsHdrVideoLayer()) {
           hdr_layer_count++;
           hdr_layer = &layer;
         } else {
@@ -803,13 +803,28 @@ auto HwcDisplay::isSingleDeviceHdrLayer() -> std::pair<bool, HwcLayer*> const {
     );
   }
 
-void HwcDisplay::resetHdrPipeLineWhenSingleDeviceHDRLayer(
+auto HwcDisplay::HasHdrLayer() -> bool {
+  for (auto& pair : layers_) {
+    auto& layer = pair.second;
+    if (layer.IsHdrLayer()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/*
+ * reset HDR color pipeline when there is single video layer
+ * The kernel driver will handle HDR video YUV10 pq gamma output
+ *
+ * a_args: args that build commit pipeline
+ */
+void HwcDisplay::TryResetHdrPipeline(
 	AtomicCommitArgs &a_args) {
-  // HDR video layer logic
-  auto only_hdr_layer = isSingleDeviceHdrLayer();
+  auto [only_hdr_layer, hdr_layer] = HasSingleHdrVideoLayer();
 
-  if (only_hdr_layer.first && only_hdr_layer.second
-    && only_hdr_layer.second->GetValidatedType() == HWC2::Composition::Device) {
+  if (only_hdr_layer && hdr_layer
+    && hdr_layer->GetValidatedType() == HWC2::Composition::Device) {
     // Disable all HDR pipeline for direct device scanout
     a_args.color_matrix = HdrPipeline::BuildCtmIdentity();
     a_args.degamma_lut.reset();
@@ -899,7 +914,7 @@ HWC2::Error HwcDisplay::CreateComposition(AtomicCommitArgs &a_args) {
   if (z_map.empty())
     return HWC2::Error::BadLayer;
 
-  resetHdrPipeLineWhenSingleDeviceHDRLayer(a_args);
+  TryResetHdrPipeline(a_args);
   std::vector<LayerData> composition_layers;
 
   /* Import & populate */

hwc2_device/HwcDisplay.h

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

hwc2_device/HwcLayer.cpp

@@ -112,12 +112,16 @@ bool HwcLayer::IsVideoLayer() {
       slots_[*active_slot_id_].bi.usage & GRALLOC_USAGE_HW_VIDEO_ENCODER;
 }
 
-bool HwcLayer::IsHDRLayer() {
+bool HwcLayer::IsHdrVideoLayer() {
   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);
 }
 
+bool HwcLayer::IsHdrLayer() {
+  return color_space_ == BufferColorSpace::kItuRec2020;
+}
+
 void HwcLayer::ImportFb() {
   if (!IsLayerUsableAsDevice() || !buffer_updated_ ||
       !active_slot_id_.has_value()) {

hwc2_device/HwcLayer.h

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