enable hdr

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/DrmAtomicStateManager.cpp

@@ -159,7 +159,9 @@ auto DrmAtomicStateManager::CommitFrame(AtomicCommitArgs &args) -> int {
       return -EINVAL;
   }
 
+  //ALOGI("kanli before hdr\n");
   if (args.hdr_metadata && connector->GetHdrOutputMetadataProperty()) {
+  ALOGI("kanli set hdr meta\n");
     auto blob = drm->RegisterUserPropertyBlob(args.hdr_metadata.get(),
                                               sizeof(hdr_output_metadata));
     new_frame_state.hdr_metadata_blob = std::move(blob);

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,8 @@ 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>();
+  ALOGI("kanli create HwcDisplay");
   if (type_ == HWC2::DisplayType::Virtual) {
     writeback_layer_ = std::make_unique<HwcLayer>(this, false);
   }
@@ -546,12 +548,19 @@ HWC2::Error HwcDisplay::GetActiveConfig(hwc2_config_t *config) const {
 
 HWC2::Error HwcDisplay::GetColorModes(uint32_t *num_modes, int32_t *modes) {
   ATRACE_CALL();
+#if 1
   if (IsInHeadlessMode()) {
     *num_modes = 1;
     if (modes)
       modes[0] = HAL_COLOR_MODE_NATIVE;
     return HWC2::Error::None;
   }
+#else
+  *num_modes = 1;
+  if (modes)
+	  modes[0] = HAL_COLOR_MODE_NATIVE;
+  return HWC2::Error::None;
+#endif
 
   if (!modes) {
     std::vector<Colormode> temp_modes;
@@ -561,16 +570,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;
+  } 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 +715,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 +936,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("kanli SetColorMode %d", mode);
   switch (mode) {
     case HAL_COLOR_MODE_NATIVE:
       hdr_metadata_.reset();
@@ -1145,6 +1169,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 +1182,25 @@ 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;
 }

hwc3/ComposerClient.cpp

@@ -823,18 +823,22 @@ ndk::ScopedAStatus ComposerClient::getColorModes(
 
   uint32_t num_modes = 0;
   auto error = Hwc2toHwc3Error(display->GetColorModes(&num_modes, nullptr));
+  ALOGI("kanli num_modes 1 %d", num_modes);
   if (error != hwc3::Error::kNone) {
     return ToBinderStatus(error);
   }
 
   std::vector<int32_t> hwc2_color_modes(num_modes);
   error = Hwc2toHwc3Error(
       display->GetColorModes(&num_modes, hwc2_color_modes.data()));
+        ALOGI("kanli num_modes 2 %d", num_modes);
+
   if (error != hwc3::Error::kNone) {
     return ToBinderStatus(error);
   }
 
   for (const auto& mode : hwc2_color_modes) {
+	ALOGI("kanli getColorModes %d",Hwc2ColorModeToHwc3(mode));
     color_modes->push_back(Hwc2ColorModeToHwc3(mode));
   }
 
@@ -928,9 +932,13 @@ ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(
     return ToBinderStatus(error);
   }
 
+  ALOGI("kanli %s %d 1 num_capabilities %d",__FUNCTION__,__LINE__, num_capabilities);
+
   std::vector<uint32_t> out_caps(num_capabilities);
   error = Hwc2toHwc3Error(
       display->GetDisplayCapabilities(&num_capabilities, out_caps.data()));
+
+  ALOGI("kanli %s %d 2 num_capabilities %d",__FUNCTION__,__LINE__, num_capabilities);
   if (error != hwc3::Error::kNone) {
     return ToBinderStatus(error);
   }
@@ -1137,8 +1145,9 @@ ndk::ScopedAStatus ComposerClient::getHdrCapabilities(int64_t display_id,
   }
 
   caps->types.reserve(num_types);
-  for (const auto type : out_types)
+  for (const auto type : out_types) {
     caps->types.emplace_back(Hwc2HdrTypeToHwc3(type));
+  }
 
   return ndk::ScopedAStatus::ok();
 }

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