[feat] update MiniRTC

scripts/macosx/pkg_arm64.sh

@@ -138,6 +138,39 @@ productbuild \
 
 echo "PKG package created: ${PKG_NAME}"
 
+# Set custom icon for PKG file
+if [ -f "${ICON_PATH}" ]; then
+    echo "Setting custom icon for PKG file..."
+    # Create a temporary iconset from icns
+    TEMP_ICON_DIR=$(mktemp -d)
+    cp "${ICON_PATH}" "${TEMP_ICON_DIR}/icon.icns"
+    
+    # Use sips to create a png from icns for the icon
+    sips -s format png "${TEMP_ICON_DIR}/icon.icns" --out "${TEMP_ICON_DIR}/icon.png" 2>/dev/null || true
+    
+    # Method: Use osascript to set file icon (works on macOS)
+    osascript <<APPLESCRIPT
+use framework "Foundation"
+use framework "AppKit"
+
+set iconPath to POSIX file "${TEMP_ICON_DIR}/icon.icns"
+set targetPath to POSIX file "$(pwd)/${PKG_NAME}"
+
+set iconImage to current application's NSImage's alloc()'s initWithContentsOfFile:(POSIX path of iconPath)
+set workspace to current application's NSWorkspace's sharedWorkspace()
+workspace's setIcon:iconImage forFile:(POSIX path of targetPath) options:0
+APPLESCRIPT
+
+    if [ $? -eq 0 ]; then
+        echo "Custom icon set successfully for ${PKG_NAME}"
+    else
+        echo "Warning: Failed to set custom icon (this is optional)"
+    fi
+    
+    rm -rf "${TEMP_ICON_DIR}"
+fi
+echo "Set icon finished"
+
 rm -rf build_pkg_temp build_pkg_scripts ${APP_BUNDLE}
 
 echo "PKG package created successfully."

scripts/macosx/pkg_x64.sh

@@ -138,6 +138,39 @@ productbuild \
 
 echo "PKG package created: ${PKG_NAME}"
 
+# Set custom icon for PKG file
+if [ -f "${ICON_PATH}" ]; then
+    echo "Setting custom icon for PKG file..."
+    # Create a temporary iconset from icns
+    TEMP_ICON_DIR=$(mktemp -d)
+    cp "${ICON_PATH}" "${TEMP_ICON_DIR}/icon.icns"
+    
+    # Use sips to create a png from icns for the icon
+    sips -s format png "${TEMP_ICON_DIR}/icon.icns" --out "${TEMP_ICON_DIR}/icon.png" 2>/dev/null || true
+    
+    # Method: Use osascript to set file icon (works on macOS)
+    osascript <<APPLESCRIPT
+use framework "Foundation"
+use framework "AppKit"
+
+set iconPath to POSIX file "${TEMP_ICON_DIR}/icon.icns"
+set targetPath to POSIX file "$(pwd)/${PKG_NAME}"
+
+set iconImage to current application's NSImage's alloc()'s initWithContentsOfFile:(POSIX path of iconPath)
+set workspace to current application's NSWorkspace's sharedWorkspace()
+workspace's setIcon:iconImage forFile:(POSIX path of targetPath) options:0
+APPLESCRIPT
+
+    if [ $? -eq 0 ]; then
+        echo "Custom icon set successfully for ${PKG_NAME}"
+    else
+        echo "Warning: Failed to set custom icon (this is optional)"
+    fi
+    
+    rm -rf "${TEMP_ICON_DIR}"
+fi
+echo "Set icon finished"
+
 rm -rf build_pkg_temp build_pkg_scripts ${APP_BUNDLE}
 
 echo "PKG package created successfully."

src/config_center/config_center.h

