HDR prep work (#808)

2023-01-23 20:54:08 -06:00
parent fa6c279efc
commit 9181028bcf
15 changed files with 294 additions and 77 deletions
--- a/src/platform/common.h
+++ b/src/platform/common.h
@@ -15,6 +15,10 @@
 #include "src/thread_safe.h"
 #include "src/utility.h"

+extern "C" {
+#include <moonlight-common-c/src/Limelight.h>
+}
+
 struct sockaddr;
 struct AVFrame;
 struct AVBufferRef;
@@ -39,6 +43,9 @@ class basic_environment;
 typedef basic_environment<char> environment;
 } // namespace process
 } // namespace boost
+namespace video {
+struct config_t;
+}

 namespace platf {
 constexpr auto MAX_GAMEPADS = 32;
@@ -270,6 +277,15 @@ public:
    return std::make_shared<hwdevice_t>();
  }

+  virtual bool is_hdr() {
+    return false;
+  }
+
+  virtual bool get_hdr_metadata(SS_HDR_METADATA &metadata) {
+    std::memset(&metadata, 0, sizeof(metadata));
+    return false;
+  }
+
  virtual ~display_t() = default;

  // Offsets for when streaming a specific monitor. By default, they are 0.
@@ -315,11 +331,11 @@ std::unique_ptr<audio_control_t> audio_control();
 *    If display_name is empty --> Use the first monitor that's compatible you can find
 *    If you require to use this parameter in a seperate thread --> make a copy of it.
 * 
- * framerate --> The peak number of images per second
+ * config --> Stream configuration
 * 
 * Returns display_t based on hwdevice_type
 */
-std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, int framerate);
+std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config);

 // A list of names of displays accepted as display_name with the mem_type_e
 std::vector<std::string> display_names(mem_type_e hwdevice_type);
