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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}

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 @@ namespace display_device {
 
  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 @@ namespace display_device {
  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));
+}