@@ -71,7 +71,7 @@ class ConfigCenter {
   const char* section_ = "Settings";
 
   LANGUAGE language_ = LANGUAGE::CHINESE;
-  VIDEO_QUALITY video_quality_ = VIDEO_QUALITY::MEDIUM;
+  VIDEO_QUALITY video_quality_ = VIDEO_QUALITY::HIGH;
   VIDEO_FRAME_RATE video_frame_rate_ = VIDEO_FRAME_RATE::FPS_60;
   VIDEO_ENCODE_FORMAT video_encode_format_ = VIDEO_ENCODE_FORMAT::H264;
   bool hardware_video_codec_ = false;

src/gui/render.h

@@ -622,10 +622,10 @@ class Render {
   char self_hosted_id_[17] = "";
   char self_hosted_user_id_[17] = "";
   int language_button_value_ = 0;
-  int video_quality_button_value_ = 0;
+  int video_quality_button_value_ = 2;
   int video_frame_rate_button_value_ = 1;
   int video_encode_format_button_value_ = 0;
-  bool enable_hardware_video_codec_ = false;
+  bool enable_hardware_video_codec_ = true;
   bool enable_turn_ = true;
   bool enable_srtp_ = false;
   char signal_server_ip_[256] = "api.crossdesk.cn";

src/gui/render_callback.cpp

@@ -568,13 +568,6 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
           remote_action.i.host_name, remote_action.i.host_name_size);
       LOG_INFO("Remote hostname: [{}]",
                render->connection_host_names_[remote_id]);
-
-      for (int i = 0; i < remote_action.i.display_num; i++) {
-        render->display_info_list_.push_back(
-            DisplayInfo(remote_action.i.display_list[i],
-                        remote_action.i.left[i], remote_action.i.top[i],
-                        remote_action.i.right[i], remote_action.i.bottom[i]));
-      }
       FreeRemoteAction(remote_action);
     }
   } else {

src/screen_capturer/screen_capturer_factory.h

@@ -8,7 +8,7 @@
 #define _SCREEN_CAPTURER_FACTORY_H_
 
 #ifdef _WIN32
-#include "screen_capturer_wgc.h"
+#include "screen_capturer_win.h"
 #elif __linux__
 #include "screen_capturer_x11.h"
 #elif __APPLE__
@@ -25,7 +25,7 @@ class ScreenCapturerFactory {
  public:
   ScreenCapturer* Create() {
 #ifdef _WIN32
-    return new ScreenCapturerWgc();
+    return new ScreenCapturerWin();
 #elif __linux__
     return new ScreenCapturerX11();
 #elif __APPLE__
@@ -37,4 +37,4 @@ class ScreenCapturerFactory {
   }
 };
 }  // namespace crossdesk
-#endif
+#endif

src/screen_capturer/windows/screen_capturer_dxgi.cpp

@@ -0,0 +1,333 @@
+#include "screen_capturer_dxgi.h"
+
+#include <algorithm>
+#include <chrono>
+#include <string>
+#include <vector>
+
+#include "libyuv.h"
+#include "rd_log.h"
+
+namespace crossdesk {
+
+namespace {
+std::string WideToUtf8(const std::wstring& wstr) {
+  if (wstr.empty()) return {};
+  int size_needed = WideCharToMultiByte(
+      CP_UTF8, 0, wstr.data(), (int)wstr.size(), nullptr, 0, nullptr, nullptr);
+  std::string result(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), result.data(),
+                      size_needed, nullptr, nullptr);
+  return result;
+}
+
+std::string CleanDisplayName(const std::wstring& wide_name) {
+  std::string name = WideToUtf8(wide_name);
+  name.erase(std::remove_if(name.begin(), name.end(),
+                            [](unsigned char c) { return !std::isalnum(c); }),
+             name.end());
+  return name;
+}
+}  // namespace
+
+ScreenCapturerDxgi::ScreenCapturerDxgi() {}
+ScreenCapturerDxgi::~ScreenCapturerDxgi() {
+  Stop();
+  Destroy();
+}
+
+int ScreenCapturerDxgi::Init(const int fps, cb_desktop_data cb) {
+  fps_ = fps;
+  callback_ = cb;
+  if (!callback_) {
+    LOG_ERROR("DXGI: callback is null");
+    return -1;
+  }
+
+  if (!InitializeDxgi()) {
+    LOG_ERROR("DXGI: initialize DXGI failed");
+    return -2;
+  }
+
+  EnumerateDisplays();
+  if (display_info_list_.empty()) {
+    LOG_ERROR("DXGI: no displays found");
+    return -3;
+  }
+
+  monitor_index_ = 0;
+  return 0;
+}
+
+int ScreenCapturerDxgi::Destroy() {
+  Stop();
+  ReleaseDuplication();
+  outputs_.clear();
+  d3d_context_.Reset();
+  d3d_device_.Reset();
+  dxgi_factory_.Reset();
+  if (nv12_frame_) {
+    delete[] nv12_frame_;
+    nv12_frame_ = nullptr;
+    nv12_width_ = 0;
+    nv12_height_ = 0;
+  }
+  return 0;
+}
+
+int ScreenCapturerDxgi::Start(bool show_cursor) {
+  if (running_) return 0;
+  show_cursor_ = show_cursor;
+
+  if (!CreateDuplicationForMonitor(monitor_index_)) {
+    LOG_ERROR("DXGI: create duplication failed for monitor {}",
+              monitor_index_.load());
+    return -1;
+  }
+
+  paused_ = false;
+  running_ = true;
+  thread_ = std::thread([this]() { CaptureLoop(); });
+  return 0;
+}
+
+int ScreenCapturerDxgi::Stop() {
+  if (!running_) return 0;
+  running_ = false;
+  if (thread_.joinable()) thread_.join();
+  ReleaseDuplication();
+  return 0;
+}
+
+int ScreenCapturerDxgi::Pause(int monitor_index) {
+  paused_ = true;
+  return 0;
+}
+
+int ScreenCapturerDxgi::Resume(int monitor_index) {
+  paused_ = false;
+  return 0;
+}
+
+int ScreenCapturerDxgi::SwitchTo(int monitor_index) {
+  if (monitor_index < 0 || monitor_index >= (int)display_info_list_.size()) {
+    LOG_ERROR("DXGI: invalid monitor index {}", monitor_index);
+    return -1;
+  }
+  paused_ = true;
+  monitor_index_ = monitor_index;
+  ReleaseDuplication();
+  if (!CreateDuplicationForMonitor(monitor_index_)) {
+    LOG_ERROR("DXGI: create duplication failed for monitor {}",
+              monitor_index_.load());
+    return -2;
+  }
+  paused_ = false;
+  LOG_INFO("DXGI: switched to monitor {}:{}", monitor_index_.load(),
+           display_info_list_[monitor_index_].name);
+  return 0;
+}
+
+bool ScreenCapturerDxgi::InitializeDxgi() {
+  UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+#ifdef _DEBUG
+  flags |= D3D11_CREATE_DEVICE_DEBUG;
+#endif
+
+  D3D_FEATURE_LEVEL feature_levels[] = {
+      D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
+      D3D_FEATURE_LEVEL_10_0};
+
+  D3D_FEATURE_LEVEL out_level{};
+  HRESULT hr = D3D11CreateDevice(
+      nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, feature_levels,
+      ARRAYSIZE(feature_levels), D3D11_SDK_VERSION, d3d_device_.GetAddressOf(),
+      &out_level, d3d_context_.GetAddressOf());
+  if (FAILED(hr)) {
+    hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_WARP, nullptr, flags,
+                           feature_levels, ARRAYSIZE(feature_levels),
+                           D3D11_SDK_VERSION, d3d_device_.GetAddressOf(),
+                           &out_level, d3d_context_.GetAddressOf());
+    if (FAILED(hr)) {
+      LOG_ERROR("DXGI: D3D11CreateDevice failed, hr={}", (int)hr);
+      return false;
+    }
+  }
+
+  hr = CreateDXGIFactory1(
+      __uuidof(IDXGIFactory1),
+      reinterpret_cast<void**>(dxgi_factory_.GetAddressOf()));
+  if (FAILED(hr)) {
+    LOG_ERROR("DXGI: CreateDXGIFactory1 failed, hr={}", (int)hr);
+    return false;
+  }
+  return true;
+}
+
+void ScreenCapturerDxgi::EnumerateDisplays() {
+  display_info_list_.clear();
+  outputs_.clear();
+
+  Microsoft::WRL::ComPtr<IDXGIAdapter> adapter;
+  for (UINT a = 0;
+       dxgi_factory_->EnumAdapters(a, adapter.ReleaseAndGetAddressOf()) !=
+       DXGI_ERROR_NOT_FOUND;
+       ++a) {
+    Microsoft::WRL::ComPtr<IDXGIOutput> output;
+    for (UINT o = 0; adapter->EnumOutputs(o, output.ReleaseAndGetAddressOf()) !=
+                     DXGI_ERROR_NOT_FOUND;
+         ++o) {
+      DXGI_OUTPUT_DESC desc{};
+      if (FAILED(output->GetDesc(&desc))) {
+        continue;
+      }
+      std::string name = CleanDisplayName(desc.DeviceName);
+      MONITORINFOEX mi{};
+      mi.cbSize = sizeof(MONITORINFOEX);
+      if (GetMonitorInfo(desc.Monitor, &mi)) {
+        bool is_primary = (mi.dwFlags & MONITORINFOF_PRIMARY) ? true : false;
+        DisplayInfo info((void*)desc.Monitor, name, is_primary,
+                         mi.rcMonitor.left, mi.rcMonitor.top,
+                         mi.rcMonitor.right, mi.rcMonitor.bottom);
+        // primary first
+        if (is_primary)
+          display_info_list_.insert(display_info_list_.begin(), info);
+        else
+          display_info_list_.push_back(info);
+        outputs_.push_back(output);
+      }
+    }
+  }
+}
+
+bool ScreenCapturerDxgi::CreateDuplicationForMonitor(int monitor_index) {
+  if (monitor_index < 0 || monitor_index >= (int)outputs_.size()) return false;
+  Microsoft::WRL::ComPtr<IDXGIOutput1> output1;
+  HRESULT hr = outputs_[monitor_index]->QueryInterface(
+      IID_PPV_ARGS(output1.GetAddressOf()));
+  if (FAILED(hr)) {
+    LOG_ERROR("DXGI: Query IDXGIOutput1 failed, hr={}", (int)hr);
+    return false;
+  }
+
+  duplication_.Reset();
+  hr = output1->DuplicateOutput(d3d_device_.Get(), duplication_.GetAddressOf());
+  if (FAILED(hr)) {
+    LOG_ERROR("DXGI: DuplicateOutput failed, hr={}", (int)hr);
+    return false;
+  }
+
+  staging_.Reset();
+  return true;
+}
+
+void ScreenCapturerDxgi::ReleaseDuplication() {
+  staging_.Reset();
+  if (duplication_) {
+    duplication_->ReleaseFrame();
+  }
+  duplication_.Reset();
+}
+
+void ScreenCapturerDxgi::CaptureLoop() {
+  const int timeout_ms = 33;
+  while (running_) {
+    if (paused_) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      continue;
+    }
+
+    if (!duplication_) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      continue;
+    }
+
+    DXGI_OUTDUPL_FRAME_INFO frame_info{};
+    Microsoft::WRL::ComPtr<IDXGIResource> desktop_resource;
+    HRESULT hr = duplication_->AcquireNextFrame(
+        timeout_ms, &frame_info, desktop_resource.GetAddressOf());
+    if (hr == DXGI_ERROR_WAIT_TIMEOUT) {
+      continue;
+    }
+    if (FAILED(hr)) {
+      LOG_ERROR("DXGI: AcquireNextFrame failed, hr={}", (int)hr);
+      // attempt to recreate duplication
+      ReleaseDuplication();
+      CreateDuplicationForMonitor(monitor_index_);
+      continue;
+    }
+
+    Microsoft::WRL::ComPtr<ID3D11Texture2D> acquired_tex;
+    if (desktop_resource) {
+      hr = desktop_resource->QueryInterface(
+          IID_PPV_ARGS(acquired_tex.GetAddressOf()));
+      if (FAILED(hr)) {
+        duplication_->ReleaseFrame();
+        continue;
+      }
+    } else {
+      duplication_->ReleaseFrame();
+      continue;
+    }
+
+    D3D11_TEXTURE2D_DESC src_desc{};
+    acquired_tex->GetDesc(&src_desc);
+
+    if (!staging_) {
+      D3D11_TEXTURE2D_DESC staging_desc = src_desc;
+      staging_desc.Usage = D3D11_USAGE_STAGING;
+      staging_desc.BindFlags = 0;
+      staging_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+      staging_desc.MiscFlags = 0;
+      hr = d3d_device_->CreateTexture2D(&staging_desc, nullptr,
+                                        staging_.GetAddressOf());
+      if (FAILED(hr)) {
+        LOG_ERROR("DXGI: CreateTexture2D staging failed, hr={}", (int)hr);
+        duplication_->ReleaseFrame();
+        continue;
+      }
+    }
+
+    d3d_context_->CopyResource(staging_.Get(), acquired_tex.Get());
+
+    D3D11_MAPPED_SUBRESOURCE mapped{};
+    hr = d3d_context_->Map(staging_.Get(), 0, D3D11_MAP_READ, 0, &mapped);
+    if (FAILED(hr)) {
+      duplication_->ReleaseFrame();
+      continue;
+    }
+
+    int logical_width = static_cast<int>(src_desc.Width);
+    int even_width = logical_width & ~1;
+    int even_height = static_cast<int>(src_desc.Height) & ~1;
+    if (even_width <= 0 || even_height <= 0) {
+      d3d_context_->Unmap(staging_.Get(), 0);
+      duplication_->ReleaseFrame();
+      continue;
+    }
+
+    int nv12_size = even_width * even_height * 3 / 2;
+    if (!nv12_frame_ || nv12_width_ != even_width ||
+        nv12_height_ != even_height) {
+      delete[] nv12_frame_;
+      nv12_frame_ = new unsigned char[nv12_size];
+      nv12_width_ = even_width;
+      nv12_height_ = even_height;
+    }
+
+    libyuv::ARGBToNV12(static_cast<const uint8_t*>(mapped.pData),
+                       static_cast<int>(mapped.RowPitch), nv12_frame_,
+                       even_width, nv12_frame_ + even_width * even_height,
+                       even_width, even_width, even_height);
+
+    if (callback_) {
+      callback_(nv12_frame_, nv12_size, even_width, even_height,
+                display_info_list_[monitor_index_].name.c_str());
+    }
+
+    d3d_context_->Unmap(staging_.Get(), 0);
+    duplication_->ReleaseFrame();
+  }
+}
+
+}  // namespace crossdesk