--- a/src/platform/linux/cuda.cpp
+++ b/src/platform/linux/cuda.cpp
@@ -13,6 +13,7 @@ extern "C" {
 #include "graphics.h"
 #include "src/main.h"
 #include "src/utility.h"
+#include "src/video.h"
 #include "wayland.h"

 #define SUNSHINE_STRINGVIEW_HELPER(x) x##sv
@@ -414,7 +415,7 @@ public:

 class display_t : public platf::display_t {
 public:
-  int init(const std::string_view &display_name, int framerate) {
+  int init(const std::string_view &display_name, const ::video::config_t &config) {
    auto handle = handle_t::make();
    if(!handle) {
      return -1;
@@ -444,14 +445,14 @@ public:
      }
    }

-    delay = std::chrono::nanoseconds { 1s } / framerate;
+    delay = std::chrono::nanoseconds { 1s } / config.framerate;

    capture_params = NVFBC_CREATE_CAPTURE_SESSION_PARAMS { NVFBC_CREATE_CAPTURE_SESSION_PARAMS_VER };

    capture_params.eCaptureType                = NVFBC_CAPTURE_SHARED_CUDA;
    capture_params.bDisableAutoModesetRecovery = nv_bool(true);

-    capture_params.dwSamplingRateMs = 1000 /* ms */ / framerate;
+    capture_params.dwSamplingRateMs = 1000 /* ms */ / config.framerate;

    if(streamedMonitor != -1) {
      auto &output = status_params->outputs[streamedMonitor];
@@ -663,7 +664,7 @@ public:
 } // namespace cuda

 namespace platf {
-std::shared_ptr<display_t> nvfbc_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> nvfbc_display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config) {
  if(hwdevice_type != mem_type_e::cuda) {
    BOOST_LOG(error) << "Could not initialize nvfbc display with the given hw device type"sv;
    return nullptr;
@@ -671,7 +672,7 @@ std::shared_ptr<display_t> nvfbc_display(mem_type_e hwdevice_type, const std::st

  auto display = std::make_shared<cuda::nvfbc::display_t>();

-  if(display->init(display_name, framerate)) {
+  if(display->init(display_name, config)) {
    return nullptr;
  }

--- a/src/platform/linux/kmsgrab.cpp
+++ b/src/platform/linux/kmsgrab.cpp
@@ -12,6 +12,7 @@
 #include "src/platform/common.h"
 #include "src/round_robin.h"
 #include "src/utility.h"
+#include "src/video.h"

 // Cursor rendering support through x11
 #include "graphics.h"
@@ -444,8 +445,8 @@ class display_t : public platf::display_t {
 public:
  display_t(mem_type_e mem_type) : platf::display_t(), mem_type { mem_type } {}

-  int init(const std::string &display_name, int framerate) {
-    delay = std::chrono::nanoseconds { 1s } / framerate;
+  int init(const std::string &display_name, const ::video::config_t &config) {
+    delay = std::chrono::nanoseconds { 1s } / config.framerate;

    int monitor_index = util::from_view(display_name);
    int monitor       = 0;
@@ -632,13 +633,13 @@ class display_ram_t : public display_t {
 public:
  display_ram_t(mem_type_e mem_type) : display_t(mem_type) {}

-  int init(const std::string &display_name, int framerate) {
+  int init(const std::string &display_name, const ::video::config_t &config) {
    if(!gbm::create_device) {
      BOOST_LOG(warning) << "libgbm not initialized"sv;
      return -1;
    }

-    if(display_t::init(display_name, framerate)) {
+    if(display_t::init(display_name, config)) {
      return -1;
    }

@@ -852,8 +853,8 @@ public:
    return capture_e::ok;
  }

-  int init(const std::string &display_name, int framerate) {
-    if(display_t::init(display_name, framerate)) {
+  int init(const std::string &display_name, const ::video::config_t &config) {
+    if(display_t::init(display_name, config)) {
      return -1;
    }

@@ -872,11 +873,11 @@ public:

 } // namespace kms

-std::shared_ptr<display_t> kms_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> kms_display(mem_type_e hwdevice_type, const std::string &display_name, const ::video::config_t &config) {
  if(hwdevice_type == mem_type_e::vaapi) {
    auto disp = std::make_shared<kms::display_vram_t>(hwdevice_type);

-    if(!disp->init(display_name, framerate)) {
+    if(!disp->init(display_name, config)) {
      return disp;
    }

@@ -885,7 +886,7 @@ std::shared_ptr<display_t> kms_display(mem_type_e hwdevice_type, const std::stri

  auto disp = std::make_shared<kms::display_ram_t>(hwdevice_type);

-  if(disp->init(display_name, framerate)) {
+  if(disp->init(display_name, config)) {
    return nullptr;
  }

--- a/src/platform/linux/misc.cpp
+++ b/src/platform/linux/misc.cpp
@@ -418,7 +418,7 @@ static std::bitset<source::MAX_FLAGS> sources;

 #ifdef SUNSHINE_BUILD_CUDA
 std::vector<std::string> nvfbc_display_names();
-std::shared_ptr<display_t> nvfbc_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate);
+std::shared_ptr<display_t> nvfbc_display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config);

 bool verify_nvfbc() {
  return !nvfbc_display_names().empty();
@@ -427,7 +427,7 @@ bool verify_nvfbc() {

 #ifdef SUNSHINE_BUILD_WAYLAND
 std::vector<std::string> wl_display_names();
-std::shared_ptr<display_t> wl_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate);
+std::shared_ptr<display_t> wl_display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config);

 bool verify_wl() {
  return window_system == window_system_e::WAYLAND && !wl_display_names().empty();
@@ -436,7 +436,7 @@ bool verify_wl() {

 #ifdef SUNSHINE_BUILD_DRM
 std::vector<std::string> kms_display_names();
-std::shared_ptr<display_t> kms_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate);
+std::shared_ptr<display_t> kms_display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config);

 bool verify_kms() {
  return !kms_display_names().empty();
@@ -445,7 +445,7 @@ bool verify_kms() {

 #ifdef SUNSHINE_BUILD_X11
 std::vector<std::string> x11_display_names();
-std::shared_ptr<display_t> x11_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate);
+std::shared_ptr<display_t> x11_display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config);

 bool verify_x11() {
  return window_system == window_system_e::X11 && !x11_display_names().empty();
@@ -469,29 +469,29 @@ std::vector<std::string> display_names(mem_type_e hwdevice_type) {
  return {};
 }

-std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config) {
 #ifdef SUNSHINE_BUILD_CUDA
  if(sources[source::NVFBC] && hwdevice_type == mem_type_e::cuda) {
    BOOST_LOG(info) << "Screencasting with NvFBC"sv;
-    return nvfbc_display(hwdevice_type, display_name, framerate);
+    return nvfbc_display(hwdevice_type, display_name, config);
  }
 #endif
 #ifdef SUNSHINE_BUILD_WAYLAND
  if(sources[source::WAYLAND]) {
    BOOST_LOG(info) << "Screencasting with Wayland's protocol"sv;
-    return wl_display(hwdevice_type, display_name, framerate);
+    return wl_display(hwdevice_type, display_name, config);
  }
 #endif
 #ifdef SUNSHINE_BUILD_DRM
  if(sources[source::KMS]) {
    BOOST_LOG(info) << "Screencasting with KMS"sv;
-    return kms_display(hwdevice_type, display_name, framerate);
+    return kms_display(hwdevice_type, display_name, config);
  }
 #endif
 #ifdef SUNSHINE_BUILD_X11
  if(sources[source::X11]) {
    BOOST_LOG(info) << "Screencasting with X11"sv;
-    return x11_display(hwdevice_type, display_name, framerate);
+    return x11_display(hwdevice_type, display_name, config);
  }
 #endif

--- a/src/platform/linux/wlgrab.cpp
+++ b/src/platform/linux/wlgrab.cpp
@@ -1,6 +1,7 @@
 #include "src/platform/common.h"

 #include "src/main.h"
+#include "src/video.h"
 #include "vaapi.h"
 #include "wayland.h"

@@ -18,8 +19,8 @@ struct img_t : public platf::img_t {

 class wlr_t : public platf::display_t {
 public:
-  int init(platf::mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
-    delay    = std::chrono::nanoseconds { 1s } / framerate;
+  int init(platf::mem_type_e hwdevice_type, const std::string &display_name, const ::video::config_t &config) {
+    delay    = std::chrono::nanoseconds { 1s } / config.framerate;
    mem_type = hwdevice_type;

    if(display.init()) {
@@ -175,8 +176,8 @@ public:
    return platf::capture_e::ok;
  }

-  int init(platf::mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
-    if(wlr_t::init(hwdevice_type, display_name, framerate)) {
+  int init(platf::mem_type_e hwdevice_type, const std::string &display_name, const ::video::config_t &config) {
+    if(wlr_t::init(hwdevice_type, display_name, config)) {
      return -1;
    }

@@ -307,7 +308,7 @@ public:
 } // namespace wl

 namespace platf {
-std::shared_ptr<display_t> wl_display(mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> wl_display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config) {
  if(hwdevice_type != platf::mem_type_e::system && hwdevice_type != platf::mem_type_e::vaapi && hwdevice_type != platf::mem_type_e::cuda) {
    BOOST_LOG(error) << "Could not initialize display with the given hw device type."sv;
    return nullptr;
@@ -315,7 +316,7 @@ std::shared_ptr<display_t> wl_display(mem_type_e hwdevice_type, const std::strin

  if(hwdevice_type == platf::mem_type_e::vaapi) {
    auto wlr = std::make_shared<wl::wlr_vram_t>();
-    if(wlr->init(hwdevice_type, display_name, framerate)) {
+    if(wlr->init(hwdevice_type, display_name, config)) {
      return nullptr;
    }

@@ -323,7 +324,7 @@ std::shared_ptr<display_t> wl_display(mem_type_e hwdevice_type, const std::strin
  }

  auto wlr = std::make_shared<wl::wlr_ram_t>();
-  if(wlr->init(hwdevice_type, display_name, framerate)) {
+  if(wlr->init(hwdevice_type, display_name, config)) {
    return nullptr;
  }

--- a/src/platform/linux/x11grab.cpp
+++ b/src/platform/linux/x11grab.cpp
@@ -19,6 +19,7 @@
 #include "src/config.h"
 #include "src/main.h"
 #include "src/task_pool.h"
+#include "src/video.h"

 #include "cuda.h"
 #include "graphics.h"
@@ -382,13 +383,13 @@ struct x11_attr_t : public display_t {
    x11::InitThreads();
  }

-  int init(const std::string &display_name, int framerate) {
+  int init(const std::string &display_name, const ::video::config_t &config) {
    if(!xdisplay) {
      BOOST_LOG(error) << "Could not open X11 display"sv;
      return -1;
    }

-    delay = std::chrono::nanoseconds { 1s } / framerate;
+    delay = std::chrono::nanoseconds { 1s } / config.framerate;

    xwindow = DefaultRootWindow(xdisplay.get());

@@ -641,8 +642,8 @@ struct shm_attr_t : public x11_attr_t {
    return 0;
  }

-  int init(const std::string &display_name, int framerate) {
-    if(x11_attr_t::init(display_name, framerate)) {
+  int init(const std::string &display_name, const ::video::config_t &config) {
+    if(x11_attr_t::init(display_name, config)) {
      return 1;
    }

@@ -685,7 +686,7 @@ struct shm_attr_t : public x11_attr_t {
  }
 };

-std::shared_ptr<display_t> x11_display(platf::mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> x11_display(platf::mem_type_e hwdevice_type, const std::string &display_name, const ::video::config_t &config) {
  if(hwdevice_type != platf::mem_type_e::system && hwdevice_type != platf::mem_type_e::vaapi && hwdevice_type != platf::mem_type_e::cuda) {
    BOOST_LOG(error) << "Could not initialize x11 display with the given hw device type"sv;
    return nullptr;
@@ -700,7 +701,7 @@ std::shared_ptr<display_t> x11_display(platf::mem_type_e hwdevice_type, const st
  // Attempt to use shared memory X11 to avoid copying the frame
  auto shm_disp = std::make_shared<shm_attr_t>(hwdevice_type);

-  auto status = shm_disp->init(display_name, framerate);
+  auto status = shm_disp->init(display_name, config);
  if(status > 0) {
    // x11_attr_t::init() failed, don't bother trying again.
    return nullptr;
@@ -712,7 +713,7 @@ std::shared_ptr<display_t> x11_display(platf::mem_type_e hwdevice_type, const st

  // Fallback
  auto x11_disp = std::make_shared<x11_attr_t>(hwdevice_type);
-  if(x11_disp->init(display_name, framerate)) {
+  if(x11_disp->init(display_name, config)) {
    return nullptr;
  }

--- a/src/platform/macos/display.mm
+++ b/src/platform/macos/display.mm
@@ -6,6 +6,11 @@
 #include "src/config.h"
 #include "src/main.h"

+// Avoid conflict between AVFoundation and libavutil both defining AVMediaType
+#define AVMediaType AVMediaType_FFmpeg
+#include "src/video.h"
+#undef AVMediaType
+
 namespace fs = std::filesystem;

 namespace platf {
@@ -147,7 +152,7 @@ struct av_display_t : public display_t {
  }
 };

-std::shared_ptr<display_t> display(platf::mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> display(platf::mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config) {
  if(hwdevice_type != platf::mem_type_e::system) {
    BOOST_LOG(error) << "Could not initialize display with the given hw device type."sv;
    return nullptr;
@@ -168,7 +173,7 @@ std::shared_ptr<display_t> display(platf::mem_type_e hwdevice_type, const std::s
    }
  }

-  display->av_capture = [[AVVideo alloc] initWithDisplay:display->display_id frameRate:framerate];
+  display->av_capture = [[AVVideo alloc] initWithDisplay:display->display_id frameRate:config.framerate];

  if(!display->av_capture) {
    BOOST_LOG(error) << "Video setup failed."sv;
--- a/src/platform/windows/display.h
+++ b/src/platform/windows/display.h
@@ -10,7 +10,7 @@
 #include <d3dcommon.h>
 #include <dwmapi.h>
 #include <dxgi.h>
-#include <dxgi1_2.h>
+#include <dxgi1_6.h>

 #include "src/platform/common.h"
 #include "src/utility.h"
@@ -37,6 +37,7 @@ using adapter_t             = util::safe_ptr<IDXGIAdapter1, Release<IDXGIAdapter
 using output_t              = util::safe_ptr<IDXGIOutput, Release<IDXGIOutput>>;
 using output1_t             = util::safe_ptr<IDXGIOutput1, Release<IDXGIOutput1>>;
 using output5_t             = util::safe_ptr<IDXGIOutput5, Release<IDXGIOutput5>>;
+using output6_t             = util::safe_ptr<IDXGIOutput6, Release<IDXGIOutput6>>;
 using dup_t                 = util::safe_ptr<IDXGIOutputDuplication, Release<IDXGIOutputDuplication>>;
 using texture2d_t           = util::safe_ptr<ID3D11Texture2D, Release<ID3D11Texture2D>>;
 using texture1d_t           = util::safe_ptr<ID3D11Texture1D, Release<ID3D11Texture1D>>;
@@ -115,7 +116,7 @@ public:

 class display_base_t : public display_t {
 public:
-  int init(int framerate, const std::string &display_name);
+  int init(const ::video::config_t &config, const std::string &display_name);
  capture_e capture(snapshot_cb_t &&snapshot_cb, std::shared_ptr<img_t> img, bool *cursor) override;

  std::chrono::nanoseconds delay;
@@ -141,6 +142,9 @@ public:

  typedef NTSTATUS WINAPI (*PD3DKMTSetProcessSchedulingPriorityClass)(HANDLE, D3DKMT_SCHEDULINGPRIORITYCLASS);

+  virtual bool is_hdr() override;
+  virtual bool get_hdr_metadata(SS_HDR_METADATA &metadata) override;
+
 protected:
  int get_pixel_pitch() {
    return (capture_format == DXGI_FORMAT_R16G16B16A16_FLOAT) ? 8 : 4;
@@ -151,6 +155,7 @@ protected:
  virtual capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor_visible) = 0;
  virtual int complete_img(img_t *img, bool dummy)                                               = 0;
  virtual std::vector<DXGI_FORMAT> get_supported_sdr_capture_formats()                           = 0;
+  virtual std::vector<DXGI_FORMAT> get_supported_hdr_capture_formats()                           = 0;
 };

 class display_ram_t : public display_base_t {
@@ -161,8 +166,9 @@ public:
  int dummy_img(img_t *img) override;
  int complete_img(img_t *img, bool dummy) override;
  std::vector<DXGI_FORMAT> get_supported_sdr_capture_formats() override;
+  std::vector<DXGI_FORMAT> get_supported_hdr_capture_formats() override;

-  int init(int framerate, const std::string &display_name);
+  int init(const ::video::config_t &config, const std::string &display_name);

  cursor_t cursor;
  D3D11_MAPPED_SUBRESOURCE img_info;
@@ -177,8 +183,9 @@ public:
  int dummy_img(img_t *img_base) override;
  int complete_img(img_t *img_base, bool dummy) override;
  std::vector<DXGI_FORMAT> get_supported_sdr_capture_formats() override;
+  std::vector<DXGI_FORMAT> get_supported_hdr_capture_formats() override;

-  int init(int framerate, const std::string &display_name);
+  int init(const ::video::config_t &config, const std::string &display_name);

  std::shared_ptr<platf::hwdevice_t> make_hwdevice(pix_fmt_e pix_fmt) override;

--- a/src/platform/windows/display_base.cpp
+++ b/src/platform/windows/display_base.cpp
@@ -17,6 +17,7 @@ typedef long NTSTATUS;
 #include "src/config.h"
 #include "src/main.h"
 #include "src/platform/common.h"
+#include "src/video.h"

 namespace platf {
 using namespace std::literals;
@@ -106,10 +107,16 @@ capture_e display_base_t::capture(snapshot_cb_t &&snapshot_cb, std::shared_ptr<:
  });

  while(img) {
-    auto wait_time_us = std::chrono::duration_cast<std::chrono::microseconds>(next_frame - std::chrono::steady_clock::now()).count();
+    // This will return false if the HDR state changes or for any number of other
+    // display or GPU changes. We should reinit to examine the updated state of
+    // the display subsystem. It is recommended to call this once per frame.
+    if(!factory->IsCurrent()) {
+      return platf::capture_e::reinit;
+    }

    // If the wait time is between 1 us and 1 second, wait the specified time
    // and offset the next frame time from the exact current frame time target.
+    auto wait_time_us = std::chrono::duration_cast<std::chrono::microseconds>(next_frame - std::chrono::steady_clock::now()).count();
    if(wait_time_us > 0 && wait_time_us < 1000000) {
      LARGE_INTEGER due_time { .QuadPart = -10LL * wait_time_us };
      SetWaitableTimer(timer, &due_time, 0, nullptr, nullptr, false);
@@ -276,7 +283,7 @@ bool test_dxgi_duplication(adapter_t &adapter, output_t &output) {
  return false;
 }

-int display_base_t::init(int framerate, const std::string &display_name) {
+int display_base_t::init(const ::video::config_t &config, const std::string &display_name) {
  std::once_flag windows_cpp_once_flag;

  std::call_once(windows_cpp_once_flag, []() {
@@ -296,7 +303,7 @@ int display_base_t::init(int framerate, const std::string &display_name) {
  // Ensure we can duplicate the current display
  syncThreadDesktop();

-  delay = std::chrono::nanoseconds { 1s } / framerate;
+  delay = std::chrono::nanoseconds { 1s } / config.framerate;

  // Get rectangle of full desktop for absolute mouse coordinates
  env_width  = GetSystemMetrics(SM_CXVIRTUALSCREEN);
@@ -421,7 +428,7 @@ int display_base_t::init(int framerate, const std::string &display_name) {
    << "Virtual Desktop    : "sv << env_width << 'x' << env_height;

  // Enable DwmFlush() only if the current refresh rate can match the client framerate.
-  auto refresh_rate = framerate;
+  auto refresh_rate = config.framerate;
  DWM_TIMING_INFO timing_info;
  timing_info.cbSize = sizeof(timing_info);

@@ -433,7 +440,7 @@ int display_base_t::init(int framerate, const std::string &display_name) {
    refresh_rate = std::round((double)timing_info.rateRefresh.uiNumerator / (double)timing_info.rateRefresh.uiDenominator);
  }

-  dup.use_dwmflush = config::video.dwmflush && !(framerate > refresh_rate) ? true : false;
+  dup.use_dwmflush = config::video.dwmflush && !(config.framerate > refresh_rate) ? true : false;

  // Bump up thread priority
  {
@@ -502,7 +509,7 @@ int display_base_t::init(int framerate, const std::string &display_name) {
    status = output->QueryInterface(IID_IDXGIOutput5, (void **)&output5);
    if(SUCCEEDED(status)) {
      // Ask the display implementation which formats it supports
-      auto supported_formats = get_supported_sdr_capture_formats();
+      auto supported_formats = config.dynamicRange ? get_supported_hdr_capture_formats() : get_supported_sdr_capture_formats();
      if(supported_formats.empty()) {
        BOOST_LOG(warning) << "No compatible capture formats for this encoder"sv;
        return -1;
@@ -562,6 +569,57 @@ int display_base_t::init(int framerate, const std::string &display_name) {
  return 0;
 }

+bool display_base_t::is_hdr() {
+  dxgi::output6_t output6 {};
+
+  auto status = output->QueryInterface(IID_IDXGIOutput6, (void **)&output6);
+  if(FAILED(status)) {
+    BOOST_LOG(warning) << "Failed to query IDXGIOutput6 from the output"sv;
+    return false;
+  }
+
+  DXGI_OUTPUT_DESC1 desc1;
+  output6->GetDesc1(&desc1);
+
+  return desc1.ColorSpace == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
+}
+
+bool display_base_t::get_hdr_metadata(SS_HDR_METADATA &metadata) {
+  dxgi::output6_t output6 {};
+
+  std::memset(&metadata, 0, sizeof(metadata));
+
+  auto status = output->QueryInterface(IID_IDXGIOutput6, (void **)&output6);
+  if(FAILED(status)) {
+    BOOST_LOG(warning) << "Failed to query IDXGIOutput6 from the output"sv;
+    return false;
+  }
+
+  DXGI_OUTPUT_DESC1 desc1;
+  output6->GetDesc1(&desc1);
+
+  metadata.displayPrimaries[0].x = desc1.RedPrimary[0] * 50000;
+  metadata.displayPrimaries[0].y = desc1.RedPrimary[1] * 50000;
+  metadata.displayPrimaries[1].x = desc1.GreenPrimary[0] * 50000;
+  metadata.displayPrimaries[1].y = desc1.GreenPrimary[1] * 50000;
+  metadata.displayPrimaries[2].x = desc1.BluePrimary[0] * 50000;
+  metadata.displayPrimaries[2].y = desc1.BluePrimary[1] * 50000;
+
+  metadata.whitePoint.x = desc1.WhitePoint[0] * 50000;
+  metadata.whitePoint.y = desc1.WhitePoint[1] * 50000;
+
+  metadata.maxDisplayLuminance = desc1.MaxLuminance;
+  metadata.minDisplayLuminance = desc1.MinLuminance * 10000;
+
+  // These are content-specific metadata parameters that this interface doesn't give us
+  metadata.maxContentLightLevel      = 0;
+  metadata.maxFrameAverageLightLevel = 0;
+
+  metadata.maxFullFrameLuminance = desc1.MaxFullFrameLuminance;
+
+  return true;
+}
+
 const char *format_str[] = {
  "DXGI_FORMAT_UNKNOWN",
  "DXGI_FORMAT_R32G32B32A32_TYPELESS",
@@ -694,18 +752,18 @@ const char *display_base_t::dxgi_format_to_string(DXGI_FORMAT format) {
 } // namespace platf::dxgi

 namespace platf {
-std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, int framerate) {
+std::shared_ptr<display_t> display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config) {
  if(hwdevice_type == mem_type_e::dxgi) {
    auto disp = std::make_shared<dxgi::display_vram_t>();

-    if(!disp->init(framerate, display_name)) {
+    if(!disp->init(config, display_name)) {
      return disp;
    }
  }
  else if(hwdevice_type == mem_type_e::system) {
    auto disp = std::make_shared<dxgi::display_ram_t>();

-    if(!disp->init(framerate, display_name)) {
+    if(!disp->init(config, display_name)) {
      return disp;
    }
  }
--- a/src/platform/windows/display_ram.cpp
+++ b/src/platform/windows/display_ram.cpp
@@ -349,11 +349,16 @@ int display_ram_t::dummy_img(platf::img_t *img) {
 }

 std::vector<DXGI_FORMAT> display_ram_t::get_supported_sdr_capture_formats() {
-  return std::vector { DXGI_FORMAT_B8G8R8A8_UNORM };
+  return { DXGI_FORMAT_B8G8R8A8_UNORM };
 }

-int display_ram_t::init(int framerate, const std::string &display_name) {
-  if(display_base_t::init(framerate, display_name)) {
+std::vector<DXGI_FORMAT> display_ram_t::get_supported_hdr_capture_formats() {
+  // HDR is unsupported
+  return {};
+}
+
+int display_ram_t::init(const ::video::config_t &config, const std::string &display_name) {
+  if(display_base_t::init(config, display_name)) {
    return -1;
  }

--- a/src/platform/windows/display_vram.cpp
+++ b/src/platform/windows/display_vram.cpp
@@ -952,8 +952,8 @@ capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::millisec
  return capture_e::ok;
 }

-int display_vram_t::init(int framerate, const std::string &display_name) {
-  if(display_base_t::init(framerate, display_name)) {
+int display_vram_t::init(const ::video::config_t &config, const std::string &display_name) {
+  if(display_base_t::init(config, display_name)) {
    return -1;
  }

@@ -1104,7 +1104,11 @@ int display_vram_t::dummy_img(platf::img_t *img_base) {
 }

 std::vector<DXGI_FORMAT> display_vram_t::get_supported_sdr_capture_formats() {
-  return std::vector { DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM };
+  return { DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM };
+}
+
+std::vector<DXGI_FORMAT> display_vram_t::get_supported_hdr_capture_formats() {
+  return { DXGI_FORMAT_R10G10B10A2_UNORM };
 }

 std::shared_ptr<platf::hwdevice_t> display_vram_t::make_hwdevice(pix_fmt_e pix_fmt) {