Enhancements to enable High Dynamic Range (HDR) processing

Introducing support for SDR-to-HDR switching in the hardware composer
(HWC) of the display system. Enhancements include pipeline updates,
the addition of degamma/gamma Look-Up Table (LUT) handling,
and support for building HDR metadata, gamma transformations, and color space
conversions. Additionally, the patch refactors code to adjust HDR property
management and integrates new classes and utility methods for HDR processing.

Key aspects of the patch include:

Added HdrPipeline module to handle HDR-specific degamma, gamma, and
color matrix operations.
Updated DrmAtomicStateManager to support HDR properties,
degamma/gamma LUT blobs, and relevant atomic properties during frame commits.
Enhanced the HwcDisplay class to manage HDR metadata, degamma/gamma LUTs, HDR
activation states, and to support the configuration of HDR output metadata.
Fixed the issue where HDR settings weren't being properly cleared during SDR
mode, resolving transition errors.

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

Author: kanlihu

Android.bp

@@ -86,6 +86,7 @@ filegroup {
         "drm/DrmMode.cpp",
         "drm/DrmPlane.cpp",
         "drm/DrmProperty.cpp",
+        "drm/HdrPipeline.cpp",
         "drm/ResourceManager.cpp",
         "drm/UEventListener.cpp",
         "drm/VSyncWorker.cpp",

drm/DrmAtomicStateManager.cpp

@@ -18,15 +18,15 @@
 
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 #define LOG_TAG "drmhwc"
+#include "DrmAtomicStateManager.h"
 #include <drm/drm_fourcc.h>
 #include <cmath>
-#include "DrmAtomicStateManager.h"
 
 #include <drm/drm_mode.h>
 #include <sync/sync.h>
 #include <utils/Trace.h>
-#include "utils/intel_blit.h"
 #include <cassert>
+#include "utils/intel_blit.h"
 
 #include "drm/DrmCrtc.h"
 #include "drm/DrmDevice.h"
@@ -132,20 +132,6 @@ auto DrmAtomicStateManager::CommitFrame(AtomicCommitArgs &args) -> int {
     }
   }
 