src/screen_capturer/windows/screen_capturer_dxgi.h

@@ -0,0 +1,79 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-02-27
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SCREEN_CAPTURER_DXGI_H_
+#define _SCREEN_CAPTURER_DXGI_H_
+
+#include <Windows.h>
+#include <d3d11.h>
+#include <dxgi1_2.h>
+#include <wrl/client.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "rd_log.h"
+#include "screen_capturer.h"
+
+namespace crossdesk {
+
+class ScreenCapturerDxgi : public ScreenCapturer {
+ public:
+  ScreenCapturerDxgi();
+  ~ScreenCapturerDxgi();
+
+ public:
+  int Init(const int fps, cb_desktop_data cb) override;
+  int Destroy() override;
+  int Start(bool show_cursor) override;
+  int Stop() override;
+
+  int Pause(int monitor_index) override;
+  int Resume(int monitor_index) override;
+
+  int SwitchTo(int monitor_index) override;
+
+  std::vector<DisplayInfo> GetDisplayInfoList() override {
+    return display_info_list_;
+  }
+
+ private:
+  bool InitializeDxgi();
+  void EnumerateDisplays();
+  bool CreateDuplicationForMonitor(int monitor_index);
+  void CaptureLoop();
+  void ReleaseDuplication();
+
+ private:
+  std::vector<DisplayInfo> display_info_list_;
+  std::vector<Microsoft::WRL::ComPtr<IDXGIOutput>> outputs_;
+
+  Microsoft::WRL::ComPtr<IDXGIFactory1> dxgi_factory_;
+  Microsoft::WRL::ComPtr<ID3D11Device> d3d_device_;
+  Microsoft::WRL::ComPtr<ID3D11DeviceContext> d3d_context_;
+  Microsoft::WRL::ComPtr<IDXGIOutputDuplication> duplication_;
+  Microsoft::WRL::ComPtr<ID3D11Texture2D> staging_;
+
+  std::atomic<bool> running_{false};
+  std::atomic<bool> paused_{false};
+  std::atomic<int> monitor_index_{0};
+  std::atomic<bool> show_cursor_{true};
+  std::thread thread_;
+  int fps_ = 60;
+  cb_desktop_data callback_ = nullptr;
+
+  unsigned char* nv12_frame_ = nullptr;
+  int nv12_width_ = 0;
+  int nv12_height_ = 0;
+};
+}  // namespace crossdesk
+
+#endif

