feat(capture): add AMD Display Capture for AFMF

.gitignore

@@ -36,6 +36,7 @@
 
 # VSCode IDE
 .vscode/
+.vs/
 
 # build directories
 build/

cmake/compile_definitions/windows.cmake

@@ -51,6 +51,7 @@ set(PLATFORM_TARGET_FILES
         "${CMAKE_SOURCE_DIR}/src/platform/windows/display_vram.cpp"
         "${CMAKE_SOURCE_DIR}/src/platform/windows/display_ram.cpp"
         "${CMAKE_SOURCE_DIR}/src/platform/windows/display_wgc.cpp"
+        "${CMAKE_SOURCE_DIR}/src/platform/windows/display_amd.cpp"
         "${CMAKE_SOURCE_DIR}/src/platform/windows/audio.cpp"
         "${CMAKE_SOURCE_DIR}/third-party/ViGEmClient/src/ViGEmClient.cpp"
         "${CMAKE_SOURCE_DIR}/third-party/ViGEmClient/include/ViGEm/Client.h"

src/platform/windows/display.h

@@ -4,6 +4,8 @@
  */
 #pragma once
 
+#include <AMF/core/CurrentTime.h>
+#include <AMF/core/Factory.h>
 #include <d3d11.h>
 #include <d3d11_4.h>
 #include <d3dcommon.h>
@@ -31,6 +33,17 @@
     dxgi->Release();
   }
 
+  /**
+   * Windows DLL loader function helper for AMD Display Capture
+   * @param item library dll
+   */
+  inline
+  void
+  FreeLibraryHelper(void *item) {
+    FreeLibrary((HMODULE) item);
+  }
+
+  using hmodule_t = util::safe_ptr<void, FreeLibraryHelper>;
   using factory1_t = util::safe_ptr<IDXGIFactory1, Release<IDXGIFactory1>>;
   using dxgi_t = util::safe_ptr<IDXGIDevice, Release<IDXGIDevice>>;
   using dxgi1_t = util::safe_ptr<IDXGIDevice1, Release<IDXGIDevice1>>;
@@ -177,6 +190,8 @@
     int height_before_rotation;
 
     int client_frame_rate;
+    int adapter_index;
+    int output_index;
 
     DXGI_FORMAT capture_format;
     D3D_FEATURE_LEVEL feature_level;
@@ -429,4 +444,46 @@
     capture_e
     release_snapshot() override;
   };
+
+  class amd_capture_t {
+
+  public:
+    amd_capture_t();
+    ~amd_capture_t();
+
+    int
+    init(display_base_t *display, const ::video::config_t &config, int output_index);
+    capture_e
+    next_frame(std::chrono::milliseconds timeout, amf::AMFData** out);
+    capture_e
+    release_frame();
+
+    hmodule_t amfrt_lib;
+    amf_uint64 amf_version;
+    amf::AMFFactory *amf_factory;
+
+    amf::AMFContextPtr context;
+    amf::AMFComponentPtr captureComp;
+    amf::AMFSurfacePtr capturedSurface;
+    amf_int64 capture_format;
+    AMFSize resolution;
+  };
+
+
+  /**
+   * Display backend that uses AMD Display Capture with a hardware encoder.
+   * Main purpose is to capture AMD Fluid Motion Frames (AFMF)
+   */
+  class display_amd_vram_t: public display_vram_t {
+    amd_capture_t dup;
+
+  public:
+    int
+    init(const ::video::config_t &config, const std::string &display_name);
+    capture_e
+    snapshot(const pull_free_image_cb_t &pull_free_image_cb, std::shared_ptr<platf::img_t> &img_out, std::chrono::milliseconds timeout, bool cursor_visible) override;
+    capture_e
+    release_snapshot() override;
+  };
+
 }  // namespace platf::dxgi

src/platform/windows/display_amd.cpp