-  if (args.color_matrix && crtc->GetCtmProperty()) {
-    auto blob = drm->RegisterUserPropertyBlob(args.color_matrix.get(),
-                                              sizeof(drm_color_ctm));
-    new_frame_state.ctm_blob = std::move(blob);
-
-    if (!new_frame_state.ctm_blob) {
-      ALOGE("Failed to create CTM blob");
-      return -EINVAL;
-    }
-
-    if (!crtc->GetCtmProperty().AtomicSet(*pset, *new_frame_state.ctm_blob))
-      return -EINVAL;
-  }
-
   if (args.colorspace && connector->GetColorspaceProperty()) {
     if (!connector->GetColorspaceProperty()
              .AtomicSet(*pset, connector->GetColorspacePropertyValue(
@@ -159,21 +145,89 @@ auto DrmAtomicStateManager::CommitFrame(AtomicCommitArgs &args) -> int {
       return -EINVAL;
   }
 
-  if (args.hdr_metadata && connector->GetHdrOutputMetadataProperty()) {
-    auto blob = drm->RegisterUserPropertyBlob(args.hdr_metadata.get(),
-                                              sizeof(hdr_output_metadata));
-    new_frame_state.hdr_metadata_blob = std::move(blob);
-    if (!new_frame_state.hdr_metadata_blob) {
-      ALOGE("Failed to create %s blob",
-            connector->GetHdrOutputMetadataProperty().GetName().c_str());
+  if (connector->GetHdrOutputMetadataProperty()) {
+    if (args.hdr_metadata) {
+      auto blob = drm->RegisterUserPropertyBlob(args.hdr_metadata.get(),
+                                                sizeof(hdr_output_metadata));
+      new_frame_state.hdr_metadata_blob = std::move(blob);
+      if (!new_frame_state.hdr_metadata_blob) {
+        ALOGE("Failed to create %s blob",
+              connector->GetHdrOutputMetadataProperty().GetName().c_str());
+        return -EINVAL;
+      }
+
+      if (!connector->GetHdrOutputMetadataProperty()
+               .AtomicSet(*pset, *new_frame_state.hdr_metadata_blob))
+        return -EINVAL;
+    } else {
+      if (!connector->GetHdrOutputMetadataProperty().AtomicSet(*pset, 0))
+        return -EINVAL;
+    }
+  }
+
+  if (args.color_matrix && crtc->GetCtmProperty()) {
+    auto blob = drm->RegisterUserPropertyBlob(args.color_matrix.get(),
+                                              sizeof(drm_color_ctm));
+    new_frame_state.ctm_blob = std::move(blob);
+
+    if (!new_frame_state.ctm_blob) {
+      ALOGE("Failed to create CTM blob");
       return -EINVAL;
     }
 
-    if (!connector->GetHdrOutputMetadataProperty()
-             .AtomicSet(*pset, *new_frame_state.hdr_metadata_blob))
+    if (!crtc->GetCtmProperty().AtomicSet(*pset, *new_frame_state.ctm_blob))
       return -EINVAL;
   }
 
+  // HDR pipeline handling (degamma -> CTM -> gamma)
+  // CTM matrix is set above
+  {
+    // Build blobs for degamma
+    if (crtc->GetDeGammaLutProperty()) {
+      if (args.degamma_lut) {
+        auto blob = drm->RegisterUserPropertyBlob(args.degamma_lut->data(),
+                                                  args.degamma_lut->size() *
+                                                      sizeof(drm_color_lut));
+        new_frame_state.degamma_blob = std::move(blob);
+        if (!new_frame_state.degamma_blob) {
+          ALOGE("Failed to create %s blob",
+                crtc->GetDeGammaLutProperty().GetName().c_str());
+          return -EINVAL;
+        }
+
+        if (!crtc->GetDeGammaLutProperty()
+                 .AtomicSet(*pset, *new_frame_state.degamma_blob))
+          return -EINVAL;
+      } else {
+        if (crtc->GetDeGammaLutProperty() &&
+         !crtc->GetDeGammaLutProperty().AtomicSet(*pset, 0))
+          return -EINVAL;
+      }
+    }
+    // Output gamma PQ
+    if (crtc->GetGammaLutProperty()) {
+      if (args.gamma_lut) {
+        auto blob = drm->RegisterUserPropertyBlob(args.gamma_lut->data(),
+                                                  args.gamma_lut->size() *
+                                                      sizeof(drm_color_lut));
+        new_frame_state.gamma_blob = std::move(blob);
+        if (!new_frame_state.gamma_blob) {
+          ALOGE("Failed to create %s blob",
+                crtc->GetGammaLutProperty().GetName().c_str());
+          return -EINVAL;
+        }
+
+        if (!crtc->GetGammaLutProperty().AtomicSet(*pset,
+                                                   *new_frame_state.gamma_blob))
+          return -EINVAL;
+      } else {
+        if (crtc->GetGammaLutProperty() &&
+         !crtc->GetGammaLutProperty().AtomicSet(*pset, 0))
+          return -EINVAL;
+      }
+    }
+  }
+
   auto unused_planes = new_frame_state.used_planes;
 
   if (args.composition) {
@@ -244,6 +298,10 @@ auto DrmAtomicStateManager::CommitFrame(AtomicCommitArgs &args) -> int {
     flags |= DRM_MODE_ATOMIC_NONBLOCK;
   }
 
+  if (args.hdr_enabled) {
+    args.color_adjustment = false;
+  }
+
   if (args.color_adjustment == true) {
     SetColorSaturationHue();
     SetColorBrightnessContrast();
@@ -709,6 +767,26 @@ auto DrmAtomicStateManager::ApplyPendingLUT(struct drm_color_lut *lut, uint64_t
   return 0;
 }
 
+auto DrmAtomicStateManager::ApplyPendingDeLUT(struct drm_color_lut *lut, uint64_t lut_size) -> int {
+  uint32_t lut_blob_id = 0;
+  if (pipe_->crtc->Get()->GetDeGammaLutProperty().id() == 0) {
+    ALOGE("GetDeGammaLutProperty().id() == 0");
+    return -EINVAL;
+  }
+
+  drmModeCreatePropertyBlob(
+    *(pipe_->device->GetFd()), lut, sizeof(struct drm_color_lut) * lut_size, &lut_blob_id);
+  if (lut_blob_id == 0) {
+    ALOGE("COLOR_ lut_blob_id == 0");
+    return -EINVAL;
+  }
+
+  drmModeObjectSetProperty(*(pipe_->device->GetFd()), pipe_->crtc->Get()->GetId(), DRM_MODE_OBJECT_CRTC,
+                           pipe_->crtc->Get()->GetDeGammaLutProperty().id(), lut_blob_id);
+  drmModeDestroyPropertyBlob(*(pipe_->device->GetFd()), lut_blob_id);
+  return 0;
+}
+
 auto DrmAtomicStateManager::SetColorSaturationHue(void) ->int{
   double color_transform_matrix[16] = {1.0, 0.0, 0.0, 0.0,
                                        0.0, 1.0, 0.0, 0.0,

drm/DrmAtomicStateManager.h

@@ -38,14 +38,18 @@ struct AtomicCommitArgs {
   std::optional<DrmMode> display_mode;
   std::optional<bool> active;
   std::shared_ptr<DrmKmsPlan> composition;
-  std::shared_ptr<drm_color_ctm> color_matrix;
   std::optional<Colorspace> colorspace;
   std::optional<int32_t> content_type;
   std::shared_ptr<hdr_output_metadata> hdr_metadata;
   bool color_adjustment = false;
   std::shared_ptr<DrmFbIdHandle> writeback_fb;
   SharedFd writeback_release_fence;
 
+  bool hdr_enabled = false;
+  std::shared_ptr<std::vector<drm_color_lut>> degamma_lut;
+  std::shared_ptr<std::vector<drm_color_lut>> gamma_lut;
+  std::shared_ptr<drm_color_ctm> color_matrix;
+
   /* out */
   SharedFd out_fence;
 
@@ -81,6 +85,8 @@ class DrmAtomicStateManager {
                                     uint32_t contrast_c,
                                     uint32_t brightness_c) ->int;
   auto ApplyPendingLUT(struct drm_color_lut *lut,  uint64_t lut_size) -> int;
+  auto ApplyPendingDeLUT(struct drm_color_lut *lut,  uint64_t lut_size) -> int;
+
   void StopThread() {
     {
       const std::unique_lock lock(mutex_);
@@ -105,7 +111,8 @@ class DrmAtomicStateManager {
     DrmModeUserPropertyBlobUnique mode_blob;
     DrmModeUserPropertyBlobUnique ctm_blob;
     DrmModeUserPropertyBlobUnique hdr_metadata_blob;
-
+    DrmModeUserPropertyBlobUnique degamma_blob;
+    DrmModeUserPropertyBlobUnique gamma_blob;
     int release_fence_pt_index{};
 
     /* To avoid setting the inactive state twice, which will fail the commit */

drm/DrmCrtc.cpp

@@ -25,6 +25,7 @@
 
 #include "DrmDevice.h"
 #include "DrmVirtgpu.h"
+#include "utils/properties.h"
 namespace android {
 
 static int GetCrtcProperty(const DrmDevice &dev, const DrmCrtc &crtc,
@@ -61,7 +62,8 @@ auto DrmCrtc::CreateInstance(DrmDevice &dev, uint32_t crtc_id, uint32_t index)
     return {};
   }
 
-  if (dev.GetColorAdjustmentEnabling()) {
+  if (dev.GetColorAdjustmentEnabling() ||
+    Properties::EnableHdrDisplay()) {
     ret = GetCrtcProperty(dev, *c, "CTM", &c->ctm_property_);
     if (ret != 0) {
       ALOGV("Missing optional CTM property");
@@ -78,6 +80,16 @@ auto DrmCrtc::CreateInstance(DrmDevice &dev, uint32_t crtc_id, uint32_t index)
       ALOGE("Failed to get GAMMA_LUT_SIZE property");
       return {};
     }
+
+    ret = GetCrtcProperty(dev, *c, "DEGAMMA_LUT", &c->de_gamma_lut_property_);
+    if (ret != 0) {
+      ALOGE("Failed to get DEGAMMA_LUT property");
+    }
+
+    ret = GetCrtcProperty(dev, *c, "DEGAMMA_LUT_SIZE", &c->de_gamma_lut_size_property_);
+    if (ret != 0) {
+      ALOGE("Failed to get DEGAMMA_LUT_SIZE property");
+    }
   }
 
   if (dev.GetName() == "virtio_gpu") {

drm/DrmCrtc.h

@@ -76,7 +76,13 @@ class DrmCrtc : public PipelineBindable<DrmCrtc> {
   auto &GetGammaLutSizeProperty() const {
     return gamma_lut_size_property_;
   }
+  auto &GetDeGammaLutProperty() const {
+    return de_gamma_lut_property_;
+  }
 
+  auto &GetDeGammaLutSizeProperty() const {
+    return de_gamma_lut_size_property_;
+  }
   bool GetAllowP2P() const {
     return allow_p2p_;
   }
@@ -91,6 +97,8 @@ class DrmCrtc : public PipelineBindable<DrmCrtc> {
   DrmProperty ctm_property_;
   DrmProperty gamma_lut_property_;
   DrmProperty gamma_lut_size_property_;
+  DrmProperty de_gamma_lut_property_;
+  DrmProperty de_gamma_lut_size_property_;
   DrmProperty active_property_;
   DrmProperty mode_property_;
   DrmProperty out_fence_ptr_property_;

drm/HdrPipeline.cpp

@@ -0,0 +1,89 @@
+#include "HdrPipeline.h"
+#include <xf86drmMode.h>
+#include <xf86drm.h>
+#include <math.h>
+
+std::vector<drm_color_lut> HdrPipeline::BuildSrgbDegamma(uint64_t size) {
+  std::vector<drm_color_lut> lut(size);
+  if (size < 2) return lut;
+  for (uint64_t i = 0; i < size; ++i) {
+    double e = double(i) / double(size - 1);
+    double l = (e <= 0.04045) ? (e / 12.92) : std::pow((e + 0.055) / 1.055, 2.4);
+    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;
+  }
+  return lut;
+}
+
+std::vector<drm_color_lut> HdrPipeline::BuildPqGamma(uint64_t size,
+    float max_luminance, float max_average_luminance,
+    float min_luminance) {
+  std::vector<drm_color_lut> lut(size);
+  if (size < 2) return lut;
+
+  // Clamp inputs
+  max_luminance        = std::max(1.0f, max_luminance);
+  max_average_luminance = std::max(1.0f, std::min(max_average_luminance, max_luminance));
+  min_luminance        = std::max(0.0f, std::min(min_luminance, max_average_luminance));
+
+  // ST2084 constants
+  const double m1 = 2610.0 / 16384.0;
+  const double m2 = 2523.0 / 32.0;
+  const double c1 = 3424.0 / 4096.0;
+  const double c2 = 2413.0 / 128.0;
+  const double c3 = 2392.0 / 128.0;
+
+  // Peak mapping: LUT 1.0 corresponds to panel peak (max_luminance)
+  // Tone map (knee) above max_average_luminance
+  const double knee_start = max_average_luminance;
+  const double knee_end   = max_luminance;
+  const double knee_range = std::max(1e-6, knee_end - knee_start);
+
+  for (uint64_t i = 0; i < size; ++i) {
+    double r = double(i) / double(size - 1); // 0..1 scene relative
+    // Map to physical luminance range
+    double L_scene = min_luminance + r * (max_luminance - min_luminance);
+
+    // Knee compression (Reinhard-like)
+    if (L_scene > knee_start) {
+      double x = (L_scene - knee_start) / knee_range; // 0..1
+      // Smooth compression: y = x / (1 + x) keeps derivatives finite
+      double comp = x / (1.0 + x);
+      L_scene = knee_start + comp * knee_range;
+    }
+
+    // Normalize to PQ absolute range (0..10000 nits)
+    double L_norm = std::clamp(L_scene / 10000.0, 0.0, 1.0);
+
+    // ST2084 OETF
+    double num = c1 + c2 * std::pow(L_norm, m1);
+    double den = 1.0 + c3 * std::pow(L_norm, m1);
+    double pq  = std::pow(num / den, m2);
+
+    uint16_t v = static_cast<uint16_t>(std::lround(std::clamp(pq, 0.0, 1.0) * 65535.0));
+    lut[i].red = lut[i].green = lut[i].blue = v;
+  }
+
+  // Ensure LUT[0] == 0
+  lut[0].red = lut[0].green = lut[0].blue = 0;
+  return lut;
+}
+
+std::shared_ptr<drm_color_ctm> HdrPipeline::BuildCtm709To2020() {
+  // Approximate Rec.709 -> Rec.2020 conversion matrix
+  double m[3][3] = {
+      {0.627404, 0.329282, 0.043313},
+      {0.069097, 0.919540, 0.011360},
+      {0.016391, 0.088013, 0.895595}
+  };
+  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

@@ -0,0 +1,14 @@
+#pragma once
+#include <vector>
+#include <stdint.h>
+#include <drm_mode.h>
+
+class HdrPipeline {
+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);
+  static std::shared_ptr<drm_color_ctm> BuildCtm709To2020();
+};