src/screen_capturer/windows/screen_capturer_gdi.cpp

@@ -0,0 +1,206 @@
+#include "screen_capturer_gdi.h"
+
+#include <algorithm>
+#include <chrono>
+#include <string>
+#include <vector>
+
+#include "libyuv.h"
+#include "rd_log.h"
+
+namespace crossdesk {
+
+namespace {
+std::string WideToUtf8(const std::wstring& wstr) {
+  if (wstr.empty()) return {};
+  int size_needed = WideCharToMultiByte(
+      CP_UTF8, 0, wstr.data(), (int)wstr.size(), nullptr, 0, nullptr, nullptr);
+  std::string result(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), result.data(),
+                      size_needed, nullptr, nullptr);
+  return result;
+}
+
+std::string CleanDisplayName(const std::wstring& wide_name) {
+  std::string name = WideToUtf8(wide_name);
+  name.erase(std::remove_if(name.begin(), name.end(),
+                            [](unsigned char c) { return !std::isalnum(c); }),
+             name.end());
+  return name;
+}
+}  // namespace
+
+ScreenCapturerGdi::ScreenCapturerGdi() {}
+ScreenCapturerGdi::~ScreenCapturerGdi() {
+  Stop();
+  Destroy();
+}
+
+BOOL CALLBACK ScreenCapturerGdi::EnumMonitorProc(HMONITOR hMonitor, HDC, LPRECT,
+                                                 LPARAM data) {
+  auto displays = reinterpret_cast<std::vector<DisplayInfo>*>(data);
+  MONITORINFOEX mi{};
+  mi.cbSize = sizeof(MONITORINFOEX);
+  if (GetMonitorInfo(hMonitor, &mi)) {
+    std::string name = CleanDisplayName(mi.szDevice);
+    bool is_primary = (mi.dwFlags & MONITORINFOF_PRIMARY) ? true : false;
+    DisplayInfo info((void*)hMonitor, name, is_primary, mi.rcMonitor.left,
+                     mi.rcMonitor.top, mi.rcMonitor.right, mi.rcMonitor.bottom);
+    if (is_primary)
+      displays->insert(displays->begin(), info);
+    else
+      displays->push_back(info);
+  }
+  return TRUE;
+}
+
+void ScreenCapturerGdi::EnumerateDisplays() {
+  display_info_list_.clear();
+  EnumDisplayMonitors(nullptr, nullptr, EnumMonitorProc,
+                      (LPARAM)&display_info_list_);
+}
+
+int ScreenCapturerGdi::Init(const int fps, cb_desktop_data cb) {
+  fps_ = fps;
+  callback_ = cb;
+  if (!callback_) {
+    LOG_ERROR("GDI: callback is null");
+    return -1;
+  }
+  EnumerateDisplays();
+  if (display_info_list_.empty()) {
+    LOG_ERROR("GDI: no displays found");
+    return -2;
+  }
+  monitor_index_ = 0;
+  return 0;
+}
+
+int ScreenCapturerGdi::Destroy() {
+  Stop();
+  if (nv12_frame_) {
+    delete[] nv12_frame_;
+    nv12_frame_ = nullptr;
+    nv12_width_ = 0;
+    nv12_height_ = 0;
+  }
+  return 0;
+}
+
+int ScreenCapturerGdi::Start(bool show_cursor) {
+  if (running_) return 0;
+  show_cursor_ = show_cursor;
+  paused_ = false;
+  running_ = true;
+  thread_ = std::thread([this]() { CaptureLoop(); });
+  return 0;
+}
+
+int ScreenCapturerGdi::Stop() {
+  if (!running_) return 0;
+  running_ = false;
+  if (thread_.joinable()) thread_.join();
+  return 0;
+}
+
+int ScreenCapturerGdi::Pause(int monitor_index) {
+  paused_ = true;
+  return 0;
+}
+
+int ScreenCapturerGdi::Resume(int monitor_index) {
+  paused_ = false;
+  return 0;
+}
+
+int ScreenCapturerGdi::SwitchTo(int monitor_index) {
+  if (monitor_index < 0 || monitor_index >= (int)display_info_list_.size()) {
+    LOG_ERROR("GDI: invalid monitor index {}", monitor_index);
+    return -1;
+  }
+  monitor_index_ = monitor_index;
+  LOG_INFO("GDI: switched to monitor {}:{}", monitor_index_.load(),
+           display_info_list_[monitor_index_].name);
+  return 0;
+}
+
+void ScreenCapturerGdi::CaptureLoop() {
+  int interval_ms = fps_ > 0 ? (1000 / fps_) : 16;
+  HDC screen_dc = GetDC(nullptr);
+  while (running_) {
+    if (paused_) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      continue;
+    }
+    if (!screen_dc) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      continue;
+    }
+
+    const auto& di = display_info_list_[monitor_index_];
+    int left = di.left;
+    int top = di.top;
+    int width = di.width & ~1;
+    int height = di.height & ~1;
+    if (width <= 0 || height <= 0) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(interval_ms));
+      continue;
+    }
+
+    BITMAPINFO bmi{};
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth = width;
+    bmi.bmiHeader.biHeight = -height;
+    bmi.bmiHeader.biPlanes = 1;
+    bmi.bmiHeader.biBitCount = 32;
+    bmi.bmiHeader.biCompression = BI_RGB;
+
+    void* bits = nullptr;
+    HDC mem_dc = CreateCompatibleDC(screen_dc);
+    HBITMAP dib =
+        CreateDIBSection(mem_dc, &bmi, DIB_RGB_COLORS, &bits, nullptr, 0);
+    HGDIOBJ old = SelectObject(mem_dc, dib);
+
+    BitBlt(mem_dc, 0, 0, width, height, screen_dc, left, top,
+           SRCCOPY | CAPTUREBLT);
+
+    if (show_cursor_) {
+      CURSORINFO ci{};
+      ci.cbSize = sizeof(CURSORINFO);
+      if (GetCursorInfo(&ci) && ci.flags == CURSOR_SHOWING && ci.hCursor) {
+        POINT pt = ci.ptScreenPos;
+        int cx = pt.x - left;
+        int cy = pt.y - top;
+        if (cx >= -64 && cy >= -64 && cx < width + 64 && cy < height + 64) {
+          DrawIconEx(mem_dc, cx, cy, ci.hCursor, 0, 0, 0, nullptr, DI_NORMAL);
+        }
+      }
+    }
+
+    int stride_argb = width * 4;
+    int nv12_size = width * height * 3 / 2;
+    if (!nv12_frame_ || nv12_width_ != width || nv12_height_ != height) {
+      delete[] nv12_frame_;
+      nv12_frame_ = new unsigned char[nv12_size];
+      nv12_width_ = width;
+      nv12_height_ = height;
+    }
+
+    libyuv::ARGBToNV12(static_cast<const uint8_t*>(bits), stride_argb,
+                       nv12_frame_, width, nv12_frame_ + width * height, width,
+                       width, height);
+
+    if (callback_) {
+      callback_(nv12_frame_, nv12_size, width, height, di.name.c_str());
+    }
+
+    SelectObject(mem_dc, old);
+    DeleteObject(dib);
+    DeleteDC(mem_dc);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(interval_ms));
+  }
+  ReleaseDC(nullptr, screen_dc);
+}
+
+}  // namespace crossdesk

