Capturing images by callback, rather than pulling

sunshine/platform/windows/display.h

@@ -74,7 +74,9 @@ public:
 
 class display_base_t : public display_t {
 public:
-  int init();
+  int init(int framerate);
+
+  std::chrono::nanoseconds delay;
 
   factory1_t factory;
   adapter_t adapter;
@@ -100,11 +102,14 @@ public:
 
 class display_ram_t : public display_base_t {
 public:
-  capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor_visible) override;
+  capture_e capture(snapshot_cb_t &&snapshot_cb, std::shared_ptr<img_t> img, bool *cursor) override;
+  capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor_visible);
+
+
   std::shared_ptr<img_t> alloc_img() override;
   int dummy_img(img_t *img) override;
 
-  int init();
+  int init(int framerate);
 
   cursor_t cursor;
   D3D11_MAPPED_SUBRESOURCE img_info;
@@ -113,7 +118,8 @@ public:
 
 class display_vram_t : public display_base_t, public std::enable_shared_from_this<display_vram_t> {
 public:
-  capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor_visible) override;
+  capture_e capture(snapshot_cb_t &&snapshot_cb, std::shared_ptr<img_t> img, bool *cursor) override;
+  capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor_visible);
 
   std::shared_ptr<img_t> alloc_img() override;
   int dummy_img(img_t *img_base) override;

sunshine/platform/windows/display_base.cpp

@@ -73,7 +73,7 @@ duplication_t::~duplication_t() {
   release_frame();
 }
 
-int display_base_t::init() {
+int display_base_t::init(int framerate) {
   /* Uncomment when use of IDXGIOutput5 is implemented
   std::call_once(windows_cpp_once_flag, []() {
     DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
@@ -94,6 +94,8 @@ int display_base_t::init() {
   // Ensure we can duplicate the current display
   syncThreadDesktop();
 
+  delay = std::chrono::nanoseconds { 1s } / framerate;
+
   // Get rectangle of full desktop for absolute mouse coordinates
   env_width  = GetSystemMetrics(SM_CXVIRTUALSCREEN);
   env_height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
@@ -431,18 +433,18 @@ const char *format_str[] = {
 } // namespace platf::dxgi
 
 namespace platf {
-std::shared_ptr<display_t> display(mem_type_e hwdevice_type) {
+std::shared_ptr<display_t> display(mem_type_e hwdevice_type, int framerate) {
   if(hwdevice_type == mem_type_e::dxgi) {
     auto disp = std::make_shared<dxgi::display_vram_t>();
 
-    if(!disp->init()) {
+    if(!disp->init(framerate)) {
       return disp;
     }
   }
   else if(hwdevice_type == mem_type_e::system) {
     auto disp = std::make_shared<dxgi::display_ram_t>();
 
-    if(!disp->init()) {
+    if(!disp->init(framerate)) {
       return disp;
     }
   }

sunshine/platform/windows/display_ram.cpp

@@ -165,6 +165,36 @@ void blend_cursor(const cursor_t &cursor, img_t &img) {
   }
 }
 
+capture_e display_ram_t::capture(snapshot_cb_t &&snapshot_cb, std::shared_ptr<::platf::img_t> img, bool *cursor) {
+  auto next_frame = std::chrono::steady_clock::now();
+
+  while(img) {
+    auto now = std::chrono::steady_clock::now();
+    while(next_frame > now) {
+      now = std::chrono::steady_clock::now();
+    }
+    next_frame = now + delay;
+
+    auto status = snapshot(img.get(), 1000ms, *cursor);
+    switch(status) {
+    case platf::capture_e::reinit:
+    case platf::capture_e::error:
+      return status;
+    case platf::capture_e::timeout:
+      std::this_thread::sleep_for(1ms);
+      continue;
+    case platf::capture_e::ok:
+      img = snapshot_cb(img);
+      break;
+    default:
+      BOOST_LOG(error) << "Unrecognized capture status ["sv << (int)status << ']';
+      return status;
+    }
+  }
+
+  return capture_e::ok;
+}
+
 capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::milliseconds timeout, bool cursor_visible) {
   auto img = (img_t *)img_base;
 
@@ -263,8 +293,8 @@ int display_ram_t::dummy_img(platf::img_t *img) {
   return 0;
 }
 
-int display_ram_t::init() {
-  if(display_base_t::init()) {
+int display_ram_t::init(int framerate) {
+  if(display_base_t::init(framerate)) {
     return -1;
   }
 

sunshine/platform/windows/display_vram.cpp

@@ -693,6 +693,36 @@ public:
   std::vector<hwdevice_t *> *hwdevices_p;
 };
 
+capture_e display_vram_t::capture(snapshot_cb_t &&snapshot_cb, std::shared_ptr<::platf::img_t> img, bool *cursor) {
+  auto next_frame = std::chrono::steady_clock::now();
+
+  while(img) {
+    auto now = std::chrono::steady_clock::now();
+    while(next_frame > now) {
+      now = std::chrono::steady_clock::now();
+    }
+    next_frame = now + delay;
+
+    auto status = snapshot(img.get(), 1000ms, *cursor);
+    switch(status) {
+    case platf::capture_e::reinit:
+    case platf::capture_e::error:
+      return status;
+    case platf::capture_e::timeout:
+      std::this_thread::sleep_for(1ms);
+      continue;
+    case platf::capture_e::ok:
+      img = snapshot_cb(img);
+      break;
+    default:
+      BOOST_LOG(error) << "Unrecognized capture status ["sv << (int)status << ']';
+      return status;
+    }
+  }
+
+  return capture_e::ok;
+}
+
 capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::milliseconds timeout, bool cursor_visible) {
   auto img = (img_d3d_t *)img_base;