enable hdr

/vendor/build.prop
ro.surface_flinger.has_wide_color_display=true
ro.surface_flinger.has_HDR_display=true
vendor.hwc.drm.enable_hdr_display=true

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

Author: kanlihu

Android.bp

@@ -37,6 +37,7 @@ cc_defaults {
 
     static_libs: [
         "libaidlcommonsupport",
+        "libdisplay_info",
     ],
 
     header_libs: [
@@ -49,6 +50,7 @@ cc_defaults {
     ],
 
     cppflags: [
+        "-DHAS_LIBDISPLAY_INFO",
         "-DHWC2_INCLUDE_STRINGIFICATION",
         "-DHWC2_USE_CPP11",
     ],
@@ -99,6 +101,7 @@ filegroup {
         "hwc2_device/hwc2_device.cpp",
 
         "utils/LibdisplayEdidWrapper.cpp",
+        "utils/H3CdisplayEdidWrapper.cpp",
         "utils/fd.cpp",
         "utils/properties.cpp",
         "utils/intel_blit.cpp",
@@ -296,4 +299,4 @@ cc_library_shared {
     proprietary: true,
     header_libs: ["libcutils_headers"],
     relative_install_path: "hw",
-}
+}

drm/DrmConnector.cpp

@@ -97,10 +97,16 @@ auto DrmConnector::Init()-> bool {
 
   UpdateEdidProperty();
 #if HAS_LIBDISPLAY_INFO
-  auto edid = LibdisplayEdidWrapper::Create(GetEdidBlob());
-  edid_wrapper_ = edid ? std::move(edid) : std::make_unique<EdidWrapper>();
+  auto edid = H3CdisplayEdidWrapper::Create(GetEdidBlob());
+  if (edid) {
+	edid_wrapper_ = edid ? std::move(edid) : std::make_unique<EdidWrapper>();
+  } else {
+	  auto edid_new = LibdisplayEdidWrapper::Create(GetEdidBlob());
+	  edid_wrapper_ = edid_new ? std::move(edid_new) : std::make_unique<EdidWrapper>();
+  }
 #else
-  edid_wrapper_ = std::make_unique<EdidWrapper>();
+  auto edid = H3CdisplayEdidWrapper::Create(GetEdidBlob());
+  edid_wrapper_ = edid ? std::move(edid) : std::make_unique<EdidWrapper>();
 #endif
 
   if (IsWriteback() &&

hwc2_device/HwcDisplay.cpp

@@ -131,6 +131,7 @@ std::string HwcDisplay::Dump() {
 HwcDisplay::HwcDisplay(hwc2_display_t handle, HWC2::DisplayType type,
                        DrmHwc *hwc)
     : hwc_(hwc), handle_(handle), type_(type), client_layer_(this, false) {
+  hdr_metadata_ = std::make_shared<hdr_output_metadata>();
   if (type_ == HWC2::DisplayType::Virtual) {
     writeback_layer_ = std::make_unique<HwcLayer>(this, false);
   }
@@ -552,6 +553,12 @@ HWC2::Error HwcDisplay::GetColorModes(uint32_t *num_modes, int32_t *modes) {
       modes[0] = HAL_COLOR_MODE_NATIVE;
     return HWC2::Error::None;
   }
+  if (!Properties::EnableHdrDisplay()) {
+    *num_modes = 1;
+    if (modes)
+      modes[0] = HAL_COLOR_MODE_NATIVE;
+    return HWC2::Error::None;
+  }
 
   if (!modes) {
     std::vector<Colormode> temp_modes;
@@ -561,16 +568,19 @@ HWC2::Error HwcDisplay::GetColorModes(uint32_t *num_modes, int32_t *modes) {
   }
 
   std::vector<Colormode> temp_modes;
-  std::vector<int32_t> out_modes(modes, modes + *num_modes);
+  std::vector<int32_t> out_modes;
   GetEdid()->GetColorModes(temp_modes);
   if (temp_modes.empty()) {
-    out_modes.emplace_back(HAL_COLOR_MODE_NATIVE);
-    return HWC2::Error::None;
+      out_modes.emplace_back(HAL_COLOR_MODE_NATIVE);
+  } else {
+      for (auto &c : temp_modes) {
+          out_modes.emplace_back(static_cast<int32_t>(c));
+      }
   }
 
-  for (auto &c : temp_modes)
-    out_modes.emplace_back(static_cast<int32_t>(c));
-
+  for (size_t i = 0; i < out_modes.size(); ++i) {
+      modes[i] = out_modes[i];
+  }
   return HWC2::Error::None;
 }
 
@@ -703,22 +713,34 @@ HWC2::Error HwcDisplay::GetHdrCapabilities(uint32_t *num_types, int32_t *types,
   }
 
   std::vector<ui::Hdr> temp_types;
-  std::vector<int32_t> out_types(types, types + *num_types);
+  std::vector<int32_t> out_types;
   GetEdid()->GetHdrCapabilities(temp_types, max_luminance,
                                 max_average_luminance, min_luminance);
+
   for (auto &t : temp_types) {
     switch (t) {
+      case ui::Hdr::DOLBY_VISION:
+        out_types.emplace_back(HAL_HDR_DOLBY_VISION);
+        break;
       case ui::Hdr::HDR10:
         out_types.emplace_back(HAL_HDR_HDR10);
         break;
       case ui::Hdr::HLG:
         out_types.emplace_back(HAL_HDR_HLG);
         break;
+      case ui::Hdr::HDR10_PLUS:
+        out_types.emplace_back(HAL_HDR_HDR10_PLUS);
+        break;
       default:
         // Ignore any other HDR types
         break;
     }
   }
+
+  for (size_t i = 0; i < out_types.size(); ++i) {
+	  types[i] = out_types[i];
+  }
+
   return HWC2::Error::None;
 }
 
@@ -912,7 +934,7 @@ HWC2::Error HwcDisplay::SetColorMode(int32_t mode) {
    */
   if (mode < HAL_COLOR_MODE_NATIVE || mode > HAL_COLOR_MODE_DISPLAY_BT2020)
     return HWC2::Error::BadParameter;
-
+  ALOGI("hwc SetColorMode %d", mode);
   switch (mode) {
     case HAL_COLOR_MODE_NATIVE:
       hdr_metadata_.reset();
@@ -1145,6 +1167,7 @@ HWC2::Error HwcDisplay::SetHdrOutputMetadata(ui::Hdr type) {
   m->min_display_mastering_luminance = static_cast<uint64_t>(hdr_luminance[2] *
                                                              10000.F);
 
+#if 0
   auto gamut = ColorGamut::BT2020();
   auto primaries = gamut.getPrimaries();
   m->display_primaries[0].x = ToU16ColorValue(primaries[0].x);
@@ -1157,6 +1180,24 @@ HWC2::Error HwcDisplay::SetHdrOutputMetadata(ui::Hdr type) {
   auto whitePoint = gamut.getWhitePoint();
   m->white_point.x = ToU16ColorValue(whitePoint.x);
   m->white_point.y = ToU16ColorValue(whitePoint.y);
+#else
+  auto gamut = ColorGamut::BT2020();
+  auto primaries = gamut.getPrimaries();
+  auto whitePoint = gamut.getWhitePoint();
+
+  GetEdid()->GetColorGamut(primaries, whitePoint);
+
+  m->display_primaries[0].x = ToU16ColorValue(primaries[0].x);
+  m->display_primaries[0].y = ToU16ColorValue(primaries[0].y);
+  m->display_primaries[1].x = ToU16ColorValue(primaries[1].x);
+  m->display_primaries[1].y = ToU16ColorValue(primaries[1].y);
+  m->display_primaries[2].x = ToU16ColorValue(primaries[2].x);
+  m->display_primaries[2].y = ToU16ColorValue(primaries[2].y);
+
+  m->white_point.x = ToU16ColorValue(whitePoint.x);
+  m->white_point.y = ToU16ColorValue(whitePoint.y);
+
+#endif
 
   return HWC2::Error::None;
 }

utils/EdidWrapper.h

@@ -24,6 +24,7 @@ extern "C" {
 #endif
 
 #include <ui/GraphicTypes.h>
+#include <ui/ColorSpace.h>
 
 #include "compositor/DisplayInfo.h"
 #include "drm/DrmUnique.h"
@@ -41,9 +42,9 @@ class EdidWrapper {
     types.clear();
   };
   virtual void GetHdrCapabilities(std::vector<ui::Hdr> &types,
-                                  const float * /*max_luminance*/,
-                                  const float * /*max_average_luminance*/,
-                                  const float * /*min_luminance*/) {
+                                  float * /*max_luminance*/,
+                                  float * /*max_average_luminance*/,
+                                  float * /*min_luminance*/) {
     GetSupportedHdrTypes(types);
   };
   virtual void GetColorModes(std::vector<Colormode> &color_modes) {
@@ -59,6 +60,10 @@ class EdidWrapper {
   virtual auto GetBoundsMm() -> std::pair<int32_t, int32_t> {
     return {-1, -1};
   }
+
+  virtual void GetColorGamut(
+    std::array<float2, 3> &primaries, float2 &whitepoint) {
+  }
 };
 
 #if HAS_LIBDISPLAY_INFO
@@ -75,9 +80,9 @@ class LibdisplayEdidWrapper final : public EdidWrapper {
   void GetSupportedHdrTypes(std::vector<ui::Hdr> &types) override;
 
   void GetHdrCapabilities(std::vector<ui::Hdr> &types,
-                          const float *max_luminance,
-                          const float *max_average_luminance,
-                          const float *min_luminance) override;
+                          float *max_luminance,
+                          float *max_average_luminance,
+                          float *min_luminance) override;
 
   void GetColorModes(std::vector<Colormode> &color_modes) override;
 
@@ -86,6 +91,9 @@ class LibdisplayEdidWrapper final : public EdidWrapper {
 
   auto GetBoundsMm() -> std::pair<int32_t, int32_t> override;
 
+  void GetColorGamut(
+    std::array<float2, 3> &primaries, float2 &whitepoint) override;
+
  private:
   LibdisplayEdidWrapper(di_info *info) : info_(std::move(info)) {
   }
@@ -96,4 +104,44 @@ class LibdisplayEdidWrapper final : public EdidWrapper {
 };
 #endif
 
+// Wrapper class for that uses hack H3Cdisplay-info to parse edids
+class H3CdisplayEdidWrapper final : public EdidWrapper {
+ public:
+  H3CdisplayEdidWrapper() = delete;
+  ~H3CdisplayEdidWrapper() override {
+  }
+  static auto Create(DrmModePropertyBlobUnique blob)
+      -> std::unique_ptr<H3CdisplayEdidWrapper>;
+
+  void GetSupportedHdrTypes(std::vector<ui::Hdr> &types) override;
+
+  void GetHdrCapabilities(std::vector<ui::Hdr> &types,
+                          float *max_luminance,
+                          float *max_average_luminance,
+                          float *min_luminance) override;
+
+  void GetColorModes(std::vector<Colormode> &color_modes) override;
+
+  auto GetDpiX() -> int override;
+  auto GetDpiY() -> int override;
+
+  auto GetBoundsMm() -> std::pair<int32_t, int32_t> override;
+
+  void GetColorGamut(
+    std::array<float2, 3> &primaries, float2 &whitepoint) override;
+
+ private:
+  H3CdisplayEdidWrapper(void *date, size_t length);
+
+  std::pair<int32_t, int32_t> GetDpi();
+
+  static constexpr int32_t kWidthPixels = 2880;
+  static constexpr int32_t kHeightPixels = 1800;
+  static constexpr int32_t kWidthMm = 301;
+  static constexpr int32_t kHeightMm = 189;
+  static constexpr float kMaxLuminance = 507.5f;
+  static constexpr float kMaxAvgLuminance = 507.5f;
+  static constexpr float kMinLuminance = 0.004f;
+};
+
 }  // namespace android