src/screen_capturer/windows/screen_capturer_gdi.h

@@ -0,0 +1,66 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-02-27
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SCREEN_CAPTURER_GDI_H_
+#define _SCREEN_CAPTURER_GDI_H_
+
+#include <Windows.h>
+
+#include <atomic>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "rd_log.h"
+#include "screen_capturer.h"
+
+namespace crossdesk {
+
+class ScreenCapturerGdi : public ScreenCapturer {
+ public:
+  ScreenCapturerGdi();
+  ~ScreenCapturerGdi();
+
+ public:
+  int Init(const int fps, cb_desktop_data cb) override;
+  int Destroy() override;
+  int Start(bool show_cursor) override;
+  int Stop() override;
+
+  int Pause(int monitor_index) override;
+  int Resume(int monitor_index) override;
+
+  int SwitchTo(int monitor_index) override;
+
+  std::vector<DisplayInfo> GetDisplayInfoList() override {
+    return display_info_list_;
+  }
+
+ private:
+  static BOOL CALLBACK EnumMonitorProc(HMONITOR hMonitor, HDC, LPRECT,
+                                       LPARAM data);
+  void EnumerateDisplays();
+  void CaptureLoop();
+
+ private:
+  std::vector<DisplayInfo> display_info_list_;
+  std::atomic<bool> running_{false};
+  std::atomic<bool> paused_{false};
+  std::atomic<int> monitor_index_{0};
+  std::atomic<bool> show_cursor_{true};
+  std::thread thread_;
+  int fps_ = 60;
+  cb_desktop_data callback_ = nullptr;
+
+  unsigned char* nv12_frame_ = nullptr;
+  int nv12_width_ = 0;
+  int nv12_height_ = 0;
+};
+}  // namespace crossdesk
+
+#endif

