Add experimental "unpaced" and "serial" processing options (Windows only)

src/config.cpp

@@ -371,7 +371,9 @@ namespace config {
     {},  // encoder
     {},  // adapter_name
     {},  // output_name
-    true  // dwmflush
+    true,  // dwmflush
+    false,  // unpaced
+    false,  // serial
   };
 
   audio_t audio {};
@@ -957,6 +959,8 @@ namespace config {
     string_f(vars, "adapter_name", video.adapter_name);
     string_f(vars, "output_name", video.output_name);
     bool_f(vars, "dwmflush", video.dwmflush);
+    bool_f(vars, "unpaced", video.unpaced);
+    bool_f(vars, "serial", video.serial);
 
     path_f(vars, "pkey", nvhttp.pkey);
     path_f(vars, "cert", nvhttp.cert);

src/config.h

@@ -57,6 +57,8 @@ namespace config {
     std::string adapter_name;
     std::string output_name;
     bool dwmflush;
+    bool unpaced;
+    bool serial;
   };
 
   struct audio_t {

src/platform/windows/display.h

@@ -163,6 +163,8 @@ namespace platf::dxgi {
       return (capture_format == DXGI_FORMAT_R16G16B16A16_FLOAT) ? 8 : 4;
     }
 
+    bool mouse_pointer_visible = false;
+
     const char *
     dxgi_format_to_string(DXGI_FORMAT format);
     const char *

src/platform/windows/display_base.cpp

@@ -32,7 +32,7 @@ namespace platf::dxgi {
       return capture_status;
     }
 
-    if (use_dwmflush) {
+    if (!config::video.unpaced && use_dwmflush) {
       DwmFlush();
     }
 
@@ -110,6 +110,13 @@ namespace platf::dxgi {
       CloseHandle(timer);
     });
 
+    if (config::video.unpaced) {
+      BOOST_LOG(info) << "Using experimental unpaced path";
+    }
+    if (config::video.serial) {
+      BOOST_LOG(info) << "Using experimental serial path";
+    }
+
     while (true) {
       // 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
@@ -118,25 +125,36 @@ namespace platf::dxgi {
         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);
-        WaitForSingleObject(timer, INFINITE);
-        next_frame += delay;
-      }
-      else {
-        // If the wait time is negative (meaning the frame is past due) or the
-        // computed wait time is beyond a second (meaning possible clock issues),
-        // just capture the frame now and resynchronize the frame interval with
-        // the current time.
-        next_frame = std::chrono::steady_clock::now() + delay;
+      if (!config::video.unpaced) {
+        // 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);
+          WaitForSingleObject(timer, INFINITE);
+          next_frame += delay;
+        }
+        else {
+          // If the wait time is negative (meaning the frame is past due) or the
+          // computed wait time is beyond a second (meaning possible clock issues),
+          // just capture the frame now and resynchronize the frame interval with
+          // the current time.
+          next_frame = std::chrono::steady_clock::now() + delay;
+        }
       }
 
       std::shared_ptr<img_t> img_out;
-      auto status = snapshot(pull_free_image_cb, img_out, 1000ms, *cursor);
+
+      std::chrono::milliseconds timeout = 1000ms;
+      if (config::video.serial) {
+        timeout = 100ms;
+        if (config::video.unpaced && mouse_pointer_visible) {
+          timeout = 0ms;
+        }
+      }
+
+      auto status = snapshot(pull_free_image_cb, img_out, timeout, *cursor);
       switch (status) {
         case platf::capture_e::reinit:
         case platf::capture_e::error:
@@ -156,6 +174,14 @@ namespace platf::dxgi {
           BOOST_LOG(error) << "Unrecognized capture status ["sv << (int) status << ']';
           return status;
       }
+
+      if (config::video.unpaced) {
+        dup.release_frame();
+        if (mouse_pointer_visible && output) {
+          // Limit and pace mouse pointer updates.
+          output->WaitForVBlank();
+        }
+      }
     }
 
     return capture_e::ok;