feat: add methods for handling hdr state

src/common/include/displaydevice/types.h

@@ -1,6 +1,14 @@
 #pragma once
 
 namespace display_device {
+  /**
+   * @brief The device's HDR state in the operating system.
+   */
+  enum class HdrState {
+    Disabled,
+    Enabled
+  };
+
   /**
    * @brief Display's resolution.
    */

src/windows/include/displaydevice/windows/types.h

@@ -91,4 +91,8 @@ namespace display_device {
    */
   using DeviceDisplayModeMap = std::map<std::string, DisplayMode>;
 
+  /**
+   * @brief Ordered map of [DEVICE_ID -> std::optional<HdrState>].
+   */
+  using HdrStateMap = std::map<std::string, std::optional<HdrState>>;
 }  // namespace display_device

src/windows/include/displaydevice/windows/winapilayer.h

@@ -36,5 +36,13 @@ namespace display_device {
     /** For details @see WinApiLayerInterface::setDisplayConfig */
     [[nodiscard]] LONG
     setDisplayConfig(std::vector<DISPLAYCONFIG_PATH_INFO> paths, std::vector<DISPLAYCONFIG_MODE_INFO> modes, UINT32 flags) override;
+
+    /** For details @see WinApiLayerInterface::getHdrState */
+    [[nodiscard]] std::optional<HdrState>
+    getHdrState(const DISPLAYCONFIG_PATH_INFO &path) const override;
+
+    /** For details @see WinApiLayerInterface::setHdrState */
+    [[nodiscard]] bool
+    setHdrState(const DISPLAYCONFIG_PATH_INFO &path, HdrState state) override;
   };
 }  // namespace display_device

src/windows/include/displaydevice/windows/winapilayerinterface.h

@@ -166,5 +166,36 @@ namespace display_device {
      */
     [[nodiscard]] virtual LONG
     setDisplayConfig(std::vector<DISPLAYCONFIG_PATH_INFO> paths, std::vector<DISPLAYCONFIG_MODE_INFO> modes, UINT32 flags) = 0;
+
+    /**
+     * @brief Get the HDR state the path.
+     * @param path Path to get HDR state for.
+     * @returns std::nullopt if the state could not be retrieved, or other enum values describing the state otherwise.
+     *
+     * EXAMPLES:
+     * ```cpp
+     * DISPLAYCONFIG_PATH_INFO path;
+     * const WinApiLayerInterface* iface = getIface(...);
+     * const auto hdr_state = iface->getHdrState(path);
+     * ```
+     */
+    [[nodiscard]] virtual std::optional<HdrState>
+    getHdrState(const DISPLAYCONFIG_PATH_INFO &path) const = 0;
+
+    /**
+     * @brief Set the HDR state for the path.
+     * @param path Path to set HDR state for.
+     * @param state Specify new HDR state.
+     * @returns True if the device is in the new state, false otherwise.
+     *
+     * EXAMPLES:
+     * ```cpp
+     * DISPLAYCONFIG_PATH_INFO path;
+     * const WinApiLayerInterface* iface = getIface(...);
+     * const bool success = iface->setHdrState(path, HdrState::Enabled);
+     * ```
+     */
+    [[nodiscard]] virtual bool
+    setHdrState(const DISPLAYCONFIG_PATH_INFO &path, HdrState state) = 0;
   };
 }  // namespace display_device

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -51,6 +51,14 @@ namespace display_device {
     [[nodiscard]] bool
     setAsPrimary(const std::string &device_id) override;
 
+    /** For details @see WinDisplayDeviceInterface::getCurrentHdrStates */
+    [[nodiscard]] HdrStateMap
+    getCurrentHdrStates(const std::set<std::string> &device_ids) const override;
+
+    /** For details @see WinDisplayDeviceInterface::setHdrStates */
+    [[nodiscard]] bool
+    setHdrStates(const HdrStateMap &states) override;
+
   private:
     std::shared_ptr<WinApiLayerInterface> m_w_api;
   };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -150,5 +150,40 @@ namespace display_device {
      */
     [[nodiscard]] virtual bool
     setAsPrimary(const std::string &device_id) = 0;
+
+    /**
+     * @brief Get HDR state for the devices.
+     * @param device_ids A list of devices to get the HDR states for.
+     * @returns A map of HDR states per a device or an empty map if an error has occurred.
+     * @note On Windows the state cannot be retrieved until the device is active even if it supports it.
+     *
+     * EXAMPLES:
+     * ```cpp
+     * const WinDisplayDeviceInterface* iface = getIface(...);
+     * const std::unordered_set<std::string> device_ids { "DEVICE_ID_1", "DEVICE_ID_2" };
+     * const auto current_hdr_states = iface->getCurrentHdrStates(device_ids);
+     * ```
+     */
+    [[nodiscard]] virtual HdrStateMap
+    getCurrentHdrStates(const std::set<std::string> &device_ids) const = 0;
+
+    /**
+     * @brief Set HDR states for the devices.
+     * @param modes A map of HDR states to set.
+     * @returns True if HDR states were set, false otherwise.
+     * @note If `unknown` states are provided, they will be silently ignored
+     *       and current state will not be changed.
+     *
+     * EXAMPLES:
+     * ```cpp
+     * const WinDisplayDeviceInterface* iface = getIface(...);
+     * const std::string display_a { "MY_ID_1" };
+     * const std::string display_b { "MY_ID_2" };
+     * const auto success = iface->setHdrStates({ { display_a, HdrState::Enabled },
+     *                                            { display_b, HdrState::Disabled } });
+     * ```
+     */
+    [[nodiscard]] virtual bool
+    setHdrStates(const HdrStateMap &states) = 0;
   };
 }  // namespace display_device