src/screen_capturer/windows/screen_capturer_wgc.cpp

@@ -56,8 +56,6 @@ BOOL WINAPI EnumMonitorProc(HMONITOR hmonitor, [[maybe_unused]] HDC hdc,
     }
   }
 
-  if (monitor_info_.dwFlags == DISPLAY_DEVICE_MIRRORING_DRIVER) return true;
-
   return true;
 }
 
@@ -165,6 +163,8 @@ int ScreenCapturerWgc::Start(bool show_cursor) {
     return 4;
   }
 
+  bool any_started = false;
+  int last_error = 0;
   for (int i = 0; i < sessions_.size(); i++) {
     if (sessions_[i].inited_ == false) {
       LOG_ERROR("Session {} not inited", i);
@@ -174,17 +174,27 @@ int ScreenCapturerWgc::Start(bool show_cursor) {
     if (sessions_[i].running_) {
       LOG_ERROR("Session {} is already running", i);
     } else {
-      sessions_[i].session_->Start(show_cursor);
+      int ret = sessions_[i].session_->Start(show_cursor);
+      if (ret != 0) {
+        LOG_ERROR("Session {} start failed, ret={}", i, ret);
+        last_error = ret;
+        continue;
+      }
 
       if (i != 0) {
         sessions_[i].session_->Pause();
         sessions_[i].paused_ = true;
       }
       sessions_[i].running_ = true;
+      any_started = true;
     }
-    running_ = true;
+    running_ = running_ || any_started;
   }
 
+  if (!any_started) {
+    LOG_ERROR("WGC: no session started successfully");
+    return last_error != 0 ? last_error : -1;
+  }
   return 0;
 }
 
@@ -327,4 +337,4 @@ void ScreenCapturerWgc::CleanUp() {
     sessions_.clear();
   }
 }
-}  // namespace crossdesk
+}  // namespace crossdesk

src/screen_capturer/windows/screen_capturer_wgc.h

@@ -57,8 +57,8 @@ class ScreenCapturerWgc : public ScreenCapturer,
 
   std::vector<WgcSessionInfo> sessions_;
 
-  std::atomic_bool running_;
+  std::atomic_bool running_{false};
-  std::atomic_bool inited_;
+  std::atomic_bool inited_{false};
 
   int fps_ = 60;
 
@@ -72,4 +72,4 @@ class ScreenCapturerWgc : public ScreenCapturer,
   std::mutex frame_mutex_;
 };
 }  // namespace crossdesk
-#endif
+#endif

src/screen_capturer/windows/screen_capturer_win.cpp

