YangWX/crossdesk
1
0
Fork 0
mirror of https://github.com/kunkundi/crossdesk.git synced 2026-04-07 10:25:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

[fix] fix Wayland reconnect black screen by keeping capturer warm and also fix Wayland mouse control

Browse Source
This commit is contained in:
dijunkun
2026-03-23 05:18:56 +08:00
parent 518e1afa58
commit 511831ced3
17 changed files with 2418 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/screen_capturer/linux/screen_capturer_linux.cpp
View File

@@ -6,6 +6,7 @@
#include <string>
#include <utility>
#include "platform.h"
#include "rd_log.h"
#if defined(CROSSDESK_HAS_DRM) && CROSSDESK_HAS_DRM
#include "screen_capturer_drm.h"
@@ -19,16 +20,6 @@ namespace crossdesk {
namespace {
bool IsWaylandSession() {
const char* session_type = getenv("XDG_SESSION_TYPE");
if (session_type && strcmp(session_type, "wayland") == 0) {
return true;
}
const char* wayland_display = getenv("WAYLAND_DISPLAY");
return wayland_display && wayland_display[0] != '\0';
}
#if defined(CROSSDESK_HAS_DRM) && CROSSDESK_HAS_DRM
constexpr bool kDrmBuildEnabled = true;
#else
@@ -162,6 +153,16 @@ int ScreenCapturerLinux::Start(bool show_cursor) {
return -1;
}
#if defined(CROSSDESK_HAS_WAYLAND_CAPTURER) && CROSSDESK_HAS_WAYLAND_CAPTURER
if (backend_ == BackendType::kWayland) {
const int refresh_ret = RefreshWaylandBackend();
if (refresh_ret != 0) {
LOG_WARN("Linux screen capturer Wayland backend refresh failed: {}",
refresh_ret);
}
}
#endif
const int ret = impl_->Start(show_cursor);
if (ret == 0) {
return 0;
@@ -211,7 +212,9 @@ int ScreenCapturerLinux::Stop() {
if (!impl_) {
return 0;
}
return impl_->Stop();
const int ret = impl_->Stop();
UpdateAliasesFromBackend(impl_.get());
return ret;
}
int ScreenCapturerLinux::Pause(int monitor_index) {
@@ -243,16 +246,19 @@ int ScreenCapturerLinux::ResetToInitialMonitor() {
}
std::vector<DisplayInfo> ScreenCapturerLinux::GetDisplayInfoList() {
{
std::lock_guard<std::mutex> lock(alias_mutex_);
if (!canonical_displays_.empty()) {
return canonical_displays_;
}
}
if (!impl_) {
return std::vector<DisplayInfo>();
}
// Wayland backend may update display geometry/stream handle asynchronously
// after Start(). Refresh aliases every time to keep canonical displays fresh.
UpdateAliasesFromBackend(impl_.get());
std::lock_guard<std::mutex> lock(alias_mutex_);
if (!canonical_displays_.empty()) {
return canonical_displays_;
}
return impl_->GetDisplayInfoList();
}
@@ -314,6 +320,29 @@ int ScreenCapturerLinux::InitWayland() {
#endif
}
int ScreenCapturerLinux::RefreshWaylandBackend() {
#if defined(CROSSDESK_HAS_WAYLAND_CAPTURER) && CROSSDESK_HAS_WAYLAND_CAPTURER
auto backend = std::make_unique<ScreenCapturerWayland>();
const int ret = backend->Init(fps_, callback_);
if (ret != 0) {
backend->Destroy();
return ret;
}
if (impl_) {
impl_->Destroy();
}
UpdateAliasesFromBackend(backend.get());
impl_ = std::move(backend);
backend_ = BackendType::kWayland;
LOG_INFO("Linux screen capturer Wayland backend refreshed before start");
return 0;
#else
return -1;
#endif
}
bool ScreenCapturerLinux::TryFallbackToDrm(bool show_cursor) {
#if defined(CROSSDESK_HAS_DRM) && CROSSDESK_HAS_DRM
auto drm_backend = std::make_unique<ScreenCapturerDrm>();
@@ -443,6 +472,8 @@ void ScreenCapturerLinux::UpdateAliasesFromBackend(ScreenCapturer* backend) {
if (i < canonical_displays_.size()) {
// Keep original stable names, but refresh geometry from active backend.
canonical_displays_[i].handle = backend_displays[i].handle;
canonical_displays_[i].is_primary = backend_displays[i].is_primary;
canonical_displays_[i].left = backend_displays[i].left;
canonical_displays_[i].top = backend_displays[i].top;
canonical_displays_[i].right = backend_displays[i].right;

1
src/screen_capturer/linux/screen_capturer_linux.h
View File

@@ -43,6 +43,7 @@ class ScreenCapturerLinux : public ScreenCapturer {
int InitX11();
int InitDrm();
int InitWayland();
int RefreshWaylandBackend();
bool TryFallbackToDrm(bool show_cursor);
bool TryFallbackToX11(bool show_cursor);
bool TryFallbackToWayland(bool show_cursor);

119
src/screen_capturer/linux/screen_capturer_wayland.cpp
View File

@@ -12,22 +12,27 @@
#include <chrono>
#include <thread>
#include "platform.h"
#include "rd_log.h"
#include "wayland_portal_shared.h"
namespace crossdesk {
namespace {
bool IsWaylandSession() {
const char* session_type = getenv("XDG_SESSION_TYPE");
if (session_type && strcmp(session_type, "wayland") == 0) {
return true;
}
const char* wayland_display = getenv("WAYLAND_DISPLAY");
return wayland_display && wayland_display[0] != '\0';
int64_t NowMs() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
struct PipeWireRecoveryConfig {
ScreenCapturerWayland::PipeWireConnectMode mode;
bool relaxed_connect = false;
};
constexpr auto kPipeWireCloseSettleDelay = std::chrono::milliseconds(200);
} // namespace
ScreenCapturerWayland::ScreenCapturerWayland() {}
@@ -54,6 +59,8 @@ int ScreenCapturerWayland::Init(const int fps, cb_desktop_data cb) {
fps_ = fps;
callback_ = cb;
pointer_granted_ = false;
shared_session_registered_ = false;
display_info_list_.clear();
display_info_list_.push_back(
DisplayInfo(display_name_, 0, 0, kFallbackWidth, kFallbackHeight));
@@ -62,6 +69,8 @@ int ScreenCapturerWayland::Init(const int fps, cb_desktop_data cb) {
frame_width_ = kFallbackWidth;
frame_height_ = kFallbackHeight;
frame_stride_ = kFallbackWidth * 4;
logical_width_ = kFallbackWidth;
logical_height_ = kFallbackHeight;
y_plane_.resize(kFallbackWidth * kFallbackHeight);
uv_plane_.resize((kFallbackWidth / 2) * (kFallbackHeight / 2) * 2);
@@ -84,6 +93,13 @@ int ScreenCapturerWayland::Start(bool show_cursor) {
show_cursor_ = show_cursor;
paused_ = false;
pipewire_node_id_ = 0;
UpdateDisplayGeometry(logical_width_ > 0 ? logical_width_ : kFallbackWidth,
logical_height_ > 0 ? logical_height_
: kFallbackHeight);
pipewire_format_ready_.store(false);
pipewire_stream_start_ms_.store(0);
pipewire_last_frame_ms_.store(0);
running_ = true;
thread_ = std::thread([this]() { Run(); });
return 0;
@@ -94,6 +110,10 @@ int ScreenCapturerWayland::Stop() {
if (thread_.joinable()) {
thread_.join();
}
pipewire_node_id_ = 0;
UpdateDisplayGeometry(logical_width_ > 0 ? logical_width_ : kFallbackWidth,
logical_height_ > 0 ? logical_height_
: kFallbackHeight);
return 0;
}
@@ -127,23 +147,96 @@ std::vector<DisplayInfo> ScreenCapturerWayland::GetDisplayInfoList() {
}
void ScreenCapturerWayland::Run() {
if (!ConnectSessionBus() || !CreatePortalSession() || !SelectPortalSource() ||
!StartPortalSession() || !OpenPipeWireRemote() ||
!SetupPipeWireStream()) {
static constexpr PipeWireRecoveryConfig kRecoveryConfigs[] = {
{PipeWireConnectMode::kTargetObject, false},
{PipeWireConnectMode::kAny, true},
{PipeWireConnectMode::kNodeId, false},
{PipeWireConnectMode::kNodeId, true},
};
int recovery_index = 0;
auto setup_pipewire = [this, &recovery_index]() -> bool {
const auto& config = kRecoveryConfigs[recovery_index];
return OpenPipeWireRemote() &&
SetupPipeWireStream(config.relaxed_connect, config.mode);
};
auto setup_pipeline = [this, &setup_pipewire]() -> bool {
return ConnectSessionBus() && CreatePortalSession() &&
SelectPortalDevices() && SelectPortalSource() &&
StartPortalSession() && setup_pipewire();
};
if (!setup_pipeline()) {
running_ = false;
CleanupPipeWire();
ClosePortalSession();
CleanupDbus();
return;
}
while (running_) {
if (!paused_) {
const int64_t now = NowMs();
const int64_t stream_start = pipewire_stream_start_ms_.load();
const int64_t last_frame = pipewire_last_frame_ms_.load();
const bool format_ready = pipewire_format_ready_.load();
const bool format_timeout =
stream_start > 0 && !format_ready && (now - stream_start) > 1200;
const bool first_frame_timeout =
stream_start > 0 && format_ready && last_frame == 0 &&
(now - stream_start) > 4000;
const bool frame_stall = last_frame > 0 && (now - last_frame) > 5000;
if (format_timeout || first_frame_timeout || frame_stall) {
if (recovery_index + 1 >=
static_cast<int>(sizeof(kRecoveryConfigs) /
sizeof(kRecoveryConfigs[0]))) {
LOG_ERROR(
"Wayland capture stalled and recovery limit reached, "
"format_ready={}, stream_start={}, last_frame={}, attempts={}",
format_ready, stream_start, last_frame, recovery_index);
running_ = false;
break;
}
++recovery_index;
const char* reason = format_timeout
? "format-timeout"
: (first_frame_timeout ? "first-frame-timeout"
: "frame-stall");
const auto& config = kRecoveryConfigs[recovery_index];
LOG_WARN(
"Wayland capture stalled ({}) - retrying PipeWire only, "
"attempt {}/{}, mode={}, relaxed_connect={}",
reason, recovery_index,
static_cast<int>(sizeof(kRecoveryConfigs) /
sizeof(kRecoveryConfigs[0])) -
1,
config.mode == PipeWireConnectMode::kTargetObject
? "target-object"
: (config.mode == PipeWireConnectMode::kNodeId ? "node-id"
: "any"),
config.relaxed_connect);
CleanupPipeWire();
if (!setup_pipewire()) {
LOG_ERROR("Wayland PipeWire-only recovery failed at attempt {}",
recovery_index);
running_ = false;
break;
}
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
CleanupPipeWire();
if (!session_handle_.empty()) {
std::this_thread::sleep_for(kPipeWireCloseSettleDelay);
}
ClosePortalSession();
CleanupDbus();
}
} // namespace crossdesk
} // namespace crossdesk

13
src/screen_capturer/linux/screen_capturer_wayland.h
View File

@@ -24,6 +24,9 @@ struct pw_thread_loop;
namespace crossdesk {
class ScreenCapturerWayland : public ScreenCapturer {
public:
enum class PipeWireConnectMode { kTargetObject, kNodeId, kAny };
public:
ScreenCapturerWayland();
~ScreenCapturerWayland();
@@ -46,10 +49,11 @@ class ScreenCapturerWayland : public ScreenCapturer {
bool CheckPortalAvailability() const;
bool ConnectSessionBus();
bool CreatePortalSession();
bool SelectPortalDevices();
bool SelectPortalSource();
bool StartPortalSession();
bool OpenPipeWireRemote();
bool SetupPipeWireStream();
bool SetupPipeWireStream(bool relaxed_connect, PipeWireConnectMode mode);
void Run();
void CleanupPipeWire();
@@ -66,6 +70,9 @@ class ScreenCapturerWayland : public ScreenCapturer {
std::atomic<bool> running_{false};
std::atomic<bool> paused_{false};
std::atomic<int> monitor_index_{0};
std::atomic<bool> pipewire_format_ready_{false};
std::atomic<int64_t> pipewire_stream_start_ms_{0};
std::atomic<int64_t> pipewire_last_frame_ms_{0};
int initial_monitor_index_ = 0;
std::atomic<bool> show_cursor_{true};
int fps_ = 60;
@@ -85,10 +92,14 @@ class ScreenCapturerWayland : public ScreenCapturer {
void* stream_listener_ = nullptr;
bool pipewire_initialized_ = false;
bool pipewire_thread_loop_started_ = false;
bool pointer_granted_ = false;
bool shared_session_registered_ = false;
uint32_t spa_video_format_ = 0;
int frame_width_ = 0;
int frame_height_ = 0;
int frame_stride_ = 0;
int logical_width_ = 0;
int logical_height_ = 0;
std::vector<uint8_t> y_plane_;
std::vector<uint8_t> uv_plane_;

16
src/screen_capturer/linux/screen_capturer_wayland_build.h
View File

@@ -16,11 +16,27 @@
#include <pipewire/pipewire.h>
#include <pipewire/stream.h>
#include <pipewire/thread-loop.h>
#include <spa/param/param.h>
#include <spa/param/format-utils.h>
#include <spa/param/video/format-utils.h>
#include <spa/param/video/raw.h>
#include <spa/buffer/meta.h>
#include <spa/utils/result.h>
#if defined(__has_include)
#if __has_include(<spa/param/buffers.h>)
#include <spa/param/buffers.h>
#endif
#endif
#define CROSSDESK_SPA_PARAM_BUFFERS_BUFFERS 1u
#define CROSSDESK_SPA_PARAM_BUFFERS_BLOCKS 2u
#define CROSSDESK_SPA_PARAM_BUFFERS_SIZE 3u
#define CROSSDESK_SPA_PARAM_BUFFERS_STRIDE 4u
#define CROSSDESK_SPA_PARAM_META_TYPE 1u
#define CROSSDESK_SPA_PARAM_META_SIZE 2u
#else
#define CROSSDESK_WAYLAND_BUILD_ENABLED 0

350
src/screen_capturer/linux/screen_capturer_wayland_pipewire.cpp
View File

@@ -4,6 +4,7 @@
#if CROSSDESK_WAYLAND_BUILD_ENABLED
#include <chrono>
#include <cstdint>
#include <thread>
#include <unistd.h>
@@ -23,14 +24,154 @@ const char* PipeWireFormatName(uint32_t spa_format) {
return "BGRx";
case SPA_VIDEO_FORMAT_BGRA:
return "BGRA";
#ifdef SPA_VIDEO_FORMAT_RGBx
case SPA_VIDEO_FORMAT_RGBx:
return "RGBx";
#endif
#ifdef SPA_VIDEO_FORMAT_RGBA
case SPA_VIDEO_FORMAT_RGBA:
return "RGBA";
#endif
default:
return "unsupported";
}
}
const char* PipeWireConnectModeName(
ScreenCapturerWayland::PipeWireConnectMode mode) {
switch (mode) {
case ScreenCapturerWayland::PipeWireConnectMode::kTargetObject:
return "target-object";
case ScreenCapturerWayland::PipeWireConnectMode::kNodeId:
return "node-id";
case ScreenCapturerWayland::PipeWireConnectMode::kAny:
return "any";
default:
return "unknown";
}
}
int64_t NowMs() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now().time_since_epoch())
.count();
}
struct PipeWireTargetLookupState {
pw_thread_loop* loop = nullptr;
uint32_t target_node_id = 0;
int sync_seq = -1;
bool done = false;
bool found = false;
std::string object_serial;
};
std::string LookupPipeWireTargetObjectSerial(pw_core* core,
pw_thread_loop* loop,
uint32_t node_id) {
if (!core || !loop || node_id == 0) {
return "";
}
PipeWireTargetLookupState state;
state.loop = loop;
state.target_node_id = node_id;
pw_registry* registry = pw_core_get_registry(core, PW_VERSION_REGISTRY, 0);
if (!registry) {
return "";
}
spa_hook registry_listener{};
spa_hook core_listener{};
pw_registry_events registry_events{};
registry_events.version = PW_VERSION_REGISTRY_EVENTS;
registry_events.global =
[](void* userdata, uint32_t id, uint32_t permissions, const char* type,
uint32_t version, const spa_dict* props) {
(void)permissions;
(void)version;
auto* state = static_cast<PipeWireTargetLookupState*>(userdata);
if (!state || !props || id != state->target_node_id || !type) {
return;
}
if (strcmp(type, PW_TYPE_INTERFACE_Node) != 0) {
return;
}
const char* object_serial = spa_dict_lookup(props, PW_KEY_OBJECT_SERIAL);
if (!object_serial || object_serial[0] == '\0') {
object_serial = spa_dict_lookup(props, "object.serial");
}
if (!object_serial || object_serial[0] == '\0') {
return;
}
state->object_serial = object_serial;
state->found = true;
};
pw_core_events core_events{};
core_events.version = PW_VERSION_CORE_EVENTS;
core_events.done = [](void* userdata, uint32_t id, int seq) {
auto* state = static_cast<PipeWireTargetLookupState*>(userdata);
if (!state || id != PW_ID_CORE || seq != state->sync_seq) {
return;
}
state->done = true;
pw_thread_loop_signal(state->loop, false);
};
core_events.error = [](void* userdata, uint32_t id, int seq, int res,
const char* message) {
(void)id;
(void)seq;
(void)res;
auto* state = static_cast<PipeWireTargetLookupState*>(userdata);
if (!state) {
return;
}
LOG_WARN("PipeWire registry lookup error: {}",
message ? message : "unknown");
state->done = true;
pw_thread_loop_signal(state->loop, false);
};
pw_registry_add_listener(registry, &registry_listener, &registry_events,
&state);
pw_core_add_listener(core, &core_listener, &core_events, &state);
state.sync_seq = pw_core_sync(core, PW_ID_CORE, 0);
while (!state.done) {
pw_thread_loop_wait(loop);
}
spa_hook_remove(&registry_listener);
spa_hook_remove(&core_listener);
pw_proxy_destroy(reinterpret_cast<pw_proxy*>(registry));
return state.found ? state.object_serial : "";
}
int BytesPerPixel(uint32_t spa_format) {
switch (spa_format) {
case SPA_VIDEO_FORMAT_BGRx:
case SPA_VIDEO_FORMAT_BGRA:
#ifdef SPA_VIDEO_FORMAT_RGBx
case SPA_VIDEO_FORMAT_RGBx:
#endif
#ifdef SPA_VIDEO_FORMAT_RGBA
case SPA_VIDEO_FORMAT_RGBA:
#endif
return 4;
default:
return 0;
}
}
} // namespace
bool ScreenCapturerWayland::SetupPipeWireStream() {
bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
PipeWireConnectMode mode) {
if (pipewire_fd_ < 0 || pipewire_node_id_ == 0) {
return false;
}
@@ -73,10 +214,35 @@ bool ScreenCapturerWayland::SetupPipeWireStream() {
}
pipewire_fd_ = -1;
pw_stream_ = pw_stream_new(
pw_core_, "CrossDesk Wayland Capture",
pw_properties* stream_props =
pw_properties_new(PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY,
"Capture", PW_KEY_MEDIA_ROLE, "Screen", nullptr));
"Capture", PW_KEY_MEDIA_ROLE, "Screen", nullptr);
if (!stream_props) {
LOG_ERROR("Failed to allocate PipeWire stream properties");
pw_thread_loop_unlock(pw_thread_loop_);
CleanupPipeWire();
return false;
}
std::string target_object_serial;
if (mode == PipeWireConnectMode::kTargetObject) {
target_object_serial =
LookupPipeWireTargetObjectSerial(pw_core_, pw_thread_loop_,
pipewire_node_id_);
if (!target_object_serial.empty()) {
pw_properties_set(stream_props, PW_KEY_TARGET_OBJECT,
target_object_serial.c_str());
LOG_INFO("PipeWire target object serial for node {} is {}",
pipewire_node_id_, target_object_serial);
} else {
LOG_WARN("PipeWire target object serial lookup failed for node {}, "
"falling back to direct target id in target-object mode",
pipewire_node_id_);
}
}
pw_stream_ = pw_stream_new(pw_core_, "CrossDesk Wayland Capture",
stream_props);
if (!pw_stream_) {
LOG_ERROR("Failed to create PipeWire stream");
pw_thread_loop_unlock(pw_thread_loop_);
@@ -108,6 +274,7 @@ bool ScreenCapturerWayland::SetupPipeWireStream() {
LOG_INFO("PipeWire stream state: {} -> {}",
pw_stream_state_as_string(old_state),
pw_stream_state_as_string(state));
};
events.param_changed =
[](void* userdata, uint32_t id, const struct spa_pod* param) {
@@ -127,18 +294,84 @@ bool ScreenCapturerWayland::SetupPipeWireStream() {
self->frame_height_ = static_cast<int>(info.size.height);
self->frame_stride_ = static_cast<int>(info.size.width) * 4;
if (self->spa_video_format_ != SPA_VIDEO_FORMAT_BGRx &&
self->spa_video_format_ != SPA_VIDEO_FORMAT_BGRA) {
bool supported_format =
(self->spa_video_format_ == SPA_VIDEO_FORMAT_BGRx) ||
(self->spa_video_format_ == SPA_VIDEO_FORMAT_BGRA);
#ifdef SPA_VIDEO_FORMAT_RGBx
supported_format =
supported_format ||
(self->spa_video_format_ == SPA_VIDEO_FORMAT_RGBx);
#endif
#ifdef SPA_VIDEO_FORMAT_RGBA
supported_format =
supported_format ||
(self->spa_video_format_ == SPA_VIDEO_FORMAT_RGBA);
#endif
if (!supported_format) {
LOG_ERROR("Unsupported PipeWire pixel format: {}",
PipeWireFormatName(self->spa_video_format_));
self->running_ = false;
return;
}
self->UpdateDisplayGeometry(self->frame_width_, self->frame_height_);
LOG_INFO("PipeWire video format: {}, {}x{}",
const int bytes_per_pixel = BytesPerPixel(self->spa_video_format_);
if (bytes_per_pixel <= 0 || self->frame_width_ <= 0 ||
self->frame_height_ <= 0) {
LOG_ERROR("Invalid PipeWire frame layout: format={}, size={}x{}",
PipeWireFormatName(self->spa_video_format_),
self->frame_width_, self->frame_height_);
self->running_ = false;
return;
}
self->frame_stride_ = self->frame_width_ * bytes_per_pixel;
uint8_t buffer[1024];
spa_pod_builder builder = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
const spa_pod* params[2];
uint32_t param_count = 0;
params[param_count++] = reinterpret_cast<const spa_pod*>(
spa_pod_builder_add_object(
&builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
CROSSDESK_SPA_PARAM_BUFFERS_BUFFERS,
SPA_POD_CHOICE_RANGE_Int(8, 4, 16),
CROSSDESK_SPA_PARAM_BUFFERS_BLOCKS, SPA_POD_Int(1),
CROSSDESK_SPA_PARAM_BUFFERS_SIZE,
SPA_POD_CHOICE_RANGE_Int(self->frame_stride_ *
self->frame_height_,
self->frame_stride_ *
self->frame_height_,
self->frame_stride_ *
self->frame_height_),
CROSSDESK_SPA_PARAM_BUFFERS_STRIDE,
SPA_POD_CHOICE_RANGE_Int(self->frame_stride_,
self->frame_stride_,
self->frame_stride_)));
params[param_count++] = reinterpret_cast<const spa_pod*>(
spa_pod_builder_add_object(
&builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
CROSSDESK_SPA_PARAM_META_TYPE, SPA_POD_Id(SPA_META_Header),
CROSSDESK_SPA_PARAM_META_SIZE,
SPA_POD_Int(sizeof(struct spa_meta_header))));
if (self->pw_stream_) {
pw_stream_update_params(self->pw_stream_, params, param_count);
}
self->pipewire_format_ready_.store(true);
const int pointer_width =
self->logical_width_ > 0 ? self->logical_width_ : self->frame_width_;
const int pointer_height = self->logical_height_ > 0
? self->logical_height_
: self->frame_height_;
self->UpdateDisplayGeometry(pointer_width, pointer_height);
LOG_INFO(
"PipeWire video format: {}, {}x{} stride={} (pointer space {}x{})",
PipeWireFormatName(self->spa_video_format_),
self->frame_width_, self->frame_height_);
self->frame_width_, self->frame_height_, self->frame_stride_,
pointer_width, pointer_height);
};
events.process = [](void* userdata) {
auto* self = static_cast<ScreenCapturerWayland*>(userdata);
@@ -150,29 +383,74 @@ bool ScreenCapturerWayland::SetupPipeWireStream() {
}();
pw_stream_add_listener(pw_stream_, listener, &stream_events, this);
pipewire_format_ready_.store(false);
pipewire_stream_start_ms_.store(NowMs());
pipewire_last_frame_ms_.store(0);
uint8_t buffer[1024];
uint8_t buffer[4096];
spa_pod_builder builder = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
const spa_pod* params[1];
const spa_rectangle min_size{1, 1};
const spa_rectangle max_size{8192, 8192};
const spa_rectangle default_size{kFallbackWidth, kFallbackHeight};
const spa_fraction any_rate{0, 1};
const spa_pod* params[8];
int param_count = 0;
const spa_rectangle fixed_size{
static_cast<uint32_t>(logical_width_ > 0 ? logical_width_ : kFallbackWidth),
static_cast<uint32_t>(logical_height_ > 0 ? logical_height_
: kFallbackHeight)};
const spa_rectangle min_size{1u, 1u};
const spa_rectangle max_size{16384u, 16384u};
params[0] = reinterpret_cast<const spa_pod*>(spa_pod_builder_add_object(
&builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_Id(SPA_VIDEO_FORMAT_BGRx),
SPA_FORMAT_VIDEO_size,
SPA_POD_CHOICE_RANGE_Rectangle(&default_size, &min_size, &max_size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&any_rate)));
if (!relaxed_connect) {
auto add_format_param = [&](uint32_t spa_format) {
if (param_count >= static_cast<int>(sizeof(params) / sizeof(params[0]))) {
return;
}
params[param_count++] =
reinterpret_cast<const spa_pod*>(spa_pod_builder_add_object(
&builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_Id(spa_format),
SPA_FORMAT_VIDEO_size,
SPA_POD_CHOICE_RANGE_Rectangle(&fixed_size, &min_size,
&max_size)));
};
add_format_param(SPA_VIDEO_FORMAT_BGRx);
add_format_param(SPA_VIDEO_FORMAT_BGRA);
#ifdef SPA_VIDEO_FORMAT_RGBx
add_format_param(SPA_VIDEO_FORMAT_RGBx);
#endif
#ifdef SPA_VIDEO_FORMAT_RGBA
add_format_param(SPA_VIDEO_FORMAT_RGBA);
#endif
if (param_count == 0) {
LOG_ERROR("No valid PipeWire format params were built");
pw_thread_loop_unlock(pw_thread_loop_);
CleanupPipeWire();
return false;
}
} else {
LOG_INFO("PipeWire stream using relaxed format negotiation");
}
uint32_t target_id = PW_ID_ANY;
if (mode == PipeWireConnectMode::kNodeId ||
(mode == PipeWireConnectMode::kTargetObject &&
target_object_serial.empty())) {
target_id = pipewire_node_id_;
}
LOG_INFO(
"PipeWire connecting stream: mode={}, node_id={}, target_id={}, "
"target_object_serial={}, relaxed_connect={}, param_count={}, "
"requested_size={}x{}",
PipeWireConnectModeName(mode), pipewire_node_id_, target_id,
target_object_serial.empty() ? "none" : target_object_serial.c_str(),
relaxed_connect, param_count, fixed_size.width, fixed_size.height);
const int ret = pw_stream_connect(
pw_stream_, PW_DIRECTION_INPUT, pipewire_node_id_,
pw_stream_, PW_DIRECTION_INPUT, target_id,
static_cast<pw_stream_flags>(PW_STREAM_FLAG_AUTOCONNECT |
PW_STREAM_FLAG_MAP_BUFFERS),
params, 1);
param_count > 0 ? params : nullptr, static_cast<uint32_t>(param_count));
pw_thread_loop_unlock(pw_thread_loop_);
if (ret < 0) {
@@ -193,16 +471,21 @@ void ScreenCapturerWayland::CleanupPipeWire() {
}
if (pw_stream_) {
pw_stream_set_active(pw_stream_, false);
pw_stream_disconnect(pw_stream_);
pw_stream_destroy(pw_stream_);
pw_stream_ = nullptr;
}
if (stream_listener_) {
spa_hook_remove(static_cast<spa_hook*>(stream_listener_));
delete static_cast<spa_hook*>(stream_listener_);
stream_listener_ = nullptr;
}
if (pw_stream_) {
pw_stream_destroy(pw_stream_);
pw_stream_ = nullptr;
}
if (pw_core_) {
pw_core_disconnect(pw_core_);
pw_core_ = nullptr;
@@ -231,6 +514,10 @@ void ScreenCapturerWayland::CleanupPipeWire() {
pipewire_fd_ = -1;
}
pipewire_format_ready_.store(false);
pipewire_stream_start_ms_.store(0);
pipewire_last_frame_ms_.store(0);
if (pipewire_initialized_) {
pw_deinit();
pipewire_initialized_ = false;
@@ -309,6 +596,7 @@ void ScreenCapturerWayland::HandlePipeWireBuffer() {
callback_(nv12.data(), static_cast<int>(nv12.size()), even_width,
even_height, display_name_.c_str());
}
pipewire_last_frame_ms_.store(NowMs());
requeue();
}
@@ -318,15 +606,17 @@ void ScreenCapturerWayland::UpdateDisplayGeometry(int width, int height) {
return;
}
frame_width_ = width;
frame_height_ = height;
void* stream_handle =
reinterpret_cast<void*>(static_cast<uintptr_t>(pipewire_node_id_));
if (display_info_list_.empty()) {
display_info_list_.push_back(DisplayInfo(display_name_, 0, 0, width, height));
display_info_list_.push_back(
DisplayInfo(stream_handle, display_name_, true, 0, 0, width, height));
return;
}
auto& display = display_info_list_[0];
display.handle = stream_handle;
display.left = 0;
display.top = 0;
display.right = width;

227
src/screen_capturer/linux/screen_capturer_wayland_portal.cpp
View File

@@ -1,6 +1,7 @@
#include "screen_capturer_wayland.h"
#include "screen_capturer_wayland_build.h"
#include "wayland_portal_shared.h"
#if CROSSDESK_WAYLAND_BUILD_ENABLED
@@ -18,6 +19,8 @@ namespace {
constexpr const char* kPortalBusName = "org.freedesktop.portal.Desktop";
constexpr const char* kPortalObjectPath = "/org/freedesktop/portal/desktop";
constexpr const char* kPortalRemoteDesktopInterface =
"org.freedesktop.portal.RemoteDesktop";
constexpr const char* kPortalScreenCastInterface =
"org.freedesktop.portal.ScreenCast";
constexpr const char* kPortalRequestInterface =
@@ -32,6 +35,7 @@ constexpr const char* kPortalSessionPathPrefix =
constexpr uint32_t kScreenCastSourceMonitor = 1u;
constexpr uint32_t kCursorModeHidden = 1u;
constexpr uint32_t kCursorModeEmbedded = 2u;
constexpr uint32_t kRemoteDesktopDevicePointer = 2u;
std::string MakeToken(const char* prefix) {
const auto now = std::chrono::steady_clock::now().time_since_epoch().count();
@@ -279,19 +283,21 @@ bool ExtractPortalResponse(DBusMessage* message, uint32_t* response_code,
}
bool SendPortalRequestAndHandleResponse(
DBusConnection* connection, const char* method_name,
DBusConnection* connection, const char* interface_name,
const char* method_name,
const char* action_name,
const std::function<bool(DBusMessage*)>& append_message_args,
const std::atomic<bool>& running,
const std::function<bool(uint32_t, DBusMessageIter*)>& handle_results,
std::string* request_path_out = nullptr) {
if (!connection || !method_name || method_name[0] == '\0') {
if (!connection || !interface_name || interface_name[0] == '\0' ||
!method_name || method_name[0] == '\0') {
return false;
}
DBusMessage* message =
dbus_message_new_method_call(kPortalBusName, kPortalObjectPath,
kPortalScreenCastInterface, method_name);
interface_name, method_name);
if (!message) {
LOG_ERROR("Failed to allocate {} message", method_name);
return false;
@@ -399,7 +405,8 @@ bool ScreenCapturerWayland::CreatePortalSession() {
const std::string session_handle_token = MakeToken("crossdesk_session");
std::string request_path;
const bool ok = SendPortalRequestAndHandleResponse(
dbus_connection_, "CreateSession", "CreateSession",
dbus_connection_, kPortalRemoteDesktopInterface, "CreateSession",
"CreateSession",
[&](DBusMessage* message) {
DBusMessageIter iter;
DBusMessageIter options;
@@ -478,7 +485,8 @@ bool ScreenCapturerWayland::SelectPortalSource() {
const char* session_handle = session_handle_.c_str();
return SendPortalRequestAndHandleResponse(
dbus_connection_, "SelectSources", "SelectSources",
dbus_connection_, kPortalScreenCastInterface, "SelectSources",
"SelectSources",
[&](DBusMessage* message) {
DBusMessageIter iter;
DBusMessageIter options;
@@ -507,6 +515,39 @@ bool ScreenCapturerWayland::SelectPortalSource() {
});
}
bool ScreenCapturerWayland::SelectPortalDevices() {
if (!dbus_connection_ || session_handle_.empty()) {
return false;
}
const char* session_handle = session_handle_.c_str();
return SendPortalRequestAndHandleResponse(
dbus_connection_, kPortalRemoteDesktopInterface, "SelectDevices",
"SelectDevices",
[&](DBusMessage* message) {
DBusMessageIter iter;
DBusMessageIter options;
dbus_message_iter_init_append(message, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
&session_handle);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}",
&options);
AppendDictEntryUint32(&options, "types", kRemoteDesktopDevicePointer);
AppendDictEntryString(&options, "handle_token",
MakeToken("crossdesk_req"));
dbus_message_iter_close_container(&iter, &options);
return true;
},
running_, [](uint32_t response_code, DBusMessageIter*) {
if (response_code != 0) {
LOG_ERROR("SelectDevices was denied or malformed, response={}",
response_code);
return false;
}
return true;
});
}
bool ScreenCapturerWayland::StartPortalSession() {
if (!dbus_connection_ || session_handle_.empty()) {
return false;
@@ -514,8 +555,9 @@ bool ScreenCapturerWayland::StartPortalSession() {
const char* session_handle = session_handle_.c_str();
const char* parent_window = "";
pointer_granted_ = false;
const bool ok = SendPortalRequestAndHandleResponse(
dbus_connection_, "Start", "Start",
dbus_connection_, kPortalRemoteDesktopInterface, "Start", "Start",
[&](DBusMessage* message) {
DBusMessageIter iter;
DBusMessageIter options;
@@ -536,6 +578,7 @@ bool ScreenCapturerWayland::StartPortalSession() {
return false;
}
uint32_t granted_devices = 0;
DBusMessageIter dict;
dbus_message_iter_recurse(results, &dict);
while (dbus_message_iter_get_arg_type(&dict) != DBUS_TYPE_INVALID) {
@@ -546,55 +589,91 @@ bool ScreenCapturerWayland::StartPortalSession() {
const char* key = nullptr;
dbus_message_iter_get_basic(&entry, &key);
if (key && dbus_message_iter_next(&entry) &&
dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_VARIANT &&
strcmp(key, "streams") == 0) {
dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_VARIANT) {
DBusMessageIter variant;
DBusMessageIter streams;
dbus_message_iter_recurse(&entry, &variant);
dbus_message_iter_recurse(&variant, &streams);
if (dbus_message_iter_get_arg_type(&streams) == DBUS_TYPE_STRUCT) {
DBusMessageIter stream;
dbus_message_iter_recurse(&streams, &stream);
if (dbus_message_iter_get_arg_type(&stream) == DBUS_TYPE_UINT32) {
dbus_message_iter_get_basic(&stream, &pipewire_node_id_);
if (strcmp(key, "devices") == 0) {
int granted_devices_int = 0;
if (ReadIntLike(&variant, &granted_devices_int) &&
granted_devices_int >= 0) {
granted_devices = static_cast<uint32_t>(granted_devices_int);
}
} else if (strcmp(key, "streams") == 0) {
DBusMessageIter streams;
dbus_message_iter_recurse(&variant, &streams);
if (dbus_message_iter_next(&stream) &&
dbus_message_iter_get_arg_type(&stream) == DBUS_TYPE_ARRAY) {
DBusMessageIter props;
dbus_message_iter_recurse(&stream, &props);
while (dbus_message_iter_get_arg_type(&props) !=
DBUS_TYPE_INVALID) {
if (dbus_message_iter_get_arg_type(&props) ==
DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter prop_entry;
dbus_message_iter_recurse(&props, &prop_entry);
if (dbus_message_iter_get_arg_type(&streams) == DBUS_TYPE_STRUCT) {
DBusMessageIter stream;
dbus_message_iter_recurse(&streams, &stream);
const char* prop_key = nullptr;
dbus_message_iter_get_basic(&prop_entry, &prop_key);
if (prop_key && dbus_message_iter_next(&prop_entry) &&
dbus_message_iter_get_arg_type(&prop_entry) ==
DBUS_TYPE_VARIANT &&
strcmp(prop_key, "size") == 0) {
DBusMessageIter prop_variant;
dbus_message_iter_recurse(&prop_entry, &prop_variant);
if (dbus_message_iter_get_arg_type(&prop_variant) ==
DBUS_TYPE_STRUCT) {
DBusMessageIter size_iter;
int width = 0;
int height = 0;
dbus_message_iter_recurse(&prop_variant, &size_iter);
if (ReadIntLike(&size_iter, &width) &&
dbus_message_iter_next(&size_iter) &&
ReadIntLike(&size_iter, &height)) {
UpdateDisplayGeometry(width, height);
if (dbus_message_iter_get_arg_type(&stream) == DBUS_TYPE_UINT32) {
dbus_message_iter_get_basic(&stream, &pipewire_node_id_);
}
if (dbus_message_iter_next(&stream) &&
dbus_message_iter_get_arg_type(&stream) == DBUS_TYPE_ARRAY) {
DBusMessageIter props;
int stream_width = 0;
int stream_height = 0;
int logical_width = 0;
int logical_height = 0;
dbus_message_iter_recurse(&stream, &props);
while (dbus_message_iter_get_arg_type(&props) !=
DBUS_TYPE_INVALID) {
if (dbus_message_iter_get_arg_type(&props) ==
DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter prop_entry;
dbus_message_iter_recurse(&props, &prop_entry);
const char* prop_key = nullptr;
dbus_message_iter_get_basic(&prop_entry, &prop_key);
if (prop_key && dbus_message_iter_next(&prop_entry) &&
dbus_message_iter_get_arg_type(&prop_entry) ==
DBUS_TYPE_VARIANT) {
DBusMessageIter prop_variant;
dbus_message_iter_recurse(&prop_entry, &prop_variant);
if (dbus_message_iter_get_arg_type(&prop_variant) ==
DBUS_TYPE_STRUCT) {
DBusMessageIter size_iter;
int width = 0;
int height = 0;
dbus_message_iter_recurse(&prop_variant, &size_iter);
if (ReadIntLike(&size_iter, &width) &&
dbus_message_iter_next(&size_iter) &&
ReadIntLike(&size_iter, &height)) {
if (strcmp(prop_key, "logical_size") == 0) {
logical_width = width;
logical_height = height;
} else if (strcmp(prop_key, "size") == 0) {
stream_width = width;
stream_height = height;
}
}
}
}
}
dbus_message_iter_next(&props);
}
const int picked_width =
logical_width > 0 ? logical_width : stream_width;
const int picked_height =
logical_height > 0 ? logical_height : stream_height;
LOG_INFO(
"Wayland portal stream geometry: stream_size={}x{}, "
"logical_size={}x{}, pointer_space={}x{}",
stream_width, stream_height, logical_width,
logical_height, picked_width, picked_height);
if (logical_width > 0 && logical_height > 0) {
logical_width_ = logical_width;
logical_height_ = logical_height;
UpdateDisplayGeometry(logical_width_, logical_height_);
} else if (stream_width > 0 && stream_height > 0) {
logical_width_ = stream_width;
logical_height_ = stream_height;
UpdateDisplayGeometry(logical_width_, logical_height_);
}
dbus_message_iter_next(&props);
}
}
}
@@ -603,6 +682,8 @@ bool ScreenCapturerWayland::StartPortalSession() {
dbus_message_iter_next(&dict);
}
pointer_granted_ =
(granted_devices & kRemoteDesktopDevicePointer) != 0;
return true;
});
if (!ok) {
@@ -613,6 +694,18 @@ bool ScreenCapturerWayland::StartPortalSession() {
LOG_ERROR("Start response did not include a PipeWire node id");
return false;
}
if (!pointer_granted_) {
LOG_ERROR("Start response did not grant pointer control");
return false;
}
shared_session_registered_ = PublishSharedWaylandPortalSession(
SharedWaylandPortalSessionInfo{
dbus_connection_, session_handle_, pipewire_node_id_, logical_width_,
logical_height_, pointer_granted_});
if (!shared_session_registered_) {
LOG_WARN("Failed to publish shared Wayland portal session");
}
LOG_INFO("Wayland screencast ready, node_id={}", pipewire_node_id_);
return true;
@@ -683,37 +776,39 @@ void ScreenCapturerWayland::CleanupDbus() {
return;
}
if (shared_session_registered_) {
return;
}
dbus_connection_close(dbus_connection_);
dbus_connection_unref(dbus_connection_);
dbus_connection_ = nullptr;
}
void ScreenCapturerWayland::ClosePortalSession() {
if (!dbus_connection_ || session_handle_.empty()) {
return;
}
DBusMessage* message = dbus_message_new_method_call(
kPortalBusName, session_handle_.c_str(), kPortalSessionInterface,
"Close");
if (message) {
DBusError error;
dbus_error_init(&error);
DBusMessage* reply =
dbus_connection_send_with_reply_and_block(dbus_connection_, message,
1000, &error);
if (!reply && dbus_error_is_set(&error)) {
LogDbusError("Session.Close", &error);
dbus_error_free(&error);
if (shared_session_registered_) {
DBusConnection* close_connection = nullptr;
std::string close_session_handle;
ReleaseSharedWaylandPortalSession(&close_connection, &close_session_handle);
shared_session_registered_ = false;
if (close_connection) {
CloseWaylandPortalSessionAndConnection(close_connection,
close_session_handle,
"Session.Close");
}
if (reply) {
dbus_message_unref(reply);
}
dbus_message_unref(message);
dbus_connection_ = nullptr;
} else if (dbus_connection_ && !session_handle_.empty()) {
CloseWaylandPortalSessionAndConnection(dbus_connection_, session_handle_,
"Session.Close");
dbus_connection_ = nullptr;
}
session_handle_.clear();
pipewire_node_id_ = 0;
UpdateDisplayGeometry(logical_width_ > 0 ? logical_width_ : kFallbackWidth,
logical_height_ > 0 ? logical_height_
: kFallbackHeight);
pointer_granted_ = false;
}
} // namespace crossdesk