src/windows/winapilayer.cpp

@@ -522,7 +522,7 @@
 
     LONG result { DisplayConfigGetDeviceInfo(&source_name.header) };
     if (result != ERROR_SUCCESS) {
-      DD_LOG(error) << getErrorString(result) << " failed to get display name! ";
+      DD_LOG(error) << getErrorString(result) << " failed to get display name!";
       return {};
     }
 
@@ -539,4 +539,39 @@
       modes.empty() ? nullptr : modes.data(),
       flags);
   }
+
+  std::optional<HdrState>
+  WinApiLayer::getHdrState(const DISPLAYCONFIG_PATH_INFO &path) const {
+    DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO color_info = {};
+    color_info.header.adapterId = path.targetInfo.adapterId;
+    color_info.header.id = path.targetInfo.id;
+    color_info.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO;
+    color_info.header.size = sizeof(color_info);
+
+    LONG result { DisplayConfigGetDeviceInfo(&color_info.header) };
+    if (result != ERROR_SUCCESS) {
+      DD_LOG(error) << getErrorString(result) << " failed to get advanced color info!";
+      return std::nullopt;
+    }
+
+    return color_info.advancedColorSupported ? std::make_optional(color_info.advancedColorEnabled ? HdrState::Enabled : HdrState::Disabled) : std::nullopt;
+  }
+
+  bool
+  WinApiLayer::setHdrState(const DISPLAYCONFIG_PATH_INFO &path, HdrState state) {
+    DISPLAYCONFIG_SET_ADVANCED_COLOR_STATE color_state = {};
+    color_state.header.adapterId = path.targetInfo.adapterId;
+    color_state.header.id = path.targetInfo.id;
+    color_state.header.type = DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE;
+    color_state.header.size = sizeof(color_state);
+    color_state.enableAdvancedColor = state == HdrState::Enabled ? 1 : 0;
+
+    LONG result { DisplayConfigSetDeviceInfo(&color_state.header) };
+    if (result != ERROR_SUCCESS) {
+      DD_LOG(error) << getErrorString(result) << " failed to set advanced color info!";
+      return false;
+    }
+
+    return true;
+  }
 }  // namespace display_device

src/windows/windisplaydevicehdr.cpp