@@ -0,0 +1,198 @@
+#include "screen_capturer_win.h"
+
+#include <cmath>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "rd_log.h"
+#include "screen_capturer_dxgi.h"
+#include "screen_capturer_gdi.h"
+#include "screen_capturer_wgc.h"
+
+namespace crossdesk {
+
+ScreenCapturerWin::ScreenCapturerWin() {}
+ScreenCapturerWin::~ScreenCapturerWin() { Destroy(); }
+
+int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
+  fps_ = fps;
+  cb_orig_ = cb;
+  cb_ = [this](unsigned char* data, int size, int w, int h,
+               const char* display_name) {
+    std::string mapped_name;
+    {
+      std::lock_guard<std::mutex> lock(alias_mutex_);
+      auto it = label_alias_.find(display_name);
+      if (it != label_alias_.end())
+        mapped_name = it->second;
+      else
+        mapped_name = display_name;
+    }
+    {
+      std::lock_guard<std::mutex> lock(alias_mutex_);
+      if (canonical_labels_.find(mapped_name) == canonical_labels_.end()) {
+        return;
+      }
+    }
+    if (cb_orig_) cb_orig_(data, size, w, h, mapped_name.c_str());
+  };
+
+  int ret = -1;
+
+  impl_ = std::make_unique<ScreenCapturerWgc>();
+  ret = impl_->Init(fps_, cb_);
+  if (ret == 0) {
+    LOG_INFO("Windows capturer: using WGC");
+    BuildCanonicalFromImpl();
+    return 0;
+  }
+
+  LOG_WARN("Windows capturer: WGC init failed (ret={}), try DXGI", ret);
+  impl_.reset();
+
+  impl_ = std::make_unique<ScreenCapturerDxgi>();
+  ret = impl_->Init(fps_, cb_);
+  if (ret == 0) {
+    LOG_INFO("Windows capturer: using DXGI Desktop Duplication");
+    BuildCanonicalFromImpl();
+    return 0;
+  }
+
+  LOG_WARN("Windows capturer: DXGI init failed (ret={}), fallback to GDI", ret);
+  impl_.reset();
+
+  impl_ = std::make_unique<ScreenCapturerGdi>();
+  ret = impl_->Init(fps_, cb_);
+  if (ret == 0) {
+    LOG_INFO("Windows capturer: using GDI BitBlt");
+    BuildCanonicalFromImpl();
+    return 0;
+  }
+
+  LOG_ERROR("Windows capturer: all implementations failed, ret={}", ret);
+  impl_.reset();
+  return -1;
+}
+
+int ScreenCapturerWin::Destroy() {
+  if (impl_) {
+    impl_->Destroy();
+    impl_.reset();
+  }
+  {
+    std::lock_guard<std::mutex> lock(alias_mutex_);
+    label_alias_.clear();
+    handle_to_canonical_.clear();
+    canonical_labels_.clear();
+  }
+  return 0;
+}
+
+int ScreenCapturerWin::Start(bool show_cursor) {
+  if (!impl_) return -1;
+  int ret = impl_->Start(show_cursor);
+  if (ret == 0) return 0;
+
+  LOG_WARN("Windows capturer: Start failed (ret={}), trying fallback", ret);
+
+  auto try_init_start = [&](std::unique_ptr<ScreenCapturer> cand) -> bool {
+    int r = cand->Init(fps_, cb_);
+    if (r != 0) return false;
+    int s = cand->Start(show_cursor);
+    if (s == 0) {
+      impl_ = std::move(cand);
+      RebuildAliasesFromImpl();
+      return true;
+    }
+    return false;
+  };
+
+  if (dynamic_cast<ScreenCapturerWgc*>(impl_.get())) {
+    if (try_init_start(std::make_unique<ScreenCapturerDxgi>())) {
+      LOG_INFO("Windows capturer: fallback to DXGI");
+      return 0;
+    }
+    if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
+      LOG_INFO("Windows capturer: fallback to GDI");
+      return 0;
+    }
+  } else if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get())) {
+    if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
+      LOG_INFO("Windows capturer: fallback to GDI");
+      return 0;
+    }
+  }
+
+  LOG_ERROR("Windows capturer: all fallbacks failed to start");
+  return ret;
+}
+
+int ScreenCapturerWin::Stop() {
+  if (!impl_) return 0;
+  return impl_->Stop();
+}
+
+int ScreenCapturerWin::Pause(int monitor_index) {
+  if (!impl_) return -1;
+  return impl_->Pause(monitor_index);
+}
+
+int ScreenCapturerWin::Resume(int monitor_index) {
+  if (!impl_) return -1;
+  return impl_->Resume(monitor_index);
+}
+
+int ScreenCapturerWin::SwitchTo(int monitor_index) {
+  if (!impl_) return -1;
+  return impl_->SwitchTo(monitor_index);
+}
+
+std::vector<DisplayInfo> ScreenCapturerWin::GetDisplayInfoList() {
+  if (!impl_) return {};
+  return impl_->GetDisplayInfoList();
+}
+
+void ScreenCapturerWin::BuildCanonicalFromImpl() {
+  std::lock_guard<std::mutex> lock(alias_mutex_);
+  handle_to_canonical_.clear();
+  label_alias_.clear();
+  canonical_displays_ = impl_->GetDisplayInfoList();
+  canonical_labels_.clear();
+  for (const auto& di : canonical_displays_) {
+    handle_to_canonical_[di.handle] = di.name;
+    canonical_labels_.insert(di.name);
+  }
+}
+
+void ScreenCapturerWin::RebuildAliasesFromImpl() {
+  std::lock_guard<std::mutex> lock(alias_mutex_);
+  label_alias_.clear();
+  auto current = impl_->GetDisplayInfoList();
+  auto similar = [&](const DisplayInfo& a, const DisplayInfo& b) {
+    int dl = std::abs(a.left - b.left);
+    int dt = std::abs(a.top - b.top);
+    int dw = std::abs(a.width - b.width);
+    int dh = std::abs(a.height - b.height);
+    return dl <= 10 && dt <= 10 && dw <= 20 && dh <= 20;
+  };
+  for (const auto& di : current) {
+    std::string canonical;
+    auto it = handle_to_canonical_.find(di.handle);
+    if (it != handle_to_canonical_.end()) {
+      canonical = it->second;
+    } else {
+      for (const auto& c : canonical_displays_) {
+        if (similar(di, c) || (di.is_primary && c.is_primary)) {
+          canonical = c.name;
+          break;
+        }
+      }
+    }
+    if (!canonical.empty() && canonical != di.name) {
+      label_alias_[di.name] = canonical;
+    }
+  }
+}
+
+}  // namespace crossdesk

src/screen_capturer/windows/screen_capturer_win.h

@@ -0,0 +1,54 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-02-27
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SCREEN_CAPTURER_WIN_H_
+#define _SCREEN_CAPTURER_WIN_H_
+
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "screen_capturer.h"
+
+namespace crossdesk {
+
+class ScreenCapturerWin : public ScreenCapturer {
+ public:
+  ScreenCapturerWin();
+  ~ScreenCapturerWin();
+
+ public:
+  int Init(const int fps, cb_desktop_data cb) override;
+  int Destroy() override;
+  int Start(bool show_cursor) override;
+  int Stop() override;
+
+  int Pause(int monitor_index) override;
+  int Resume(int monitor_index) override;
+
+  int SwitchTo(int monitor_index) override;
+
+  std::vector<DisplayInfo> GetDisplayInfoList() override;
+
+ private:
+  std::unique_ptr<ScreenCapturer> impl_;
+  int fps_ = 60;
+  cb_desktop_data cb_;
+  cb_desktop_data cb_orig_;
+
+  std::unordered_map<void*, std::string> handle_to_canonical_;
+  std::unordered_map<std::string, std::string> label_alias_;
+  std::mutex alias_mutex_;
+  std::vector<DisplayInfo> canonical_displays_;
+  std::unordered_set<std::string> canonical_labels_;
+
+  void BuildCanonicalFromImpl();
+  void RebuildAliasesFromImpl();
+};
+}  // namespace crossdesk
+#endif