@@ -0,0 +1,183 @@
+/**
+ * @file src/platform/windows/display_amd.cpp
+ * @brief Display capture implementation using AMD Direct Capture
+ */
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavutil/hwcontext_d3d11va.h>
+}
+
+#include "display.h"
+#include "misc.h"
+#include "src/config.h"
+#include "src/main.h"
+#include "src/video.h"
+
+#include <AMF/components/DisplayCapture.h>
+#include <AMF/components/VideoConverter.h>
+#include <AMF/core/Trace.h>
+
+namespace platf {
+  using namespace std::literals;
+}
+
+namespace platf::dxgi {
+  amd_capture_t::amd_capture_t() {
+  }
+
+  amd_capture_t::~amd_capture_t() {
+    AMF_RESULT result;
+
+    // Before terminating the Display Capture component, we need to drain the remaining frames
+    result = captureComp->Drain();
+    if (result == AMF_OK) {
+      do {
+        result = captureComp->QueryOutput((amf::AMFData**) &capturedSurface);
+        Sleep(1);
+      } while (result != AMF_EOF);
+    }
+    captureComp->Terminate();
+
+    context->Terminate();
+    captureComp = nullptr;
+    context = nullptr;
+    capturedSurface = nullptr;
+  }
+
+  capture_e
+  amd_capture_t::release_frame() {
+    if (capturedSurface != nullptr)
+    {
+        capturedSurface = nullptr;
+    }
+
+    return capture_e::ok;
+  }
+
+  /**
+   * @brief Get the next frame from the producer thread.
+   * If not available, the capture thread blocks until one is, or the wait times out.
+   * @param timeout how long to wait for the next frame
+   * @param out pointer to AMFSurfacePtr
+   */
+  capture_e
+  amd_capture_t::next_frame(std::chrono::milliseconds timeout, amf::AMFData** out) {
+    release_frame();
+
+    AMF_RESULT result;
+    auto capture_start = std::chrono::steady_clock::now();
+    do {
+      result = captureComp->QueryOutput(out);
+      if (result == AMF_REPEAT) {
+        if (std::chrono::steady_clock::now() - capture_start >= timeout) {
+          return platf::capture_e::timeout;
+        }
+        Sleep(1);
+      }
+    } while (result == AMF_REPEAT);
+
+    if (result != AMF_OK) {
+      return capture_e::timeout;
+    }
+    return capture_e::ok;
+  }
+
+
+  int
+  amd_capture_t::init(display_base_t *display, const ::video::config_t &config, int output_index) {
+    // We have to load AMF before calling the base init() because we will need it loaded
+    // when our test_capture() function is called.
+    amfrt_lib.reset(LoadLibraryW(AMF_DLL_NAME));
+    if (!amfrt_lib) {
+      // Probably not an AMD GPU system
+      return -1;
+    }
+
+    auto fn_AMFQueryVersion = (AMFQueryVersion_Fn) GetProcAddress((HMODULE) amfrt_lib.get(), AMF_QUERY_VERSION_FUNCTION_NAME);
+    auto fn_AMFInit = (AMFInit_Fn) GetProcAddress((HMODULE) amfrt_lib.get(), AMF_INIT_FUNCTION_NAME);
+
+    if (!fn_AMFQueryVersion || !fn_AMFInit) {
+      BOOST_LOG(error) << "Missing required AMF function!"sv;
+      return -1;
+    }
+
+    auto result = fn_AMFQueryVersion(&amf_version);
+    if (result != AMF_OK) {
+      BOOST_LOG(error) << "AMFQueryVersion() failed: "sv << result;
+      return -1;
+    }
+
+    // We don't support anything older than AMF 1.4.30. We'll gracefully fall back to DDAPI.
+    if (amf_version < AMF_MAKE_FULL_VERSION(1, 4, 30, 0)) {
+      BOOST_LOG(warning) << "AMD Direct Capture is not supported on AMF version"sv
+                        << AMF_GET_MAJOR_VERSION(amf_version) << '.'
+                        << AMF_GET_MINOR_VERSION(amf_version) << '.'
+                        << AMF_GET_SUBMINOR_VERSION(amf_version) << '.'
+                        << AMF_GET_BUILD_VERSION(amf_version);
+      BOOST_LOG(warning) << "Consider updating your AMD graphics driver for better capture performance!"sv;
+      return -1;
+    }
+
+    // Initialize AMF library
+    result = fn_AMFInit(AMF_FULL_VERSION, &amf_factory);
+    if (result != AMF_OK) {
+      BOOST_LOG(error) << "AMFInit() failed: "sv << result;
+      return -1;
+    }
+
+    DXGI_ADAPTER_DESC adapter_desc;
+    display->adapter->GetDesc(&adapter_desc);
+
+    // Bail if this is not an AMD GPU
+    if (adapter_desc.VendorId != 0x1002) {
+      return -1;
+    }
+
+    // Create the capture context
+    result = amf_factory->CreateContext(&context);
+
+    if (result != AMF_OK) {
+      BOOST_LOG(error) << "CreateContext() failed: "sv << result;
+      return -1;
+    }
+
+    // Associate the context with our ID3D11Device. This will enable multithread protection on the device.
+    result = context->InitDX11(display->device.get());
+    if (result != AMF_OK) {
+      BOOST_LOG(error) << "InitDX11() failed: "sv << result;
+      return -1;
+    }
+
+    display->capture_format = DXGI_FORMAT_UNKNOWN;
+
+    // Create the DisplayCapture component
+    result = amf_factory->CreateComponent(context, AMFDisplayCapture, &(captureComp));
+    if (result != AMF_OK) {
+      BOOST_LOG(error) << "CreateComponent(AMFDisplayCapture) failed: "sv << result;
+      return -1;
+    }
+
+    // Set parameters for non-blocking capture
+    captureComp->SetProperty(AMF_DISPLAYCAPTURE_MONITOR_INDEX, output_index);
+    captureComp->SetProperty(AMF_DISPLAYCAPTURE_FRAMERATE, AMFConstructRate(config.framerate, 1));
+    captureComp->SetProperty(AMF_DISPLAYCAPTURE_MODE, AMF_DISPLAYCAPTURE_MODE_WAIT_FOR_PRESENT);
+    captureComp->SetProperty(AMF_DISPLAYCAPTURE_DUPLICATEOUTPUT, true);
+
+    // Initialize capture
+    result = captureComp->Init(amf::AMF_SURFACE_UNKNOWN, 0, 0);
+    if (result != AMF_OK) {
+      BOOST_LOG(error) << "DisplayCapture::Init() failed: "sv << result;
+      return -1;
+    }
+
+    captureComp->GetProperty(AMF_DISPLAYCAPTURE_FORMAT, &(capture_format));
+    captureComp->GetProperty(AMF_DISPLAYCAPTURE_RESOLUTION, &(resolution));
+    BOOST_LOG(info) << "Desktop resolution ["sv << resolution.width << 'x' << resolution.height << ']';
+
+    BOOST_LOG(info) << "Using AMD Direct Capture API for display capture"sv;
+
+    return 0;
+  }
+
+}  // namespace platf::dxgi

src/platform/windows/display_base.cpp

@@ -565,6 +565,7 @@
           }
 
           if (desc.AttachedToDesktop && test_dxgi_duplication(adapter_tmp, output_tmp, false)) {
+            output_index = y;
             output = std::move(output_tmp);
 
             offset_x = desc.DesktopCoordinates.left;
@@ -593,6 +594,7 @@
         }
 
         if (output) {
+          adapter_index = x;
           adapter = std::move(adapter_tmp);
           break;
         }
@@ -1052,6 +1054,16 @@
    */
   std::shared_ptr<display_t>
   display(mem_type_e hwdevice_type, const std::string &display_name, const video::config_t &config) {
+    if (config::video.capture == "amd" || config::video.capture.empty()) {
+      if (hwdevice_type == mem_type_e::dxgi) {
+        auto disp = std::make_shared<dxgi::display_amd_vram_t>();
+
+        if (!disp->init(config, display_name)) {
+          return disp;
+        }
+      }
+    }
+
     if (config::video.capture == "ddx" || config::video.capture.empty()) {
       if (hwdevice_type == mem_type_e::dxgi) {
         auto disp = std::make_shared<dxgi::display_ddup_vram_t>();