@@ -0,0 +1,127 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// system includes
+#include <ranges>
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+  namespace {
+    /** @brief HDR state map without optional values. */
+    using HdrStateMapNoOpt = std::map<std::string, HdrState>;
+
+    /**
+     * @see setHdrStates for a description as this was split off to reduce cognitive complexity.
+     */
+    bool
+    doSetHdrStates(WinApiLayerInterface &w_api, const PathAndModeData &display_data, const HdrStateMapNoOpt &states, HdrStateMapNoOpt *changed_states) {
+      const auto try_set_state {
+        [&w_api, &display_data](const auto &device_id, const auto &state, auto &current_state) {
+          const auto path { win_utils::getActivePath(w_api, device_id, display_data.m_paths) };
+          if (!path) {
+            DD_LOG(error) << "Failed to find device for " << device_id << "!";
+            return false;
+          }
+
+          const auto current_state_int { w_api.getHdrState(*path) };
+          if (!current_state_int) {
+            DD_LOG(error) << "HDR state cannot be changed for " << device_id << "!";
+            return false;
+          }
+
+          if (state != *current_state_int) {
+            if (!w_api.setHdrState(*path, state)) {
+              // Error already logged
+              return false;
+            }
+
+            current_state = current_state_int;
+          }
+
+          return true;
+        }
+      };
+
+      for (const auto &[device_id, state] : states) {
+        std::optional<HdrState> current_state;
+        if (try_set_state(device_id, state, current_state)) {
+          if (current_state && changed_states != nullptr) {
+            (*changed_states)[device_id] = *current_state;
+          }
+        }
+        // If we are undoing changes we don't want to return early and continue regardless of what error we get.
+        else if (changed_states != nullptr) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+  }  // namespace
+
+  HdrStateMap
+  WinDisplayDevice::getCurrentHdrStates(const std::set<std::string> &device_ids) const {
+    if (device_ids.empty()) {
+      DD_LOG(error) << "Device id set is empty!";
+      return {};
+    }
+
+    const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+    if (!display_data) {
+      // Error already logged
+      return {};
+    }
+
+    HdrStateMap states;
+    for (const auto &device_id : device_ids) {
+      const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+      if (!path) {
+        DD_LOG(error) << "Failed to find device for " << device_id << "!";
+        return {};
+      }
+
+      states[device_id] = m_w_api->getHdrState(*path);
+    }
+
+    return states;
+  }
+
+  bool
+  WinDisplayDevice::setHdrStates(const HdrStateMap &states) {
+    if (states.empty()) {
+      DD_LOG(error) << "States map is empty!";
+      return false;
+    }
+
+    HdrStateMapNoOpt states_without_opt;
+    std::ranges::copy(states |
+                        std::ranges::views::filter([](const auto &entry) { return static_cast<bool>(entry.second); }) |
+                        std::views::transform([](const auto &entry) { return std::make_pair(entry.first, *entry.second); }),
+      std::inserter(states_without_opt, std::begin(states_without_opt)));
+
+    if (states_without_opt.empty()) {
+      // Return early as there is nothing to do...
+      return true;
+    }
+
+    const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+    if (!display_data) {
+      // Error already logged
+      return {};
+    }
+
+    HdrStateMapNoOpt changed_states;
+    if (!doSetHdrStates(*m_w_api, *display_data, states_without_opt, &changed_states)) {
+      if (!changed_states.empty()) {
+        doSetHdrStates(*m_w_api, *display_data, changed_states, nullptr);  // return value does not matter
+      }
+      return false;
+    }
+
+    return true;
+  }
+}  // namespace display_device

tests/unit/windows/test_winapilayer.cpp

@@ -204,3 +204,11 @@ TEST_F_S(GetDisplayName) {
 TEST_F_S(GetDisplayName, InvalidPath) {
   EXPECT_EQ(m_layer.getDisplayName(INVALID_PATH), std::string {});
 }
+
+TEST_F_S(GetHdrState, InvalidPath) {
+  EXPECT_EQ(m_layer.getHdrState(INVALID_PATH), std::nullopt);
+}
+
+TEST_F_S(SetHdrState, InvalidPath) {
+  EXPECT_FALSE(m_layer.setHdrState(INVALID_PATH, display_device::HdrState::Enabled));
+}