src/screen_capturer/windows/wgc_session_impl.cpp

@@ -7,6 +7,8 @@
 #include <iostream>
 #include <memory>
 
+#include "rd_log.h"
+
 #define CHECK_INIT                            \
   if (!is_initialized_) {                     \
     std::cout << "AE_NEED_INIT" << std::endl; \
@@ -64,6 +66,7 @@ int WgcSessionImpl::Start(bool show_cursor) {
 
   CHECK_INIT;
   try {
+    last_show_cursor_ = show_cursor;
     if (!capture_session_) {
       auto current_size = capture_item_.Size();
       capture_framepool_ =
@@ -89,13 +92,12 @@ int WgcSessionImpl::Start(bool show_cursor) {
     // we need to test the performance later
     // loop_ = std::thread(std::bind(&WgcSessionImpl::message_func, this));
 
-    capture_session_.StartCapture();
-
     capture_session_.IsCursorCaptureEnabled(show_cursor);
+    capture_session_.StartCapture();
 
     error = 0;
   } catch (winrt::hresult_error) {
-    std::cout << "AE_WGC_CREATE_CAPTURER_FAILED" << std::endl;
+    LOG_ERROR("AE_WGC_CREATE_CAPTURER_FAILED");
     return 86;
   } catch (...) {
     return 86;
@@ -246,8 +248,15 @@ void WgcSessionImpl::OnFrame(
       auto frame_captured =
           GetDXGIInterfaceFromObject<ID3D11Texture2D>(frame.Surface());
 
-      if (!d3d11_texture_mapped_ || is_new_size)
+      if (!d3d11_texture_mapped_ || is_new_size) {
-        CreateMappedTexture(frame_captured);
+        HRESULT tex_hr = CreateMappedTexture(frame_captured);
+        if (FAILED(tex_hr)) {
+          OutputDebugStringW(
+              (L"CreateMappedTexture failed: " + std::to_wstring(tex_hr))
+                  .c_str());
+          return;
+        }
+      }
 
       d3d11_device_context_->CopyResource(d3d11_texture_mapped_.get(),
                                           frame_captured.get());
@@ -262,6 +271,7 @@ void WgcSessionImpl::OnFrame(
       if (FAILED(hr)) {
         OutputDebugStringW(
             (L"map resource failed: " + std::to_wstring(hr)).c_str());
+        return;
       }
 
       // copy data from map_result.pData
@@ -290,7 +300,24 @@ void WgcSessionImpl::OnFrame(
 void WgcSessionImpl::OnClosed(
     winrt::Windows::Graphics::Capture::GraphicsCaptureItem const&,
     winrt::Windows::Foundation::IInspectable const&) {
-  OutputDebugStringW(L"WgcSessionImpl::OnClosed");
+  std::lock_guard locker(lock_);
+  try {
+    CleanUp();
+    is_initialized_ = false;
+    if (Initialize() == 0) {
+      int ret = Start(last_show_cursor_);
+      if (ret == 0) {
+        OutputDebugStringW(L"WgcSessionImpl::OnClosed: auto recovered");
+      } else {
+        OutputDebugStringW(L"WgcSessionImpl::OnClosed: recover Start failed");
+      }
+    } else {
+      OutputDebugStringW(
+          L"WgcSessionImpl::OnClosed: recover Initialize failed");
+    }
+  } catch (...) {
+    OutputDebugStringW(L"WgcSessionImpl::OnClosed: exception during recover");
+  }
 }
 
 int WgcSessionImpl::Initialize() {
@@ -313,7 +340,7 @@ int WgcSessionImpl::Initialize() {
     d3d11_device->GetImmediateContext(d3d11_device_context_.put());
 
   } catch (winrt::hresult_error) {
-    std::cout << "AE_WGC_CREATE_CAPTURER_FAILED" << std::endl;
+    LOG_ERROR("AE_WGC_CREATE_CAPTURER_FAILED");
     return 86;
   } catch (...) {
     return 86;
@@ -378,4 +405,4 @@ LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param,
 //   ::CloseWindow(hwnd_);
 //   ::DestroyWindow(hwnd_);
 // }
-}  // namespace crossdesk
+}  // namespace crossdesk

src/screen_capturer/windows/wgc_session_impl.h

@@ -79,6 +79,7 @@ class WgcSessionImpl : public WgcSession {
   bool is_initialized_ = false;
   bool is_running_ = false;
   bool is_paused_ = false;
+  bool last_show_cursor_ = false;
 
   wgc_session_observer* observer_ = nullptr;
 
@@ -116,4 +117,4 @@ class WgcSessionImpl : public WgcSession {
 //   return result;
 // }
 }  // namespace crossdesk
-#endif
+#endif

xmake.lua

@@ -39,7 +39,7 @@ if is_os("windows") then
     add_requires("libyuv", "miniaudio 0.11.21")
     add_links("Shell32", "windowsapp", "dwmapi", "User32", "kernel32",
         "SDL3-static", "gdi32", "winmm", "setupapi", "version",
-        "Imm32", "iphlpapi")
+        "Imm32", "iphlpapi", "d3d11", "dxgi")
     add_cxflags("/WX")
     set_runtimes("MT")
 elseif is_os("linux") then