From 4cf8e17e92500cf52723edc82c20ff3be609081f Mon Sep 17 00:00:00 2001 From: Guido Urdaneta Date: Fri, 9 Oct 2020 09:02:53 +0000 Subject: [PATCH] Revert "Improve screen sharing with PipeWire on Wayland" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 9b87037073f1811bcdae30967167f30b364e6879. Reason for revert: Causing compile failures that prevent rolling into chrome. See https://ci.chromium.org/p/chromium/builders/try/cast_shell_linux/726007 https://chromium-review.googlesource.com/c/chromium/src/+/2461647 Original change's description: > Improve screen sharing with PipeWire on Wayland > > Currently, sharing a screen or a window on Wayland opens unnecessary > preview dialog on Chromium side, which is then followed by a similar > dialog on xdg-desktop-portal side. The Chromium dialog is useless on > Wayland, as it doesn't show anything. This is because Chromium doesn't > have access to screen content as in case of X11 session. To fix this, we > want to avoid showing the preview dialog in case we find that we run on > Wayland and only pick a screen or a window from the dialog that comes > from xdg-desktop-portal. > > This patch splits BaseCapturerPipeWire class, moving portal related code > into XdgPortalBase, which does all the DBus communication and which is > supposed to be reused by BaseCapturerPipeWire when the user confirms > the dialog from xdg-desktop-portal. The XdgPortalBase is extended to > support multiple calls at once, where each call is identified by Id. > > Relevant change on Chromium side will be in a different review. > > Bug: chromium:682122 > Change-Id: If8afd36da66231eb154cdc00114908ac897ee4cf > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/160649 > Commit-Queue: Tommi > Reviewed-by: Tommi > Reviewed-by: Erik Språng > Cr-Commit-Position: refs/heads/master@{#32342} TBR=mbonadei@webrtc.org,jamiewalch@chromium.org,tommi@webrtc.org,sprang@webrtc.org,tomas.popela@gmail.com,grulja@gmail.com # Not skipping CQ checks because original CL landed > 1 day ago. Bug: chromium:682122 Change-Id: I41518f795e34b84374bc8208b711cfeb0a070578 No-Try: True Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/187352 Commit-Queue: Guido Urdaneta Reviewed-by: Guido Urdaneta Cr-Commit-Position: refs/heads/master@{#32365} --- modules/desktop_capture/BUILD.gn | 39 +- .../desktop_capture_options.cc | 3 - .../desktop_capture/desktop_capture_options.h | 62 +- .../linux/base_capturer_pipewire.cc | 903 ++++++++++++++++-- .../linux/base_capturer_pipewire.h | 151 ++- modules/desktop_capture/linux/pipewire.sigs | 2 - .../desktop_capture/linux/pipewire_base.cc | 500 ---------- modules/desktop_capture/linux/pipewire_base.h | 95 -- .../linux/screen_capturer_pipewire.cc | 29 + .../linux/screen_capturer_pipewire.h | 33 + .../linux/window_capturer_pipewire.cc | 29 + .../linux/window_capturer_pipewire.h | 33 + .../linux/xdg_desktop_portal_base.cc | 813 ---------------- .../linux/xdg_desktop_portal_base.h | 201 ---- .../desktop_capture/screen_capturer_linux.cc | 4 +- .../desktop_capture/window_capturer_linux.cc | 4 +- 16 files changed, 1079 insertions(+), 1822 deletions(-) delete mode 100644 modules/desktop_capture/linux/pipewire_base.cc delete mode 100644 modules/desktop_capture/linux/pipewire_base.h create mode 100644 modules/desktop_capture/linux/screen_capturer_pipewire.cc create mode 100644 modules/desktop_capture/linux/screen_capturer_pipewire.h create mode 100644 modules/desktop_capture/linux/window_capturer_pipewire.cc create mode 100644 modules/desktop_capture/linux/window_capturer_pipewire.h delete mode 100644 modules/desktop_capture/linux/xdg_desktop_portal_base.cc delete mode 100644 modules/desktop_capture/linux/xdg_desktop_portal_base.h diff --git a/modules/desktop_capture/BUILD.gn b/modules/desktop_capture/BUILD.gn index 9bb9f62280..2cb6891c9e 100644 --- a/modules/desktop_capture/BUILD.gn +++ b/modules/desktop_capture/BUILD.gn @@ -76,21 +76,6 @@ if (rtc_include_tests) { "window_finder_unittest.cc", ] public_configs = [ ":x11_config" ] - if (is_linux) { - public_configs += [ ":pipewire_config" ] - if (rtc_use_pipewire) { - configs += [ - ":pipewire_config", - ":gio", - ] - - if (rtc_link_pipewire) { - configs += [ ":pipewire" ] - } else { - deps += [ ":pipewire_stubs" ] - } - } - } if (is_win) { deps += [ "../../rtc_base:win32" ] } @@ -147,21 +132,6 @@ if (rtc_include_tests) { } deps += [ ":desktop_capture_mock" ] public_configs = [ ":x11_config" ] - if (is_linux) { - public_configs += [ ":pipewire_config" ] - if (rtc_use_pipewire) { - configs += [ - ":pipewire_config", - ":gio", - ] - - if (rtc_link_pipewire) { - configs += [ ":pipewire" ] - } else { - deps += [ ":pipewire_stubs" ] - } - } - } } } @@ -526,7 +496,6 @@ rtc_library("desktop_capture_generic") { absl_deps = [ "//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/strings", - "//third_party/abseil-cpp/absl/types:optional", ] if (rtc_use_x11_extensions) { @@ -547,10 +516,10 @@ rtc_library("desktop_capture_generic") { sources += [ "linux/base_capturer_pipewire.cc", "linux/base_capturer_pipewire.h", - "linux/pipewire_base.cc", - "linux/pipewire_base.h", - "linux/xdg_desktop_portal_base.cc", - "linux/xdg_desktop_portal_base.h", + "linux/screen_capturer_pipewire.cc", + "linux/screen_capturer_pipewire.h", + "linux/window_capturer_pipewire.cc", + "linux/window_capturer_pipewire.h", ] configs += [ diff --git a/modules/desktop_capture/desktop_capture_options.cc b/modules/desktop_capture/desktop_capture_options.cc index 5c17dfbbe7..c89896d5fd 100644 --- a/modules/desktop_capture/desktop_capture_options.cc +++ b/modules/desktop_capture/desktop_capture_options.cc @@ -35,9 +35,6 @@ DesktopCaptureOptions DesktopCaptureOptions::CreateDefault() { #if defined(WEBRTC_USE_X11) result.set_x_display(SharedXDisplay::CreateDefault()); #endif -#if defined(WEBRTC_USE_PIPEWIRE) - result.set_xdp_base(XdgDesktopPortalBase::CreateDefault()); -#endif #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) result.set_configuration_monitor(new DesktopConfigurationMonitor()); result.set_full_screen_window_detector( diff --git a/modules/desktop_capture/desktop_capture_options.h b/modules/desktop_capture/desktop_capture_options.h index 5323841a97..521c80b5c5 100644 --- a/modules/desktop_capture/desktop_capture_options.h +++ b/modules/desktop_capture/desktop_capture_options.h @@ -10,7 +10,6 @@ #ifndef MODULES_DESKTOP_CAPTURE_DESKTOP_CAPTURE_OPTIONS_H_ #define MODULES_DESKTOP_CAPTURE_DESKTOP_CAPTURE_OPTIONS_H_ -#include "absl/types/optional.h" #include "api/scoped_refptr.h" #include "rtc_base/system/rtc_export.h" @@ -24,10 +23,6 @@ #include "modules/desktop_capture/full_screen_window_detector.h" -#if defined(WEBRTC_USE_PIPEWIRE) -#include "modules/desktop_capture/linux/xdg_desktop_portal_base.h" -#endif - namespace webrtc { // An object that stores initialization parameters for screen and window @@ -136,68 +131,13 @@ class RTC_EXPORT DesktopCaptureOptions { #if defined(WEBRTC_USE_PIPEWIRE) bool allow_pipewire() const { return allow_pipewire_; } void set_allow_pipewire(bool allow) { allow_pipewire_ = allow; } - - // Provides a way how to identify portal call for a sharing request - // made by the client. This allows to go through the preview dialog - // and to the web page itself with just one xdg-desktop-portal call. - // Client is supposed to: - // 1) Call start_request(id) to tell us an identificator for the current - // request - // 2) Call close_request(id) in case the preview dialog was cancelled - // or user picked a web page to be shared - // Note: In case the current request is not finalized, we will close it for - // safety reasons and client will need to ask the portal again - // This was done primarily for chromium support as there was no way how to - // identify a portal call made for the preview and later on continue with the - // same content on the web page itself. - - void start_request(int32_t request_id) { - // In case we get a duplicit start_request call, which might happen when a - // browser requests both screen and window sharing, we don't want to do - // anything. - if (request_id == xdp_base_->CurrentConnectionId()) { - return; - } - - // In case we are about to start a new request and the previous one is not - // finalized and not stream to the web page itself we will just close it. - if (!xdp_base_->IsConnectionStreamingOnWeb(absl::nullopt) && - xdp_base_->IsConnectionInitialized(absl::nullopt)) { - xdp_base_->CloseConnection(absl::nullopt); - } - - xdp_base_->SetCurrentConnectionId(request_id); - } - - void close_request(int32_t request_id) { - xdp_base_->CloseConnection(request_id); - xdp_base_->SetCurrentConnectionId(absl::nullopt); - } - - absl::optional request_id() { - // Reset request_id in case the connection is in final state, which means it - // is streaming content to the web page itself and nobody should be asking - // again for this ID. - if (xdp_base_->IsConnectionStreamingOnWeb(absl::nullopt)) { - xdp_base_->SetCurrentConnectionId(absl::nullopt); - } - - return xdp_base_->CurrentConnectionId(); - } - - XdgDesktopPortalBase* xdp_base() const { return xdp_base_; } - void set_xdp_base(rtc::scoped_refptr xdp_base) { - xdp_base_ = std::move(xdp_base); - } #endif private: #if defined(WEBRTC_USE_X11) rtc::scoped_refptr x_display_; #endif -#if defined(WEBRTC_USE_PIPEWIRE) - rtc::scoped_refptr xdp_base_; -#endif + #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) rtc::scoped_refptr configuration_monitor_; bool allow_iosurface_ = false; diff --git a/modules/desktop_capture/linux/base_capturer_pipewire.cc b/modules/desktop_capture/linux/base_capturer_pipewire.cc index f9323f1848..2640e93aa9 100644 --- a/modules/desktop_capture/linux/base_capturer_pipewire.cc +++ b/modules/desktop_capture/linux/base_capturer_pipewire.cc @@ -10,102 +10,859 @@ #include "modules/desktop_capture/linux/base_capturer_pipewire.h" +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "absl/memory/memory.h" +#include "modules/desktop_capture/desktop_capture_options.h" #include "modules/desktop_capture/desktop_capturer.h" -#include "modules/desktop_capture/linux/pipewire_base.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" +#if defined(WEBRTC_DLOPEN_PIPEWIRE) +#include "modules/desktop_capture/linux/pipewire_stubs.h" + +using modules_desktop_capture_linux::InitializeStubs; +using modules_desktop_capture_linux::kModulePipewire; +using modules_desktop_capture_linux::StubPathMap; +#endif // defined(WEBRTC_DLOPEN_PIPEWIRE) + namespace webrtc { -BaseCapturerPipeWire::BaseCapturerPipeWire() {} +const char kDesktopBusName[] = "org.freedesktop.portal.Desktop"; +const char kDesktopObjectPath[] = "/org/freedesktop/portal/desktop"; +const char kDesktopRequestObjectPath[] = + "/org/freedesktop/portal/desktop/request"; +const char kSessionInterfaceName[] = "org.freedesktop.portal.Session"; +const char kRequestInterfaceName[] = "org.freedesktop.portal.Request"; +const char kScreenCastInterfaceName[] = "org.freedesktop.portal.ScreenCast"; -BaseCapturerPipeWire::~BaseCapturerPipeWire() { - webrtc::XdgDesktopPortalBase* xdpBase = options_.xdp_base(); - if (auto_close_connection_ || xdpBase->IsConnectionStreamingOnWeb(id_)) { - xdpBase->CloseConnection(id_); +const int kBytesPerPixel = 4; + +#if defined(WEBRTC_DLOPEN_PIPEWIRE) +const char kPipeWireLib[] = "libpipewire-0.2.so.1"; +#endif + +// static +void BaseCapturerPipeWire::OnStateChanged(void* data, + pw_remote_state old_state, + pw_remote_state state, + const char* error_message) { + BaseCapturerPipeWire* that = static_cast(data); + RTC_DCHECK(that); + + switch (state) { + case PW_REMOTE_STATE_ERROR: + RTC_LOG(LS_ERROR) << "PipeWire remote state error: " << error_message; + break; + case PW_REMOTE_STATE_CONNECTED: + RTC_LOG(LS_INFO) << "PipeWire remote state: connected."; + that->CreateReceivingStream(); + break; + case PW_REMOTE_STATE_CONNECTING: + RTC_LOG(LS_INFO) << "PipeWire remote state: connecting."; + break; + case PW_REMOTE_STATE_UNCONNECTED: + RTC_LOG(LS_INFO) << "PipeWire remote state: unconnected."; + break; } } -bool BaseCapturerPipeWire::Init(const DesktopCaptureOptions& options, - XdgDesktopPortalBase::CaptureSourceType type) { - options_ = options; - type_ = type; +// static +void BaseCapturerPipeWire::OnStreamStateChanged(void* data, + pw_stream_state old_state, + pw_stream_state state, + const char* error_message) { + BaseCapturerPipeWire* that = static_cast(data); + RTC_DCHECK(that); - XdgDesktopPortalBase::CaptureSourceType requestedType_ = - XdgDesktopPortalBase::CaptureSourceType::kAny; + switch (state) { + case PW_STREAM_STATE_ERROR: + RTC_LOG(LS_ERROR) << "PipeWire stream state error: " << error_message; + break; + case PW_STREAM_STATE_CONFIGURE: + pw_stream_set_active(that->pw_stream_, true); + break; + case PW_STREAM_STATE_UNCONNECTED: + case PW_STREAM_STATE_CONNECTING: + case PW_STREAM_STATE_READY: + case PW_STREAM_STATE_PAUSED: + case PW_STREAM_STATE_STREAMING: + break; + } +} - id_ = options_.request_id(); +// static +void BaseCapturerPipeWire::OnStreamFormatChanged(void* data, + const struct spa_pod* format) { + BaseCapturerPipeWire* that = static_cast(data); + RTC_DCHECK(that); - // We need some ID to be able to identify our capturer - if (!id_) { - id_ = g_random_int_range(0, G_MAXINT); - auto_close_connection_ = true; - requestedType_ = type; + RTC_LOG(LS_INFO) << "PipeWire stream format changed."; + + if (!format) { + pw_stream_finish_format(that->pw_stream_, /*res=*/0, /*params=*/nullptr, + /*n_params=*/0); + return; } - webrtc::XdgDesktopPortalBase* xdpBase = options_.xdp_base(); + that->spa_video_format_ = new spa_video_info_raw(); + spa_format_video_raw_parse(format, that->spa_video_format_, + &that->pw_type_->format_video); - if (xdpBase->IsConnectionInitialized(id_.value())) { - // Because capturers created for the preview dialog (Chrome, Firefox) will - // be created simultaneously and because of that the connection cannot be - // initialized yet, we can safely assume this a capturer created in the - // final state to show the content on the web page itself Note: this will - // have no effect on clients not using our specific API in - // DesktopCaptureOptions - xdpBase->SetConnectionStreamingOnWeb(id_.value()); - portal_initialized_ = true; - return true; + auto width = that->spa_video_format_->size.width; + auto height = that->spa_video_format_->size.height; + auto stride = SPA_ROUND_UP_N(width * kBytesPerPixel, 4); + auto size = height * stride; + + uint8_t buffer[1024] = {}; + auto builder = spa_pod_builder{buffer, sizeof(buffer)}; + + // Setup buffers and meta header for new format. + const struct spa_pod* params[2]; + params[0] = reinterpret_cast(spa_pod_builder_object( + &builder, + // id to enumerate buffer requirements + that->pw_core_type_->param.idBuffers, + that->pw_core_type_->param_buffers.Buffers, + // Size: specified as integer (i) and set to specified size + ":", that->pw_core_type_->param_buffers.size, "i", size, + // Stride: specified as integer (i) and set to specified stride + ":", that->pw_core_type_->param_buffers.stride, "i", stride, + // Buffers: specifies how many buffers we want to deal with, set as + // integer (i) where preferred number is 8, then allowed number is defined + // as range (r) from min and max values and it is undecided (u) to allow + // negotiation + ":", that->pw_core_type_->param_buffers.buffers, "iru", 8, + SPA_POD_PROP_MIN_MAX(1, 32), + // Align: memory alignment of the buffer, set as integer (i) to specified + // value + ":", that->pw_core_type_->param_buffers.align, "i", 16)); + params[1] = reinterpret_cast(spa_pod_builder_object( + &builder, + // id to enumerate supported metadata + that->pw_core_type_->param.idMeta, that->pw_core_type_->param_meta.Meta, + // Type: specified as id or enum (I) + ":", that->pw_core_type_->param_meta.type, "I", + that->pw_core_type_->meta.Header, + // Size: size of the metadata, specified as integer (i) + ":", that->pw_core_type_->param_meta.size, "i", + sizeof(struct spa_meta_header))); + + pw_stream_finish_format(that->pw_stream_, /*res=*/0, params, /*n_params=*/2); +} + +// static +void BaseCapturerPipeWire::OnStreamProcess(void* data) { + BaseCapturerPipeWire* that = static_cast(data); + RTC_DCHECK(that); + + pw_buffer* buf = nullptr; + + if (!(buf = pw_stream_dequeue_buffer(that->pw_stream_))) { + return; } - auto lambda = [=](bool result) { portal_initialized_ = result; }; + that->HandleBuffer(buf); - rtc::Callback1 cb = lambda; - xdpBase->InitPortal(cb, requestedType_, id_.value()); + pw_stream_queue_buffer(that->pw_stream_, buf); +} - return true; +BaseCapturerPipeWire::BaseCapturerPipeWire(CaptureSourceType source_type) + : capture_source_type_(source_type) {} + +BaseCapturerPipeWire::~BaseCapturerPipeWire() { + if (pw_main_loop_) { + pw_thread_loop_stop(pw_main_loop_); + } + + if (pw_type_) { + delete pw_type_; + } + + if (spa_video_format_) { + delete spa_video_format_; + } + + if (pw_stream_) { + pw_stream_destroy(pw_stream_); + } + + if (pw_remote_) { + pw_remote_destroy(pw_remote_); + } + + if (pw_core_) { + pw_core_destroy(pw_core_); + } + + if (pw_main_loop_) { + pw_thread_loop_destroy(pw_main_loop_); + } + + if (pw_loop_) { + pw_loop_destroy(pw_loop_); + } + + if (current_frame_) { + free(current_frame_); + } + + if (start_request_signal_id_) { + g_dbus_connection_signal_unsubscribe(connection_, start_request_signal_id_); + } + if (sources_request_signal_id_) { + g_dbus_connection_signal_unsubscribe(connection_, + sources_request_signal_id_); + } + if (session_request_signal_id_) { + g_dbus_connection_signal_unsubscribe(connection_, + session_request_signal_id_); + } + + if (session_handle_) { + GDBusMessage* message = g_dbus_message_new_method_call( + kDesktopBusName, session_handle_, kSessionInterfaceName, "Close"); + if (message) { + GError* error = nullptr; + g_dbus_connection_send_message(connection_, message, + G_DBUS_SEND_MESSAGE_FLAGS_NONE, + /*out_serial=*/nullptr, &error); + if (error) { + RTC_LOG(LS_ERROR) << "Failed to close the session: " << error->message; + g_error_free(error); + } + g_object_unref(message); + } + } + + g_free(start_handle_); + g_free(sources_handle_); + g_free(session_handle_); + g_free(portal_handle_); + + if (cancellable_) { + g_cancellable_cancel(cancellable_); + g_object_unref(cancellable_); + cancellable_ = nullptr; + } + + if (proxy_) { + g_object_unref(proxy_); + proxy_ = nullptr; + } +} + +void BaseCapturerPipeWire::InitPortal() { + cancellable_ = g_cancellable_new(); + g_dbus_proxy_new_for_bus( + G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, /*info=*/nullptr, + kDesktopBusName, kDesktopObjectPath, kScreenCastInterfaceName, + cancellable_, + reinterpret_cast(OnProxyRequested), this); +} + +void BaseCapturerPipeWire::InitPipeWire() { +#if defined(WEBRTC_DLOPEN_PIPEWIRE) + StubPathMap paths; + + // Check if the PipeWire library is available. + paths[kModulePipewire].push_back(kPipeWireLib); + if (!InitializeStubs(paths)) { + RTC_LOG(LS_ERROR) << "Failed to load the PipeWire library and symbols."; + portal_init_failed_ = true; + return; + } +#endif // defined(WEBRTC_DLOPEN_PIPEWIRE) + + pw_init(/*argc=*/nullptr, /*argc=*/nullptr); + + pw_loop_ = pw_loop_new(/*properties=*/nullptr); + pw_main_loop_ = pw_thread_loop_new(pw_loop_, "pipewire-main-loop"); + + pw_core_ = pw_core_new(pw_loop_, /*properties=*/nullptr); + pw_core_type_ = pw_core_get_type(pw_core_); + pw_remote_ = pw_remote_new(pw_core_, nullptr, /*user_data_size=*/0); + + InitPipeWireTypes(); + + // Initialize event handlers, remote end and stream-related. + pw_remote_events_.version = PW_VERSION_REMOTE_EVENTS; + pw_remote_events_.state_changed = &OnStateChanged; + + pw_stream_events_.version = PW_VERSION_STREAM_EVENTS; + pw_stream_events_.state_changed = &OnStreamStateChanged; + pw_stream_events_.format_changed = &OnStreamFormatChanged; + pw_stream_events_.process = &OnStreamProcess; + + pw_remote_add_listener(pw_remote_, &spa_remote_listener_, &pw_remote_events_, + this); + pw_remote_connect_fd(pw_remote_, pw_fd_); + + if (pw_thread_loop_start(pw_main_loop_) < 0) { + RTC_LOG(LS_ERROR) << "Failed to start main PipeWire loop"; + portal_init_failed_ = true; + } + + RTC_LOG(LS_INFO) << "PipeWire remote opened."; +} + +void BaseCapturerPipeWire::InitPipeWireTypes() { + spa_type_map* map = pw_core_type_->map; + pw_type_ = new PipeWireType(); + + spa_type_media_type_map(map, &pw_type_->media_type); + spa_type_media_subtype_map(map, &pw_type_->media_subtype); + spa_type_format_video_map(map, &pw_type_->format_video); + spa_type_video_format_map(map, &pw_type_->video_format); +} + +void BaseCapturerPipeWire::CreateReceivingStream() { + spa_rectangle pwMinScreenBounds = spa_rectangle{1, 1}; + spa_rectangle pwScreenBounds = + spa_rectangle{static_cast(desktop_size_.width()), + static_cast(desktop_size_.height())}; + + spa_fraction pwFrameRateMin = spa_fraction{0, 1}; + spa_fraction pwFrameRateMax = spa_fraction{60, 1}; + + pw_properties* reuseProps = + pw_properties_new_string("pipewire.client.reuse=1"); + pw_stream_ = pw_stream_new(pw_remote_, "webrtc-consume-stream", reuseProps); + + uint8_t buffer[1024] = {}; + const spa_pod* params[1]; + spa_pod_builder builder = spa_pod_builder{buffer, sizeof(buffer)}; + params[0] = reinterpret_cast(spa_pod_builder_object( + &builder, + // id to enumerate formats + pw_core_type_->param.idEnumFormat, pw_core_type_->spa_format, "I", + pw_type_->media_type.video, "I", pw_type_->media_subtype.raw, + // Video format: specified as id or enum (I), preferred format is BGRx, + // then allowed formats are enumerated (e) and the format is undecided (u) + // to allow negotiation + ":", pw_type_->format_video.format, "Ieu", pw_type_->video_format.BGRx, + SPA_POD_PROP_ENUM(2, pw_type_->video_format.RGBx, + pw_type_->video_format.BGRx), + // Video size: specified as rectangle (R), preferred size is specified as + // first parameter, then allowed size is defined as range (r) from min and + // max values and the format is undecided (u) to allow negotiation + ":", pw_type_->format_video.size, "Rru", &pwScreenBounds, 2, + &pwMinScreenBounds, &pwScreenBounds, + // Frame rate: specified as fraction (F) and set to minimum frame rate + // value + ":", pw_type_->format_video.framerate, "F", &pwFrameRateMin, + // Max frame rate: specified as fraction (F), preferred frame rate is set + // to maximum value, then allowed frame rate is defined as range (r) from + // min and max values and it is undecided (u) to allow negotiation + ":", pw_type_->format_video.max_framerate, "Fru", &pwFrameRateMax, 2, + &pwFrameRateMin, &pwFrameRateMax)); + + pw_stream_add_listener(pw_stream_, &spa_stream_listener_, &pw_stream_events_, + this); + pw_stream_flags flags = static_cast( + PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE | + PW_STREAM_FLAG_MAP_BUFFERS); + if (pw_stream_connect(pw_stream_, PW_DIRECTION_INPUT, /*port_path=*/nullptr, + flags, params, + /*n_params=*/1) != 0) { + RTC_LOG(LS_ERROR) << "Could not connect receiving stream."; + portal_init_failed_ = true; + return; + } +} + +void BaseCapturerPipeWire::HandleBuffer(pw_buffer* buffer) { + spa_buffer* spaBuffer = buffer->buffer; + void* src = nullptr; + + if (!(src = spaBuffer->datas[0].data)) { + return; + } + + uint32_t maxSize = spaBuffer->datas[0].maxsize; + int32_t srcStride = spaBuffer->datas[0].chunk->stride; + if (srcStride != (desktop_size_.width() * kBytesPerPixel)) { + RTC_LOG(LS_ERROR) << "Got buffer with stride different from screen stride: " + << srcStride + << " != " << (desktop_size_.width() * kBytesPerPixel); + portal_init_failed_ = true; + return; + } + + if (!current_frame_) { + current_frame_ = static_cast(malloc(maxSize)); + } + RTC_DCHECK(current_frame_ != nullptr); + + // If both sides decided to go with the RGBx format we need to convert it to + // BGRx to match color format expected by WebRTC. + if (spa_video_format_->format == pw_type_->video_format.RGBx) { + uint8_t* tempFrame = static_cast(malloc(maxSize)); + std::memcpy(tempFrame, src, maxSize); + ConvertRGBxToBGRx(tempFrame, maxSize); + std::memcpy(current_frame_, tempFrame, maxSize); + free(tempFrame); + } else { + std::memcpy(current_frame_, src, maxSize); + } +} + +void BaseCapturerPipeWire::ConvertRGBxToBGRx(uint8_t* frame, uint32_t size) { + // Change color format for KDE KWin which uses RGBx and not BGRx + for (uint32_t i = 0; i < size; i += 4) { + uint8_t tempR = frame[i]; + uint8_t tempB = frame[i + 2]; + frame[i] = tempB; + frame[i + 2] = tempR; + } +} + +guint BaseCapturerPipeWire::SetupRequestResponseSignal( + const gchar* object_path, + GDBusSignalCallback callback) { + return g_dbus_connection_signal_subscribe( + connection_, kDesktopBusName, kRequestInterfaceName, "Response", + object_path, /*arg0=*/nullptr, G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE, + callback, this, /*user_data_free_func=*/nullptr); +} + +// static +void BaseCapturerPipeWire::OnProxyRequested(GObject* /*object*/, + GAsyncResult* result, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + GError* error = nullptr; + GDBusProxy *proxy = g_dbus_proxy_new_finish(result, &error); + if (!proxy) { + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + return; + RTC_LOG(LS_ERROR) << "Failed to create a proxy for the screen cast portal: " + << error->message; + g_error_free(error); + that->portal_init_failed_ = true; + return; + } + that->proxy_ = proxy; + that->connection_ = g_dbus_proxy_get_connection(that->proxy_); + + RTC_LOG(LS_INFO) << "Created proxy for the screen cast portal."; + that->SessionRequest(); +} + +// static +gchar* BaseCapturerPipeWire::PrepareSignalHandle(GDBusConnection* connection, + const gchar* token) { + gchar* sender = g_strdup(g_dbus_connection_get_unique_name(connection) + 1); + for (int i = 0; sender[i]; i++) { + if (sender[i] == '.') { + sender[i] = '_'; + } + } + + gchar* handle = g_strconcat(kDesktopRequestObjectPath, "/", sender, "/", + token, /*end of varargs*/ nullptr); + g_free(sender); + + return handle; +} + +void BaseCapturerPipeWire::SessionRequest() { + GVariantBuilder builder; + gchar* variant_string; + + g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); + variant_string = + g_strdup_printf("webrtc_session%d", g_random_int_range(0, G_MAXINT)); + g_variant_builder_add(&builder, "{sv}", "session_handle_token", + g_variant_new_string(variant_string)); + g_free(variant_string); + variant_string = g_strdup_printf("webrtc%d", g_random_int_range(0, G_MAXINT)); + g_variant_builder_add(&builder, "{sv}", "handle_token", + g_variant_new_string(variant_string)); + + portal_handle_ = PrepareSignalHandle(connection_, variant_string); + session_request_signal_id_ = SetupRequestResponseSignal( + portal_handle_, OnSessionRequestResponseSignal); + g_free(variant_string); + + RTC_LOG(LS_INFO) << "Screen cast session requested."; + g_dbus_proxy_call( + proxy_, "CreateSession", g_variant_new("(a{sv})", &builder), + G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, cancellable_, + reinterpret_cast(OnSessionRequested), this); +} + +// static +void BaseCapturerPipeWire::OnSessionRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + GError* error = nullptr; + GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error); + if (!variant) { + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + return; + RTC_LOG(LS_ERROR) << "Failed to create a screen cast session: " + << error->message; + g_error_free(error); + that->portal_init_failed_ = true; + return; + } + RTC_LOG(LS_INFO) << "Initializing the screen cast session."; + + gchar* handle = nullptr; + g_variant_get_child(variant, 0, "o", &handle); + g_variant_unref(variant); + if (!handle) { + RTC_LOG(LS_ERROR) << "Failed to initialize the screen cast session."; + if (that->session_request_signal_id_) { + g_dbus_connection_signal_unsubscribe(that->connection_, + that->session_request_signal_id_); + that->session_request_signal_id_ = 0; + } + that->portal_init_failed_ = true; + return; + } + + g_free(handle); + + RTC_LOG(LS_INFO) << "Subscribing to the screen cast session."; +} + +// static +void BaseCapturerPipeWire::OnSessionRequestResponseSignal( + GDBusConnection* connection, + const gchar* sender_name, + const gchar* object_path, + const gchar* interface_name, + const gchar* signal_name, + GVariant* parameters, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + RTC_LOG(LS_INFO) + << "Received response for the screen cast session subscription."; + + guint32 portal_response; + GVariant* response_data; + g_variant_get(parameters, "(u@a{sv})", &portal_response, &response_data); + g_variant_lookup(response_data, "session_handle", "s", + &that->session_handle_); + g_variant_unref(response_data); + + if (!that->session_handle_ || portal_response) { + RTC_LOG(LS_ERROR) + << "Failed to request the screen cast session subscription."; + that->portal_init_failed_ = true; + return; + } + + that->SourcesRequest(); +} + +void BaseCapturerPipeWire::SourcesRequest() { + GVariantBuilder builder; + gchar* variant_string; + + g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); + // We want to record monitor content. + g_variant_builder_add(&builder, "{sv}", "types", + g_variant_new_uint32(capture_source_type_)); + // We don't want to allow selection of multiple sources. + g_variant_builder_add(&builder, "{sv}", "multiple", + g_variant_new_boolean(false)); + variant_string = g_strdup_printf("webrtc%d", g_random_int_range(0, G_MAXINT)); + g_variant_builder_add(&builder, "{sv}", "handle_token", + g_variant_new_string(variant_string)); + + sources_handle_ = PrepareSignalHandle(connection_, variant_string); + sources_request_signal_id_ = SetupRequestResponseSignal( + sources_handle_, OnSourcesRequestResponseSignal); + g_free(variant_string); + + RTC_LOG(LS_INFO) << "Requesting sources from the screen cast session."; + g_dbus_proxy_call( + proxy_, "SelectSources", + g_variant_new("(oa{sv})", session_handle_, &builder), + G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, cancellable_, + reinterpret_cast(OnSourcesRequested), this); +} + +// static +void BaseCapturerPipeWire::OnSourcesRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + GError* error = nullptr; + GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error); + if (!variant) { + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + return; + RTC_LOG(LS_ERROR) << "Failed to request the sources: " << error->message; + g_error_free(error); + that->portal_init_failed_ = true; + return; + } + + RTC_LOG(LS_INFO) << "Sources requested from the screen cast session."; + + gchar* handle = nullptr; + g_variant_get_child(variant, 0, "o", &handle); + g_variant_unref(variant); + if (!handle) { + RTC_LOG(LS_ERROR) << "Failed to initialize the screen cast session."; + if (that->sources_request_signal_id_) { + g_dbus_connection_signal_unsubscribe(that->connection_, + that->sources_request_signal_id_); + that->sources_request_signal_id_ = 0; + } + that->portal_init_failed_ = true; + return; + } + + g_free(handle); + + RTC_LOG(LS_INFO) << "Subscribed to sources signal."; +} + +// static +void BaseCapturerPipeWire::OnSourcesRequestResponseSignal( + GDBusConnection* connection, + const gchar* sender_name, + const gchar* object_path, + const gchar* interface_name, + const gchar* signal_name, + GVariant* parameters, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + RTC_LOG(LS_INFO) << "Received sources signal from session."; + + guint32 portal_response; + g_variant_get(parameters, "(u@a{sv})", &portal_response, nullptr); + if (portal_response) { + RTC_LOG(LS_ERROR) + << "Failed to select sources for the screen cast session."; + that->portal_init_failed_ = true; + return; + } + + that->StartRequest(); +} + +void BaseCapturerPipeWire::StartRequest() { + GVariantBuilder builder; + gchar* variant_string; + + g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); + variant_string = g_strdup_printf("webrtc%d", g_random_int_range(0, G_MAXINT)); + g_variant_builder_add(&builder, "{sv}", "handle_token", + g_variant_new_string(variant_string)); + + start_handle_ = PrepareSignalHandle(connection_, variant_string); + start_request_signal_id_ = + SetupRequestResponseSignal(start_handle_, OnStartRequestResponseSignal); + g_free(variant_string); + + // "Identifier for the application window", this is Wayland, so not "x11:...". + const gchar parent_window[] = ""; + + RTC_LOG(LS_INFO) << "Starting the screen cast session."; + g_dbus_proxy_call( + proxy_, "Start", + g_variant_new("(osa{sv})", session_handle_, parent_window, &builder), + G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, cancellable_, + reinterpret_cast(OnStartRequested), this); +} + +// static +void BaseCapturerPipeWire::OnStartRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + GError* error = nullptr; + GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error); + if (!variant) { + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + return; + RTC_LOG(LS_ERROR) << "Failed to start the screen cast session: " + << error->message; + g_error_free(error); + that->portal_init_failed_ = true; + return; + } + + RTC_LOG(LS_INFO) << "Initializing the start of the screen cast session."; + + gchar* handle = nullptr; + g_variant_get_child(variant, 0, "o", &handle); + g_variant_unref(variant); + if (!handle) { + RTC_LOG(LS_ERROR) + << "Failed to initialize the start of the screen cast session."; + if (that->start_request_signal_id_) { + g_dbus_connection_signal_unsubscribe(that->connection_, + that->start_request_signal_id_); + that->start_request_signal_id_ = 0; + } + that->portal_init_failed_ = true; + return; + } + + g_free(handle); + + RTC_LOG(LS_INFO) << "Subscribed to the start signal."; +} + +// static +void BaseCapturerPipeWire::OnStartRequestResponseSignal( + GDBusConnection* connection, + const gchar* sender_name, + const gchar* object_path, + const gchar* interface_name, + const gchar* signal_name, + GVariant* parameters, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + RTC_LOG(LS_INFO) << "Start signal received."; + guint32 portal_response; + GVariant* response_data; + GVariantIter* iter = nullptr; + g_variant_get(parameters, "(u@a{sv})", &portal_response, &response_data); + if (portal_response || !response_data) { + RTC_LOG(LS_ERROR) << "Failed to start the screen cast session."; + that->portal_init_failed_ = true; + return; + } + + // Array of PipeWire streams. See + // https://github.com/flatpak/xdg-desktop-portal/blob/master/data/org.freedesktop.portal.ScreenCast.xml + // documentation for . + if (g_variant_lookup(response_data, "streams", "a(ua{sv})", &iter)) { + GVariant* variant; + + while (g_variant_iter_next(iter, "@(ua{sv})", &variant)) { + guint32 stream_id; + gint32 width; + gint32 height; + GVariant* options; + + g_variant_get(variant, "(u@a{sv})", &stream_id, &options); + RTC_DCHECK(options != nullptr); + + g_variant_lookup(options, "size", "(ii)", &width, &height); + + that->desktop_size_.set(width, height); + + g_variant_unref(options); + g_variant_unref(variant); + } + } + g_variant_iter_free(iter); + g_variant_unref(response_data); + + that->OpenPipeWireRemote(); +} + +void BaseCapturerPipeWire::OpenPipeWireRemote() { + GVariantBuilder builder; + g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); + + RTC_LOG(LS_INFO) << "Opening the PipeWire remote."; + + g_dbus_proxy_call_with_unix_fd_list( + proxy_, "OpenPipeWireRemote", + g_variant_new("(oa{sv})", session_handle_, &builder), + G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, /*fd_list=*/nullptr, + cancellable_, + reinterpret_cast(OnOpenPipeWireRemoteRequested), + this); +} + +// static +void BaseCapturerPipeWire::OnOpenPipeWireRemoteRequested( + GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data) { + BaseCapturerPipeWire* that = static_cast(user_data); + RTC_DCHECK(that); + + GError* error = nullptr; + GUnixFDList* outlist = nullptr; + GVariant* variant = g_dbus_proxy_call_with_unix_fd_list_finish( + proxy, &outlist, result, &error); + if (!variant) { + if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + return; + RTC_LOG(LS_ERROR) << "Failed to open the PipeWire remote: " + << error->message; + g_error_free(error); + that->portal_init_failed_ = true; + return; + } + + gint32 index; + g_variant_get(variant, "(h)", &index); + + if ((that->pw_fd_ = g_unix_fd_list_get(outlist, index, &error)) == -1) { + RTC_LOG(LS_ERROR) << "Failed to get file descriptor from the list: " + << error->message; + g_error_free(error); + g_variant_unref(variant); + that->portal_init_failed_ = true; + return; + } + + g_variant_unref(variant); + g_object_unref(outlist); + + that->InitPipeWire(); } void BaseCapturerPipeWire::Start(Callback* callback) { RTC_DCHECK(!callback_); RTC_DCHECK(callback); + InitPortal(); + callback_ = callback; } void BaseCapturerPipeWire::CaptureFrame() { - if (!portal_initialized_) { - callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr); - return; - } - - webrtc::XdgDesktopPortalBase* xdpBase = options_.xdp_base(); - if (type_ != XdgDesktopPortalBase::CaptureSourceType::kAny && - xdpBase->GetConnectionData(id_)->capture_source_type_ != type_ && - xdpBase->GetConnectionData(id_)->capture_source_type_ != - XdgDesktopPortalBase::CaptureSourceType::kAny) { + if (portal_init_failed_) { callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr); return; } - const webrtc::PipeWireBase* pwBase = xdpBase->GetPipeWireBase(id_); - - if (!pwBase) { - callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr); - return; - } - - if (!pwBase->Frame()) { + if (!current_frame_) { callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr); return; } - const DesktopSize frame_size = pwBase->FrameSize(); - - std::unique_ptr result(new BasicDesktopFrame(frame_size)); + std::unique_ptr result(new BasicDesktopFrame(desktop_size_)); result->CopyPixelsFrom( - pwBase->Frame(), (frame_size.width() * 4), // kBytesPerPixel = 4 - DesktopRect::MakeWH(frame_size.width(), frame_size.height())); - + current_frame_, (desktop_size_.width() * kBytesPerPixel), + DesktopRect::MakeWH(desktop_size_.width(), desktop_size_.height())); if (!result) { callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr); return; @@ -130,36 +887,4 @@ bool BaseCapturerPipeWire::SelectSource(SourceId id) { return true; } -// static -std::unique_ptr BaseCapturerPipeWire::CreateRawScreenCapturer( - const DesktopCaptureOptions& options) { - if (!options.xdp_base()) - return nullptr; - - std::unique_ptr capturer = - std::make_unique(); - if (!capturer->Init(options, - XdgDesktopPortalBase::CaptureSourceType::kScreen)) { - return nullptr; - } - - return std::move(capturer); -} - -// static -std::unique_ptr BaseCapturerPipeWire::CreateRawWindowCapturer( - const DesktopCaptureOptions& options) { - if (!options.xdp_base()) - return nullptr; - - std::unique_ptr capturer = - std::make_unique(); - if (!capturer->Init(options, - XdgDesktopPortalBase::CaptureSourceType::kWindow)) { - return nullptr; - } - - return std::move(capturer); -} - } // namespace webrtc diff --git a/modules/desktop_capture/linux/base_capturer_pipewire.h b/modules/desktop_capture/linux/base_capturer_pipewire.h index 849b283d24..f28d7a558b 100644 --- a/modules/desktop_capture/linux/base_capturer_pipewire.h +++ b/modules/desktop_capture/linux/base_capturer_pipewire.h @@ -11,43 +11,156 @@ #ifndef MODULES_DESKTOP_CAPTURE_LINUX_BASE_CAPTURER_PIPEWIRE_H_ #define MODULES_DESKTOP_CAPTURE_LINUX_BASE_CAPTURER_PIPEWIRE_H_ +#include +#define typeof __typeof__ +#include +#include + #include "modules/desktop_capture/desktop_capture_options.h" #include "modules/desktop_capture/desktop_capturer.h" -#include "modules/desktop_capture/linux/xdg_desktop_portal_base.h" - -#include "api/ref_counted_base.h" #include "rtc_base/constructor_magic.h" namespace webrtc { -class RTC_EXPORT BaseCapturerPipeWire : public DesktopCapturer { +class PipeWireType { public: - explicit BaseCapturerPipeWire(); + spa_type_media_type media_type; + spa_type_media_subtype media_subtype; + spa_type_format_video format_video; + spa_type_video_format video_format; +}; + +class BaseCapturerPipeWire : public DesktopCapturer { + public: + enum CaptureSourceType { Screen = 1, Window }; + + explicit BaseCapturerPipeWire(CaptureSourceType source_type); ~BaseCapturerPipeWire() override; - bool Init(const DesktopCaptureOptions& options, - XdgDesktopPortalBase::CaptureSourceType type); - + // DesktopCapturer interface. void Start(Callback* delegate) override; void CaptureFrame() override; bool GetSourceList(SourceList* sources) override; bool SelectSource(SourceId id) override; - static std::unique_ptr CreateRawScreenCapturer( - const DesktopCaptureOptions& options); - - static std::unique_ptr CreateRawWindowCapturer( - const DesktopCaptureOptions& options); - private: + // PipeWire types --> + pw_core* pw_core_ = nullptr; + pw_type* pw_core_type_ = nullptr; + pw_stream* pw_stream_ = nullptr; + pw_remote* pw_remote_ = nullptr; + pw_loop* pw_loop_ = nullptr; + pw_thread_loop* pw_main_loop_ = nullptr; + PipeWireType* pw_type_ = nullptr; + + spa_hook spa_stream_listener_ = {}; + spa_hook spa_remote_listener_ = {}; + + pw_stream_events pw_stream_events_ = {}; + pw_remote_events pw_remote_events_ = {}; + + spa_video_info_raw* spa_video_format_ = nullptr; + + gint32 pw_fd_ = -1; + + CaptureSourceType capture_source_type_ = + BaseCapturerPipeWire::CaptureSourceType::Screen; + + // <-- end of PipeWire types + + GDBusConnection* connection_ = nullptr; + GDBusProxy* proxy_ = nullptr; + GCancellable *cancellable_ = nullptr; + gchar* portal_handle_ = nullptr; + gchar* session_handle_ = nullptr; + gchar* sources_handle_ = nullptr; + gchar* start_handle_ = nullptr; + guint session_request_signal_id_ = 0; + guint sources_request_signal_id_ = 0; + guint start_request_signal_id_ = 0; + + DesktopSize desktop_size_ = {}; DesktopCaptureOptions options_ = {}; + + uint8_t* current_frame_ = nullptr; Callback* callback_ = nullptr; - XdgDesktopPortalBase::CaptureSourceType type_ = - XdgDesktopPortalBase::CaptureSourceType::kScreen; - absl::optional id_; - bool auto_close_connection_ = false; - bool portal_initialized_ = false; + bool portal_init_failed_ = false; + + void InitPortal(); + void InitPipeWire(); + void InitPipeWireTypes(); + + void CreateReceivingStream(); + void HandleBuffer(pw_buffer* buffer); + + void ConvertRGBxToBGRx(uint8_t* frame, uint32_t size); + + static void OnStateChanged(void* data, + pw_remote_state old_state, + pw_remote_state state, + const char* error); + static void OnStreamStateChanged(void* data, + pw_stream_state old_state, + pw_stream_state state, + const char* error_message); + + static void OnStreamFormatChanged(void* data, const struct spa_pod* format); + static void OnStreamProcess(void* data); + static void OnNewBuffer(void* data, uint32_t id); + + guint SetupRequestResponseSignal(const gchar* object_path, + GDBusSignalCallback callback); + + static void OnProxyRequested(GObject* object, + GAsyncResult* result, + gpointer user_data); + + static gchar* PrepareSignalHandle(GDBusConnection* connection, + const gchar* token); + + void SessionRequest(); + static void OnSessionRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data); + static void OnSessionRequestResponseSignal(GDBusConnection* connection, + const gchar* sender_name, + const gchar* object_path, + const gchar* interface_name, + const gchar* signal_name, + GVariant* parameters, + gpointer user_data); + + void SourcesRequest(); + static void OnSourcesRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data); + static void OnSourcesRequestResponseSignal(GDBusConnection* connection, + const gchar* sender_name, + const gchar* object_path, + const gchar* interface_name, + const gchar* signal_name, + GVariant* parameters, + gpointer user_data); + + void StartRequest(); + static void OnStartRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data); + static void OnStartRequestResponseSignal(GDBusConnection* connection, + const gchar* sender_name, + const gchar* object_path, + const gchar* interface_name, + const gchar* signal_name, + GVariant* parameters, + gpointer user_data); + + void OpenPipeWireRemote(); + static void OnOpenPipeWireRemoteRequested(GDBusProxy *proxy, + GAsyncResult* result, + gpointer user_data); + + RTC_DISALLOW_COPY_AND_ASSIGN(BaseCapturerPipeWire); }; } // namespace webrtc diff --git a/modules/desktop_capture/linux/pipewire.sigs b/modules/desktop_capture/linux/pipewire.sigs index e915bc9f17..3e21e9dc07 100644 --- a/modules/desktop_capture/linux/pipewire.sigs +++ b/modules/desktop_capture/linux/pipewire.sigs @@ -42,5 +42,3 @@ void pw_thread_loop_destroy(pw_thread_loop *loop); pw_thread_loop * pw_thread_loop_new(pw_loop *loop, const char *name); int pw_thread_loop_start(pw_thread_loop *loop); void pw_thread_loop_stop(pw_thread_loop *loop); -void pw_thread_loop_lock(struct pw_thread_loop *loop); -void pw_thread_loop_unlock(struct pw_thread_loop *loop); diff --git a/modules/desktop_capture/linux/pipewire_base.cc b/modules/desktop_capture/linux/pipewire_base.cc deleted file mode 100644 index 6b789eaaf0..0000000000 --- a/modules/desktop_capture/linux/pipewire_base.cc +++ /dev/null @@ -1,500 +0,0 @@ -/* - * Copyright 2020 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "modules/desktop_capture/linux/pipewire_base.h" - -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "absl/memory/memory.h" -#include "modules/desktop_capture/desktop_capture_options.h" -#include "rtc_base/checks.h" -#include "rtc_base/logging.h" - -#if defined(WEBRTC_DLOPEN_PIPEWIRE) -#include "modules/desktop_capture/linux/pipewire_stubs.h" - -using modules_desktop_capture_linux::InitializeStubs; -using modules_desktop_capture_linux::kModulePipewire; -using modules_desktop_capture_linux::StubPathMap; -#endif // defined(WEBRTC_DLOPEN_PIPEWIRE) - -namespace webrtc { - -const int kBytesPerPixel = 4; - -#if defined(WEBRTC_DLOPEN_PIPEWIRE) -const char kPipeWireLib[] = "libpipewire-0.2.so.1"; -#endif - -// static -void PipeWireBase::SyncDmaBuf(int fd, uint64_t start_or_end) { - struct dma_buf_sync sync = {0}; - - sync.flags = start_or_end | DMA_BUF_SYNC_READ; - - while (true) { - int ret; - ret = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); - if (ret == -1 && errno == EINTR) { - continue; - } else if (ret == -1) { - RTC_LOG(LS_ERROR) << "Failed to synchronize DMA buffer: " - << g_strerror(errno); - break; - } else { - break; - } - } -} - -// static -void PipeWireBase::OnStateChanged(void* data, - pw_remote_state old_state, - pw_remote_state state, - const char* error_message) { - PipeWireBase* that = static_cast(data); - RTC_DCHECK(that); - - switch (state) { - case PW_REMOTE_STATE_ERROR: - RTC_LOG(LS_ERROR) << "PipeWire remote state error: " << error_message; - break; - case PW_REMOTE_STATE_CONNECTED: - RTC_LOG(LS_INFO) << "PipeWire remote state: connected."; - that->CreateReceivingStream(); - break; - case PW_REMOTE_STATE_CONNECTING: - RTC_LOG(LS_INFO) << "PipeWire remote state: connecting."; - break; - case PW_REMOTE_STATE_UNCONNECTED: - RTC_LOG(LS_INFO) << "PipeWire remote state: unconnected."; - break; - } -} - -// static -void PipeWireBase::OnStreamStateChanged(void* data, - pw_stream_state old_state, - pw_stream_state state, - const char* error_message) { - PipeWireBase* that = static_cast(data); - RTC_DCHECK(that); - - switch (state) { - case PW_STREAM_STATE_ERROR: - RTC_LOG(LS_ERROR) << "PipeWire stream state error: " << error_message; - break; - case PW_STREAM_STATE_CONFIGURE: - pw_stream_set_active(that->pw_stream_, true); - break; - case PW_STREAM_STATE_UNCONNECTED: - case PW_STREAM_STATE_CONNECTING: - case PW_STREAM_STATE_READY: - case PW_STREAM_STATE_PAUSED: - case PW_STREAM_STATE_STREAMING: - break; - } -} - -// static -void PipeWireBase::OnStreamFormatChanged(void* data, - const struct spa_pod* format) { - PipeWireBase* that = static_cast(data); - RTC_DCHECK(that); - - RTC_LOG(LS_INFO) << "PipeWire stream format changed."; - - if (!format) { - pw_stream_finish_format(that->pw_stream_, /*res=*/0, /*params=*/nullptr, - /*n_params=*/0); - return; - } - - that->spa_video_format_ = new spa_video_info_raw(); - spa_format_video_raw_parse(format, that->spa_video_format_, - &that->pw_type_->format_video); - - auto width = that->spa_video_format_->size.width; - auto height = that->spa_video_format_->size.height; - auto stride = SPA_ROUND_UP_N(width * kBytesPerPixel, 4); - auto size = height * stride; - - that->desktop_size_ = DesktopSize(width, height); - - uint8_t buffer[1024] = {}; - auto builder = spa_pod_builder{buffer, sizeof(buffer)}; - - // Setup buffers and meta header for new format. - const struct spa_pod* params[3]; - params[0] = reinterpret_cast(spa_pod_builder_object( - &builder, - // id to enumerate buffer requirements - that->pw_core_type_->param.idBuffers, - that->pw_core_type_->param_buffers.Buffers, - // Size: specified as integer (i) and set to specified size - ":", that->pw_core_type_->param_buffers.size, "i", size, - // Stride: specified as integer (i) and set to specified stride - ":", that->pw_core_type_->param_buffers.stride, "i", stride, - // Buffers: specifies how many buffers we want to deal with, set as - // integer (i) where preferred number is 8, then allowed number is defined - // as range (r) from min and max values and it is undecided (u) to allow - // negotiation - ":", that->pw_core_type_->param_buffers.buffers, "iru", 8, - SPA_POD_PROP_MIN_MAX(1, 32), - // Align: memory alignment of the buffer, set as integer (i) to specified - // value - ":", that->pw_core_type_->param_buffers.align, "i", 16)); - params[1] = reinterpret_cast(spa_pod_builder_object( - &builder, - // id to enumerate supported metadata - that->pw_core_type_->param.idMeta, that->pw_core_type_->param_meta.Meta, - // Type: specified as id or enum (I) - ":", that->pw_core_type_->param_meta.type, "I", - that->pw_core_type_->meta.Header, - // Size: size of the metadata, specified as integer (i) - ":", that->pw_core_type_->param_meta.size, "i", - sizeof(struct spa_meta_header))); - params[2] = reinterpret_cast( - spa_pod_builder_object(&builder, that->pw_core_type_->param.idMeta, - that->pw_core_type_->param_meta.Meta, ":", - that->pw_core_type_->param_meta.type, "I", - that->pw_core_type_->meta.VideoCrop, ":", - that->pw_core_type_->param_meta.size, "i", - sizeof(struct spa_meta_video_crop))); - pw_stream_finish_format(that->pw_stream_, /*res=*/0, params, /*n_params=*/3); -} - -// static -void PipeWireBase::OnStreamProcess(void* data) { - PipeWireBase* that = static_cast(data); - RTC_DCHECK(that); - - struct pw_buffer* next_buffer; - struct pw_buffer* buffer = nullptr; - - next_buffer = pw_stream_dequeue_buffer(that->pw_stream_); - while (next_buffer) { - buffer = next_buffer; - next_buffer = pw_stream_dequeue_buffer(that->pw_stream_); - - if (next_buffer) { - pw_stream_queue_buffer(that->pw_stream_, buffer); - } - } - - if (!buffer) { - return; - } - - that->HandleBuffer(buffer); - - pw_stream_queue_buffer(that->pw_stream_, buffer); -} - -PipeWireBase::PipeWireBase(int32_t fd) { -#if defined(WEBRTC_DLOPEN_PIPEWIRE) - StubPathMap paths; - - // Check if the PipeWire library is available. - paths[kModulePipewire].push_back(kPipeWireLib); - if (!InitializeStubs(paths)) { - RTC_LOG(LS_ERROR) << "Failed to load the PipeWire library and symbols."; - pipewire_init_failed_ = true; - return; - } -#endif // defined(WEBRTC_DLOPEN_PIPEWIRE) - - pw_init(/*argc=*/nullptr, /*argc=*/nullptr); - - pw_loop_ = pw_loop_new(/*properties=*/nullptr); - pw_main_loop_ = pw_thread_loop_new(pw_loop_, "pipewire-main-loop"); - - pw_thread_loop_lock(pw_main_loop_); - - pw_core_ = pw_core_new(pw_loop_, /*properties=*/nullptr); - pw_core_type_ = pw_core_get_type(pw_core_); - pw_remote_ = pw_remote_new(pw_core_, nullptr, /*user_data_size=*/0); - - InitPipeWireTypes(); - - // Initialize event handlers, remote end and stream-related. - pw_remote_events_.version = PW_VERSION_REMOTE_EVENTS; - pw_remote_events_.state_changed = &OnStateChanged; - - pw_stream_events_.version = PW_VERSION_STREAM_EVENTS; - pw_stream_events_.state_changed = &OnStreamStateChanged; - pw_stream_events_.format_changed = &OnStreamFormatChanged; - pw_stream_events_.process = &OnStreamProcess; - - pw_remote_add_listener(pw_remote_, &spa_remote_listener_, &pw_remote_events_, - this); - pw_remote_connect_fd(pw_remote_, fd); - - if (pw_thread_loop_start(pw_main_loop_) < 0) { - RTC_LOG(LS_ERROR) << "Failed to start main PipeWire loop"; - pipewire_init_failed_ = true; - } - - pw_thread_loop_unlock(pw_main_loop_); - - RTC_LOG(LS_INFO) << "PipeWire remote opened."; -} - -PipeWireBase::~PipeWireBase() { - if (pw_main_loop_) { - pw_thread_loop_stop(pw_main_loop_); - } - - if (pw_type_) { - delete pw_type_; - } - - if (spa_video_format_) { - delete spa_video_format_; - } - - if (pw_stream_) { - pw_stream_destroy(pw_stream_); - } - - if (pw_remote_) { - pw_remote_destroy(pw_remote_); - } - - if (pw_core_) { - pw_core_destroy(pw_core_); - } - - if (pw_main_loop_) { - pw_thread_loop_destroy(pw_main_loop_); - } - - if (pw_loop_) { - pw_loop_destroy(pw_loop_); - } -} - -uint8_t* PipeWireBase::Frame() const { - if (!current_frame_) { - return nullptr; - } - - return current_frame_.get(); -} - -DesktopSize PipeWireBase::FrameSize() const { - return video_crop_size_.value_or(desktop_size_); -} - -void PipeWireBase::InitPipeWireTypes() { - spa_type_map* map = pw_core_type_->map; - pw_type_ = new PipeWireType(); - - spa_type_media_type_map(map, &pw_type_->media_type); - spa_type_media_subtype_map(map, &pw_type_->media_subtype); - spa_type_format_video_map(map, &pw_type_->format_video); - spa_type_video_format_map(map, &pw_type_->video_format); -} - -void PipeWireBase::CreateReceivingStream() { - spa_rectangle pwMinScreenBounds = spa_rectangle{1, 1}; - spa_rectangle pwMaxScreenBounds = spa_rectangle{INT32_MAX, INT32_MAX}; - - pw_properties* reuseProps = - pw_properties_new_string("pipewire.client.reuse=1"); - pw_stream_ = pw_stream_new(pw_remote_, "webrtc-consume-stream", reuseProps); - - uint8_t buffer[1024] = {}; - const spa_pod* params[1]; - spa_pod_builder builder = spa_pod_builder{buffer, sizeof(buffer)}; - params[0] = reinterpret_cast(spa_pod_builder_object( - &builder, - // id to enumerate formats - pw_core_type_->param.idEnumFormat, pw_core_type_->spa_format, "I", - pw_type_->media_type.video, "I", pw_type_->media_subtype.raw, - // Video format: specified as id or enum (I), preferred format is BGRx, - // then allowed formats are enumerated (e) and the format is undecided (u) - // to allow negotiation - ":", pw_type_->format_video.format, "Ieu", pw_type_->video_format.BGRx, - SPA_POD_PROP_ENUM( - 4, pw_type_->video_format.RGBx, pw_type_->video_format.BGRx, - pw_type_->video_format.RGBA, pw_type_->video_format.BGRA), - // Video size: specified as rectangle (R), preferred size is specified as - // first parameter, then allowed size is defined as range (r) from min and - // max values and the format is undecided (u) to allow negotiation - ":", pw_type_->format_video.size, "Rru", &pwMinScreenBounds, - SPA_POD_PROP_MIN_MAX(&pwMinScreenBounds, &pwMaxScreenBounds))); - - pw_stream_add_listener(pw_stream_, &spa_stream_listener_, &pw_stream_events_, - this); - pw_stream_flags flags = static_cast( - PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE); - if (pw_stream_connect(pw_stream_, PW_DIRECTION_INPUT, /*port_path=*/nullptr, - flags, params, - /*n_params=*/1) != 0) { - RTC_LOG(LS_ERROR) << "Could not connect receiving stream."; - pipewire_init_failed_ = true; - return; - } -} - -void PipeWireBase::HandleBuffer(pw_buffer* buffer) { - struct spa_meta_video_crop* video_crop; - spa_buffer* spaBuffer = buffer->buffer; - uint8_t* map = nullptr; - uint8_t* src = nullptr; - uint8_t* dst = nullptr; - - if (spaBuffer->datas[0].chunk->size == 0) { - map = nullptr; - src = nullptr; - } else if (spaBuffer->datas[0].type == pw_core_type_->data.MemFd) { - map = static_cast(mmap( - nullptr, spaBuffer->datas[0].maxsize + spaBuffer->datas[0].mapoffset, - PROT_READ, MAP_PRIVATE, spaBuffer->datas[0].fd, 0)); - - if (map == MAP_FAILED) { - RTC_LOG(LS_ERROR) << "Failed to mmap the memory: " - << std::strerror(errno); - return; - } - - src = SPA_MEMBER(map, spaBuffer->datas[0].mapoffset, uint8_t); - } else if (spaBuffer->datas[0].type == pw_core_type_->data.DmaBuf) { - int fd; - fd = spaBuffer->datas[0].fd; - - map = static_cast(mmap( - nullptr, spaBuffer->datas[0].maxsize + spaBuffer->datas[0].mapoffset, - PROT_READ, MAP_PRIVATE, fd, 0)); - - if (map == MAP_FAILED) { - RTC_LOG(LS_ERROR) << "Failed to mmap the memory: " - << std::strerror(errno); - return; - } - - SyncDmaBuf(fd, DMA_BUF_SYNC_START); - - src = SPA_MEMBER(map, spaBuffer->datas[0].mapoffset, uint8_t); - } else if (spaBuffer->datas[0].type == pw_core_type_->data.MemPtr) { - map = nullptr; - src = static_cast(spaBuffer->datas[0].data); - } else { - return; - } - - if (!src) { - return; - } - - DesktopSize prev_crop_size = video_crop_size_.value_or(DesktopSize(0, 0)); - - if ((video_crop = static_cast( - spa_buffer_find_meta(spaBuffer, pw_core_type_->meta.VideoCrop)))) { - RTC_DCHECK(video_crop->width <= desktop_size_.width() && - video_crop->height <= desktop_size_.height()); - if ((video_crop->width != desktop_size_.width() || - video_crop->height != desktop_size_.height()) && - video_crop->width && video_crop->height) { - video_crop_size_ = DesktopSize(video_crop->width, video_crop->height); - } else { - video_crop_size_.reset(); - } - } else { - video_crop_size_.reset(); - } - - size_t frame_size; - if (video_crop_size_) { - frame_size = - video_crop_size_->width() * video_crop_size_->height() * kBytesPerPixel; - } else { - frame_size = - desktop_size_.width() * desktop_size_.height() * kBytesPerPixel; - } - - if (!current_frame_ || - (video_crop_size_ && !video_crop_size_->equals(prev_crop_size)) || - (!video_crop_size_ && !prev_crop_size.is_empty())) { - current_frame_ = std::make_unique(frame_size); - } - RTC_DCHECK(current_frame_ != nullptr); - - const int32_t dstStride = video_crop_size_ - ? video_crop_size_->width() * kBytesPerPixel - : desktop_size_.width() * kBytesPerPixel; - const int32_t srcStride = spaBuffer->datas[0].chunk->stride; - - if (srcStride != (desktop_size_.width() * kBytesPerPixel)) { - RTC_LOG(LS_ERROR) << "Got buffer with stride different from screen stride: " - << srcStride - << " != " << (desktop_size_.width() * kBytesPerPixel); - pipewire_init_failed_ = true; - return; - } - - dst = current_frame_.get(); - - // Adjust source content based on crop video position - if (video_crop_size_ && - (video_crop->y + video_crop_size_->height() <= desktop_size_.height())) { - for (int i = 0; i < video_crop->y; ++i) { - src += srcStride; - } - } - - const int xOffset = - video_crop_size_ && (video_crop->x + video_crop_size_->width() <= - desktop_size_.width()) - ? video_crop->x * kBytesPerPixel - : 0; - const int height = video_crop_size_.value_or(desktop_size_).height(); - for (int i = 0; i < height; ++i) { - // Adjust source content based on crop video position if needed - src += xOffset; - std::memcpy(dst, src, dstStride); - // If both sides decided to go with the RGBx format we need to convert it to - // BGRx to match color format expected by WebRTC. - if (spa_video_format_->format == pw_type_->video_format.RGBx || - spa_video_format_->format == pw_type_->video_format.RGBA) { - ConvertRGBToBGR(dst, dstStride); - } - src += srcStride - xOffset; - dst += dstStride; - } - - if (map) { - if (spaBuffer->datas[0].type == pw_core_type_->data.DmaBuf) { - SyncDmaBuf(spaBuffer->datas[0].fd, DMA_BUF_SYNC_END); - } - munmap(map, spaBuffer->datas[0].maxsize + spaBuffer->datas[0].mapoffset); - } -} - -void PipeWireBase::ConvertRGBToBGR(uint8_t* frame, uint32_t size) { - // Change color format for KDE KWin which uses RGBx and not BGRx - for (uint32_t i = 0; i < size; i += 4) { - uint8_t tempR = frame[i]; - uint8_t tempB = frame[i + 2]; - frame[i] = tempB; - frame[i + 2] = tempR; - } -} - -} // namespace webrtc diff --git a/modules/desktop_capture/linux/pipewire_base.h b/modules/desktop_capture/linux/pipewire_base.h deleted file mode 100644 index 5900b58bca..0000000000 --- a/modules/desktop_capture/linux/pipewire_base.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright 2020 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef MODULES_DESKTOP_CAPTURE_LINUX_PIPEWIRE_BASE_H_ -#define MODULES_DESKTOP_CAPTURE_LINUX_PIPEWIRE_BASE_H_ - -#define typeof __typeof__ -#include -#include - -#include - -#include "modules/desktop_capture/desktop_geometry.h" - -#include "absl/types/optional.h" -#include "api/ref_counted_base.h" -#include "rtc_base/constructor_magic.h" - -namespace webrtc { - -class PipeWireType { - public: - spa_type_media_type media_type; - spa_type_media_subtype media_subtype; - spa_type_format_video format_video; - spa_type_video_format video_format; -}; - -class PipeWireBase : public rtc::RefCountedBase { - public: - explicit PipeWireBase(int32_t fd); - ~PipeWireBase(); - - uint8_t* Frame() const; - DesktopSize FrameSize() const; - - private: - pw_core* pw_core_ = nullptr; - pw_type* pw_core_type_ = nullptr; - pw_stream* pw_stream_ = nullptr; - pw_remote* pw_remote_ = nullptr; - pw_loop* pw_loop_ = nullptr; - pw_thread_loop* pw_main_loop_ = nullptr; - PipeWireType* pw_type_ = nullptr; - - spa_hook spa_stream_listener_ = {}; - spa_hook spa_remote_listener_ = {}; - - pw_stream_events pw_stream_events_ = {}; - pw_remote_events pw_remote_events_ = {}; - - spa_video_info_raw* spa_video_format_ = nullptr; - - int32_t pw_fd_ = -1; - - absl::optional video_crop_size_; - DesktopSize desktop_size_ = {}; - - bool pipewire_init_failed_ = false; - - std::unique_ptr current_frame_; - - void InitPipeWireTypes(); - - void CreateReceivingStream(); - void HandleBuffer(pw_buffer* buffer); - - void ConvertRGBToBGR(uint8_t* frame, uint32_t size); - - static void SyncDmaBuf(int fd, uint64_t start_or_end); - - static void OnStateChanged(void* data, - pw_remote_state old_state, - pw_remote_state state, - const char* error); - static void OnStreamStateChanged(void* data, - pw_stream_state old_state, - pw_stream_state state, - const char* error_message); - - static void OnStreamFormatChanged(void* data, const struct spa_pod* format); - static void OnStreamProcess(void* data); - static void OnNewBuffer(void* data, uint32_t id); -}; - -} // namespace webrtc - -#endif // MODULES_DESKTOP_CAPTURE_LINUX_PIPEWIRE_BASE_H_ diff --git a/modules/desktop_capture/linux/screen_capturer_pipewire.cc b/modules/desktop_capture/linux/screen_capturer_pipewire.cc new file mode 100644 index 0000000000..fe672140cc --- /dev/null +++ b/modules/desktop_capture/linux/screen_capturer_pipewire.cc @@ -0,0 +1,29 @@ +/* + * Copyright 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/desktop_capture/linux/screen_capturer_pipewire.h" + +#include + + +namespace webrtc { + +ScreenCapturerPipeWire::ScreenCapturerPipeWire() + : BaseCapturerPipeWire(BaseCapturerPipeWire::CaptureSourceType::Screen) {} +ScreenCapturerPipeWire::~ScreenCapturerPipeWire() {} + +// static +std::unique_ptr +ScreenCapturerPipeWire::CreateRawScreenCapturer( + const DesktopCaptureOptions& options) { + return std::make_unique(); +} + +} // namespace webrtc diff --git a/modules/desktop_capture/linux/screen_capturer_pipewire.h b/modules/desktop_capture/linux/screen_capturer_pipewire.h new file mode 100644 index 0000000000..66dcd680e0 --- /dev/null +++ b/modules/desktop_capture/linux/screen_capturer_pipewire.h @@ -0,0 +1,33 @@ +/* + * Copyright 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_DESKTOP_CAPTURE_LINUX_SCREEN_CAPTURER_PIPEWIRE_H_ +#define MODULES_DESKTOP_CAPTURE_LINUX_SCREEN_CAPTURER_PIPEWIRE_H_ + +#include + +#include "modules/desktop_capture/linux/base_capturer_pipewire.h" + +namespace webrtc { + +class ScreenCapturerPipeWire : public BaseCapturerPipeWire { + public: + ScreenCapturerPipeWire(); + ~ScreenCapturerPipeWire() override; + + static std::unique_ptr CreateRawScreenCapturer( + const DesktopCaptureOptions& options); + + RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerPipeWire); +}; + +} // namespace webrtc + +#endif // MODULES_DESKTOP_CAPTURE_LINUX_SCREEN_CAPTURER_PIPEWIRE_H_ diff --git a/modules/desktop_capture/linux/window_capturer_pipewire.cc b/modules/desktop_capture/linux/window_capturer_pipewire.cc new file mode 100644 index 0000000000..b4559156dc --- /dev/null +++ b/modules/desktop_capture/linux/window_capturer_pipewire.cc @@ -0,0 +1,29 @@ +/* + * Copyright 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/desktop_capture/linux/window_capturer_pipewire.h" + +#include + + +namespace webrtc { + +WindowCapturerPipeWire::WindowCapturerPipeWire() + : BaseCapturerPipeWire(BaseCapturerPipeWire::CaptureSourceType::Window) {} +WindowCapturerPipeWire::~WindowCapturerPipeWire() {} + +// static +std::unique_ptr +WindowCapturerPipeWire::CreateRawWindowCapturer( + const DesktopCaptureOptions& options) { + return std::make_unique(); +} + +} // namespace webrtc diff --git a/modules/desktop_capture/linux/window_capturer_pipewire.h b/modules/desktop_capture/linux/window_capturer_pipewire.h new file mode 100644 index 0000000000..7f184ef299 --- /dev/null +++ b/modules/desktop_capture/linux/window_capturer_pipewire.h @@ -0,0 +1,33 @@ +/* + * Copyright 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_DESKTOP_CAPTURE_LINUX_WINDOW_CAPTURER_PIPEWIRE_H_ +#define MODULES_DESKTOP_CAPTURE_LINUX_WINDOW_CAPTURER_PIPEWIRE_H_ + +#include + +#include "modules/desktop_capture/linux/base_capturer_pipewire.h" + +namespace webrtc { + +class WindowCapturerPipeWire : public BaseCapturerPipeWire { + public: + WindowCapturerPipeWire(); + ~WindowCapturerPipeWire() override; + + static std::unique_ptr CreateRawWindowCapturer( + const DesktopCaptureOptions& options); + + RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerPipeWire); +}; + +} // namespace webrtc + +#endif // MODULES_DESKTOP_CAPTURE_LINUX_WINDOW_CAPTURER_PIPEWIRE_H_ diff --git a/modules/desktop_capture/linux/xdg_desktop_portal_base.cc b/modules/desktop_capture/linux/xdg_desktop_portal_base.cc deleted file mode 100644 index 0c7e693056..0000000000 --- a/modules/desktop_capture/linux/xdg_desktop_portal_base.cc +++ /dev/null @@ -1,813 +0,0 @@ -/* - * Copyright 2020 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include "modules/desktop_capture/linux/xdg_desktop_portal_base.h" - -#include - -#include - -#include "rtc_base/checks.h" -#include "rtc_base/logging.h" - -namespace webrtc { - -const char kDesktopBusName[] = "org.freedesktop.portal.Desktop"; -const char kDesktopObjectPath[] = "/org/freedesktop/portal/desktop"; -const char kDesktopRequestObjectPath[] = - "/org/freedesktop/portal/desktop/request"; -const char kSessionInterfaceName[] = "org.freedesktop.portal.Session"; -const char kRequestInterfaceName[] = "org.freedesktop.portal.Request"; -const char kScreenCastInterfaceName[] = "org.freedesktop.portal.ScreenCast"; - -template -class Scoped { - public: - Scoped() {} - explicit Scoped(T* val) { ptr_ = val; } - ~Scoped() { RTC_NOTREACHED(); } - - T* operator->() { return ptr_; } - - bool operator!() { return ptr_ == nullptr; } - - T* get() { return ptr_; } - - T** receive() { - RTC_CHECK(!ptr_); - return &ptr_; - } - - Scoped& operator=(T* val) { - ptr_ = val; - return *this; - } - - protected: - T* ptr_ = nullptr; -}; - -template <> -Scoped::~Scoped() { - if (ptr_) { - g_error_free(ptr_); - } -} - -template <> -Scoped::~Scoped() { - if (ptr_) { - g_free(ptr_); - } -} - -template <> -Scoped::~Scoped() { - if (ptr_) { - g_variant_unref(ptr_); - } -} - -template <> -Scoped::~Scoped() { - if (ptr_) { - g_variant_iter_free(ptr_); - } -} - -template <> -Scoped::~Scoped() { - if (ptr_) { - g_object_unref(ptr_); - } -} - -template <> -Scoped::~Scoped() { - if (ptr_) { - g_object_unref(ptr_); - } -} - -ConnectionData::ConnectionData(int32_t id) : id_(id) {} - -ConnectionData::~ConnectionData() { - if (start_request_signal_id_) { - g_dbus_connection_signal_unsubscribe(connection_, start_request_signal_id_); - start_request_signal_id_ = 0; - } - if (sources_request_signal_id_) { - g_dbus_connection_signal_unsubscribe(connection_, - sources_request_signal_id_); - sources_request_signal_id_ = 0; - } - if (session_request_signal_id_) { - g_dbus_connection_signal_unsubscribe(connection_, - session_request_signal_id_); - session_request_signal_id_ = 0; - } - - if (session_handle_) { - Scoped message(g_dbus_message_new_method_call( - kDesktopBusName, session_handle_, kSessionInterfaceName, "Close")); - if (message.get()) { - Scoped error; - g_dbus_connection_send_message(connection_, message.get(), - G_DBUS_SEND_MESSAGE_FLAGS_NONE, - /*out_serial=*/nullptr, error.receive()); - if (error.get()) { - RTC_LOG(LS_ERROR) << "Failed to close the session: " << error->message; - } - } - } - - g_free(start_handle_); - start_handle_ = nullptr; - g_free(sources_handle_); - sources_handle_ = nullptr; - g_free(session_handle_); - session_handle_ = nullptr; - g_free(portal_handle_); - portal_handle_ = nullptr; - - if (proxy_) { - g_clear_object(&proxy_); - proxy_ = nullptr; - } - - g_object_unref(connection_); - connection_ = nullptr; - - // Restore to initial values - id_ = 0; - stream_id_ = 0; - pw_fd_ = -1; - portal_init_failed_ = false; -} - -XdgDesktopPortalBase::XdgDesktopPortalBase() {} - -XdgDesktopPortalBase::~XdgDesktopPortalBase() { - connection_data_map_.clear(); -} - -// static -rtc::scoped_refptr XdgDesktopPortalBase::CreateDefault() { - return new XdgDesktopPortalBase(); -} - -void XdgDesktopPortalBase::InitPortal( - rtc::Callback1 callback, - XdgDesktopPortalBase::CaptureSourceType requested_type, - int32_t id) { - if (!id) { - callback(false); - return; - } - - auto data = GetConnectionData(id); - - if (data) { - data->callbacks_.push_back(callback); - return; - } - - std::unique_ptr connection_data(new ConnectionData(id)); - connection_data->callbacks_.push_back(callback); - connection_data->requested_source_type_ = requested_type; - - connection_data_map_.insert({id, std::move(connection_data)}); - - g_dbus_proxy_new_for_bus( - G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, /*info=*/nullptr, - kDesktopBusName, kDesktopObjectPath, kScreenCastInterfaceName, - /*cancellable=*/nullptr, - reinterpret_cast(OnProxyRequested), - new UserData(id, this)); -} - -bool XdgDesktopPortalBase::IsConnectionInitialized( - const absl::optional& id) const { - auto connection_data = GetConnectionData(id); - - if (!connection_data) { - return false; - } - - if (connection_data->portal_init_failed_) { - return false; - } - - if (connection_data->pw_fd_ == -1) { - return false; - } - - return true; -} - -bool XdgDesktopPortalBase::IsConnectionStreamingOnWeb( - const absl::optional& id) const { - auto connection_data = GetConnectionData(id); - - if (!connection_data) { - return false; - } - - return connection_data->web_streaming_; -} - -PipeWireBase* XdgDesktopPortalBase::GetPipeWireBase( - const absl::optional& id) const { - int32_t valid_id = id.value_or(current_connection_id_.value_or(0)); - - auto connection_data = GetConnectionData(valid_id); - RTC_CHECK(connection_data); - - if (!connection_data->pw_base_) { - return nullptr; - } - - auto pwBase = connection_data->pw_base_.get(); - - // Assume this call/connection has been already used when someone asks for - // PipeWireBase which we use to guess we already stream to the web page itself - // and not to the preview dialog - if (!connection_data->already_used_ && pwBase && pwBase->Frame()) { - connection_data->already_used_ = true; - } - - return pwBase; -} - -ConnectionData* XdgDesktopPortalBase::GetConnectionData( - const absl::optional& id) const { - int32_t valid_id = id.value_or(current_connection_id_.value_or(0)); - - auto search = connection_data_map_.find(valid_id); - if (search != connection_data_map_.end()) { - return search->second.get(); - } - - return nullptr; -} - -absl::optional XdgDesktopPortalBase::CurrentConnectionId() const { - return current_connection_id_; -} - -void XdgDesktopPortalBase::SetCurrentConnectionId( - const absl::optional& id) { - current_connection_id_ = id; -} - -guint XdgDesktopPortalBase::SetupRequestResponseSignal( - const gchar* object_path, - GDBusSignalCallback callback, - UserData* data) { - auto connection_data = GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - return g_dbus_connection_signal_subscribe( - connection_data->connection_, kDesktopBusName, kRequestInterfaceName, - "Response", object_path, /*arg0=*/nullptr, - G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE, callback, data, - /*user_data_free_func=*/nullptr); -} - -// static -void XdgDesktopPortalBase::OnProxyRequested(GObject* /*object*/, - GAsyncResult* result, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - Scoped error; - connection_data->proxy_ = g_dbus_proxy_new_finish(result, error.receive()); - if (!connection_data->proxy_) { - RTC_LOG(LS_ERROR) << "Failed to create a proxy for the screen cast portal: " - << error->message; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - connection_data->connection_ = - g_dbus_proxy_get_connection(connection_data->proxy_); - - RTC_LOG(LS_INFO) << "Created proxy for the screen cast portal."; - portal_base->SessionRequest(data); -} - -// static -gchar* XdgDesktopPortalBase::PrepareSignalHandle(GDBusConnection* connection, - const gchar* token) { - Scoped sender( - g_strdup(g_dbus_connection_get_unique_name(connection) + 1)); - for (int i = 0; sender.get()[i]; i++) { - if (sender.get()[i] == '.') { - sender.get()[i] = '_'; - } - } - - gchar* handle = g_strconcat(kDesktopRequestObjectPath, "/", sender.get(), "/", - token, /*end of varargs*/ nullptr); - - return handle; -} - -void XdgDesktopPortalBase::SessionRequest(UserData* data) { - auto connection_data = GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - GVariantBuilder builder; - Scoped variant_string; - - g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); - variant_string = - g_strdup_printf("webrtc_session%d", g_random_int_range(0, G_MAXINT)); - g_variant_builder_add(&builder, "{sv}", "session_handle_token", - g_variant_new_string(variant_string.get())); - - variant_string = g_strdup_printf("webrtc%d", g_random_int_range(0, G_MAXINT)); - g_variant_builder_add(&builder, "{sv}", "handle_token", - g_variant_new_string(variant_string.get())); - - connection_data->portal_handle_ = - PrepareSignalHandle(connection_data->connection_, variant_string.get()); - connection_data->session_request_signal_id_ = SetupRequestResponseSignal( - connection_data->portal_handle_, OnSessionRequestResponseSignal, data); - - RTC_LOG(LS_INFO) << "Screen cast session requested."; - g_dbus_proxy_call(connection_data->proxy_, "CreateSession", - g_variant_new("(a{sv})", &builder), G_DBUS_CALL_FLAGS_NONE, - /*timeout=*/-1, /*cancellable=*/nullptr, - reinterpret_cast(OnSessionRequested), - data); -} - -// static -void XdgDesktopPortalBase::OnSessionRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - Scoped error; - Scoped variant(g_dbus_proxy_call_finish(connection_data->proxy_, - result, error.receive())); - if (!variant) { - RTC_LOG(LS_ERROR) << "Failed to create a screen cast session: " - << error->message; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - RTC_LOG(LS_INFO) << "Initializing the screen cast session."; - - Scoped handle; - g_variant_get_child(variant.get(), 0, "o", handle.receive()); - if (!handle) { - RTC_LOG(LS_ERROR) << "Failed to initialize the screen cast session."; - if (connection_data->session_request_signal_id_) { - g_dbus_connection_signal_unsubscribe( - connection, connection_data->session_request_signal_id_); - connection_data->session_request_signal_id_ = 0; - } - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - RTC_LOG(LS_INFO) << "Subscribing to the screen cast session."; -} - -// static -void XdgDesktopPortalBase::OnSessionRequestResponseSignal( - GDBusConnection* connection, - const gchar* sender_name, - const gchar* object_path, - const gchar* interface_name, - const gchar* signal_name, - GVariant* parameters, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - RTC_LOG(LS_INFO) - << "Received response for the screen cast session subscription."; - - guint32 portal_response; - Scoped response_data; - g_variant_get(parameters, "(u@a{sv})", &portal_response, - response_data.receive()); - g_variant_lookup(response_data.get(), "session_handle", "s", - &connection_data->session_handle_); - - if (!connection_data->session_handle_ || portal_response) { - RTC_LOG(LS_ERROR) - << "Failed to request the screen cast session subscription."; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - return; - } - - portal_base->SourcesRequest(data); -} - -void XdgDesktopPortalBase::SourcesRequest(UserData* data) { - auto connection_data = GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - GVariantBuilder builder; - Scoped variant_string; - - g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); - // We want to record monitor content. - g_variant_builder_add(&builder, "{sv}", "types", - g_variant_new_uint32(static_cast( - connection_data->requested_source_type_))); - // We don't want to allow selection of multiple sources. - g_variant_builder_add(&builder, "{sv}", "multiple", - g_variant_new_boolean(false)); - variant_string = g_strdup_printf("webrtc%d", g_random_int_range(0, G_MAXINT)); - g_variant_builder_add(&builder, "{sv}", "handle_token", - g_variant_new_string(variant_string.get())); - - connection_data->sources_handle_ = - PrepareSignalHandle(connection_data->connection_, variant_string.get()); - connection_data->sources_request_signal_id_ = SetupRequestResponseSignal( - connection_data->sources_handle_, OnSourcesRequestResponseSignal, data); - - RTC_LOG(LS_INFO) << "Requesting sources from the screen cast session."; - g_dbus_proxy_call( - connection_data->proxy_, "SelectSources", - g_variant_new("(oa{sv})", connection_data->session_handle_, &builder), - G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, /*cancellable=*/nullptr, - reinterpret_cast(OnSourcesRequested), data); -} - -// static -void XdgDesktopPortalBase::OnSourcesRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - Scoped error; - Scoped variant(g_dbus_proxy_call_finish(connection_data->proxy_, - result, error.receive())); - if (!variant) { - RTC_LOG(LS_ERROR) << "Failed to request the sources: " << error->message; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - RTC_LOG(LS_INFO) << "Sources requested from the screen cast session."; - - Scoped handle; - g_variant_get_child(variant.get(), 0, "o", handle.receive()); - if (!handle) { - RTC_LOG(LS_ERROR) << "Failed to initialize the screen cast session."; - if (connection_data->sources_request_signal_id_) { - g_dbus_connection_signal_unsubscribe( - connection, connection_data->sources_request_signal_id_); - connection_data->sources_request_signal_id_ = 0; - } - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - RTC_LOG(LS_INFO) << "Subscribed to sources signal."; -} - -// static -void XdgDesktopPortalBase::OnSourcesRequestResponseSignal( - GDBusConnection* connection, - const gchar* sender_name, - const gchar* object_path, - const gchar* interface_name, - const gchar* signal_name, - GVariant* parameters, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - RTC_LOG(LS_INFO) << "Received sources signal from session."; - - guint32 portal_response; - g_variant_get(parameters, "(u@a{sv})", &portal_response, nullptr); - if (portal_response) { - RTC_LOG(LS_ERROR) - << "Failed to select sources for the screen cast session."; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - portal_base->StartRequest(data); -} - -void XdgDesktopPortalBase::StartRequest(UserData* data) { - auto connection_data = GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - GVariantBuilder builder; - Scoped variant_string; - - g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); - variant_string = g_strdup_printf("webrtc%d", g_random_int_range(0, G_MAXINT)); - g_variant_builder_add(&builder, "{sv}", "handle_token", - g_variant_new_string(variant_string.get())); - - connection_data->start_handle_ = - PrepareSignalHandle(connection_data->connection_, variant_string.get()); - connection_data->start_request_signal_id_ = SetupRequestResponseSignal( - connection_data->start_handle_, OnStartRequestResponseSignal, data); - - // "Identifier for the application window", this is Wayland, so not "x11:...". - const gchar parent_window[] = ""; - - RTC_LOG(LS_INFO) << "Starting the screen cast session."; - g_dbus_proxy_call( - connection_data->proxy_, "Start", - g_variant_new("(osa{sv})", connection_data->session_handle_, - parent_window, &builder), - G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, /*cancellable=*/nullptr, - reinterpret_cast(OnStartRequested), data); -} - -// static -void XdgDesktopPortalBase::OnStartRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - Scoped error; - Scoped variant(g_dbus_proxy_call_finish(connection_data->proxy_, - result, error.receive())); - if (!variant) { - RTC_LOG(LS_ERROR) << "Failed to start the screen cast session: " - << error->message; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - RTC_LOG(LS_INFO) << "Initializing the start of the screen cast session."; - - gchar* handle = nullptr; - g_variant_get_child(variant.get(), 0, "o", &handle); - if (!handle) { - RTC_LOG(LS_ERROR) - << "Failed to initialize the start of the screen cast session."; - if (connection_data->start_request_signal_id_) { - g_dbus_connection_signal_unsubscribe( - connection, connection_data->start_request_signal_id_); - connection_data->start_request_signal_id_ = 0; - } - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - RTC_LOG(LS_INFO) << "Subscribed to the start signal."; -} - -// static -void XdgDesktopPortalBase::OnStartRequestResponseSignal( - GDBusConnection* connection, - const gchar* sender_name, - const gchar* object_path, - const gchar* interface_name, - const gchar* signal_name, - GVariant* parameters, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - RTC_LOG(LS_INFO) << "Start signal received."; - guint32 portal_response; - Scoped response_data; - Scoped iter; - g_variant_get(parameters, "(u@a{sv})", &portal_response, - response_data.receive()); - if (portal_response || !response_data) { - RTC_LOG(LS_ERROR) << "Failed to start the screen cast session."; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - // Array of PipeWire streams. See - // https://github.com/flatpak/xdg-desktop-portal/blob/master/data/org.freedesktop.portal.ScreenCast.xml - // documentation for . - if (g_variant_lookup(response_data.get(), "streams", "a(ua{sv})", - iter.receive())) { - Scoped variant; - - while (g_variant_iter_next(iter.get(), "@(ua{sv})", variant.receive())) { - guint32 stream_id; - gint32 width; - gint32 height; - guint32 type; - Scoped options; - - g_variant_get(variant.get(), "(u@a{sv})", &stream_id, options.receive()); - RTC_DCHECK(options.get()); - - g_variant_lookup(options.get(), "size", "(ii)", &width, &height); - - if (g_variant_lookup(options.get(), "source_type", "u", &type)) { - connection_data->capture_source_type_ = - static_cast(type); - } - connection_data->desktop_size_.set(width, height); - connection_data->stream_id_ = stream_id; - - break; - } - } - - portal_base->OpenPipeWireRemote(data); -} - -void XdgDesktopPortalBase::OpenPipeWireRemote(UserData* data) { - auto connection_data = GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - if (!connection_data) { - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - CloseConnection(connection_data->id_); - return; - } - - GVariantBuilder builder; - g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); - - RTC_LOG(LS_INFO) << "Opening the PipeWire remote."; - - g_dbus_proxy_call_with_unix_fd_list( - connection_data->proxy_, "OpenPipeWireRemote", - g_variant_new("(oa{sv})", connection_data->session_handle_, &builder), - G_DBUS_CALL_FLAGS_NONE, /*timeout=*/-1, /*fd_list=*/nullptr, - /*cancellable=*/nullptr, - reinterpret_cast(OnOpenPipeWireRemoteRequested), - data); -} - -// static -void XdgDesktopPortalBase::OnOpenPipeWireRemoteRequested( - GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data) { - UserData* data = static_cast(user_data); - RTC_DCHECK(data); - - auto* portal_base = data->GetXdgDesktopPortalBase(); - RTC_CHECK(portal_base); - - auto connection_data = portal_base->GetConnectionData(data->GetDataId()); - RTC_CHECK(connection_data); - - Scoped error; - Scoped outlist; - Scoped variant(g_dbus_proxy_call_with_unix_fd_list_finish( - connection_data->proxy_, outlist.receive(), result, error.receive())); - if (!variant) { - RTC_LOG(LS_ERROR) << "Failed to open the PipeWire remote: " - << error->message; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - gint32 index; - g_variant_get(variant.get(), "(h)", &index); - - if ((connection_data->pw_fd_ = - g_unix_fd_list_get(outlist.get(), index, error.receive())) == -1) { - RTC_LOG(LS_ERROR) << "Failed to get file descriptor from the list: " - << error->message; - connection_data->portal_init_failed_ = true; - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(false); - } - portal_base->CloseConnection(connection_data->id_); - return; - } - - connection_data->pw_base_ = - std::make_unique(connection_data->pw_fd_); - - for (rtc::Callback1& callback : connection_data->callbacks_) { - callback(true); - } -} - -void XdgDesktopPortalBase::CloseConnection(const absl::optional& id) { - auto connection_data = GetConnectionData(id); - - if (!connection_data) { - return; - } - - connection_data_map_.erase(connection_data->id_); -} - -void XdgDesktopPortalBase::SetConnectionStreamingOnWeb( - const absl::optional& id) { - auto connection_data = GetConnectionData(id); - - if (!connection_data) { - return; - } - - connection_data->web_streaming_ = true; -} - -} // namespace webrtc diff --git a/modules/desktop_capture/linux/xdg_desktop_portal_base.h b/modules/desktop_capture/linux/xdg_desktop_portal_base.h deleted file mode 100644 index 829cbf9464..0000000000 --- a/modules/desktop_capture/linux/xdg_desktop_portal_base.h +++ /dev/null @@ -1,201 +0,0 @@ -/* - * Copyright 2020 The WebRTC project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef MODULES_DESKTOP_CAPTURE_LINUX_XDG_DESKTOP_PORTAL_BASE_H_ -#define MODULES_DESKTOP_CAPTURE_LINUX_XDG_DESKTOP_PORTAL_BASE_H_ - -#include - -#include -#include -#include - -#include "modules/desktop_capture/desktop_geometry.h" -#include "modules/desktop_capture/linux/pipewire_base.h" - -#include "api/ref_counted_base.h" -#include "api/scoped_refptr.h" -#include "rtc_base/callback.h" -#include "rtc_base/constructor_magic.h" - -namespace webrtc { - -struct ConnectionData; -class UserData; - -class RTC_EXPORT XdgDesktopPortalBase : public rtc::RefCountedBase { - public: - enum class CaptureSourceType : uint32_t { - kScreen = 0b01, - kWindow = 0b10, - kAny = 0b11 - }; - - XdgDesktopPortalBase(); - ~XdgDesktopPortalBase(); - - static rtc::scoped_refptr CreateDefault(); - - // Initializes a screen sharing request for a web page identified with a - // id. This id is later used to associate it with ConnectionData structure - // where we keep all the necessary information about the DBus communication. - // - // This starts a series of DBus calls: - // 1) SessionRequest - requests a session, which will be associated with - // this screen sharing request, passing a handle for identification so - // we can watch for success/failure. - // 2) SourceRequest - requests what content we want to share on given - // session (either monitor, screen or both) - // 3) StartRequest - requests to - // start sharing, which in return will give us information about stream - // (stream id and resolution). - // 4) OpenPipeWireRemote - requests a file descriptor which we can use - // for initialization of PipeWire on the client side and start receiving - // content. - void InitPortal(rtc::Callback1 callback, - XdgDesktopPortalBase::CaptureSourceType requested_type, - int32_t id); - - void CloseConnection(const absl::optional& id); - void SetConnectionStreamingOnWeb(const absl::optional& id); - - bool IsConnectionInitialized(const absl::optional& id) const; - bool IsConnectionStreamingOnWeb(const absl::optional& id) const; - - PipeWireBase* GetPipeWireBase(const absl::optional& id) const; - - // Current ID serves for the DesktopCapturerOption to identify portal call - // from the client itself so we can skip an additional call which would be - // made upon preview dialog confirmation (e.g. Chromium). - absl::optional CurrentConnectionId() const; - void SetCurrentConnectionId(const absl::optional& id); - - ConnectionData* GetConnectionData(const absl::optional& id) const; - - private: - // Methods are defined in the same order in which they are being called - guint SetupRequestResponseSignal(const gchar* object_path, - GDBusSignalCallback callback, - UserData* data); - - static void OnProxyRequested(GObject* object, - GAsyncResult* result, - gpointer user_data); - - static gchar* PrepareSignalHandle(GDBusConnection* connection, - const gchar* token); - - void SessionRequest(UserData* data); - static void OnSessionRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data); - static void OnSessionRequestResponseSignal(GDBusConnection* connection, - const gchar* sender_name, - const gchar* object_path, - const gchar* interface_name, - const gchar* signal_name, - GVariant* parameters, - gpointer user_data); - - void SourcesRequest(UserData* data); - static void OnSourcesRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data); - static void OnSourcesRequestResponseSignal(GDBusConnection* connection, - const gchar* sender_name, - const gchar* object_path, - const gchar* interface_name, - const gchar* signal_name, - GVariant* parameters, - gpointer user_data); - - void StartRequest(UserData* data); - static void OnStartRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data); - static void OnStartRequestResponseSignal(GDBusConnection* connection, - const gchar* sender_name, - const gchar* object_path, - const gchar* interface_name, - const gchar* signal_name, - GVariant* parameters, - gpointer user_data); - void OpenPipeWireRemote(UserData* data); - static void OnOpenPipeWireRemoteRequested(GDBusConnection* connection, - GAsyncResult* result, - gpointer user_data); - - absl::optional current_connection_id_; - std::map> connection_data_map_; - - RTC_DISALLOW_COPY_AND_ASSIGN(XdgDesktopPortalBase); -}; - -// This class represents each screen sharing request, which consists from a -// series of DBus calls, where we need to remember the session handle and -// parameters of the returned stream (id, resolution). -struct RTC_EXPORT ConnectionData { - explicit ConnectionData(int32_t id); - ~ConnectionData(); - - bool operator=(const int32_t id) { return id_ == id; } - - gint32 pw_fd_ = -1; - - XdgDesktopPortalBase::CaptureSourceType capture_source_type_ = - XdgDesktopPortalBase::CaptureSourceType::kAny; - XdgDesktopPortalBase::CaptureSourceType requested_source_type_ = - XdgDesktopPortalBase::CaptureSourceType::kAny; - - GDBusConnection* connection_ = nullptr; - GDBusProxy* proxy_ = nullptr; - gchar* portal_handle_ = nullptr; - gchar* session_handle_ = nullptr; - gchar* sources_handle_ = nullptr; - gchar* start_handle_ = nullptr; - guint session_request_signal_id_ = 0; - guint sources_request_signal_id_ = 0; - guint start_request_signal_id_ = 0; - - DesktopSize desktop_size_ = {}; - guint32 stream_id_ = 0; - - int32_t id_; - - bool already_used_ = false; - bool portal_init_failed_ = false; - bool web_streaming_ = false; - std::vector> callbacks_; - rtc::Callback2 pw_callback_; - - std::unique_ptr pw_base_; -}; - -// Structure which is used as user_data property in GLib async calls, where we -// need to pass two values. One is ID of the web page requesting screen sharing -// and the other is pointer to the XdgDesktopPortalBase object. -class UserData { - public: - UserData(int32_t id, XdgDesktopPortalBase* xdp) { - data_id_ = id; - xdp_ = xdp; - } - - int32_t GetDataId() const { return data_id_; } - XdgDesktopPortalBase* GetXdgDesktopPortalBase() const { return xdp_; } - - private: - int32_t data_id_ = 0; - XdgDesktopPortalBase* xdp_ = nullptr; -}; - -} // namespace webrtc - -#endif // MODULES_DESKTOP_CAPTURE_LINUX_XDG_DESKTOP_PORTAL_BASE_H_ diff --git a/modules/desktop_capture/screen_capturer_linux.cc b/modules/desktop_capture/screen_capturer_linux.cc index 71a81b9363..82dbae4813 100644 --- a/modules/desktop_capture/screen_capturer_linux.cc +++ b/modules/desktop_capture/screen_capturer_linux.cc @@ -14,7 +14,7 @@ #include "modules/desktop_capture/desktop_capturer.h" #if defined(WEBRTC_USE_PIPEWIRE) -#include "modules/desktop_capture/linux/base_capturer_pipewire.h" +#include "modules/desktop_capture/linux/screen_capturer_pipewire.h" #endif // defined(WEBRTC_USE_PIPEWIRE) #if defined(WEBRTC_USE_X11) @@ -28,7 +28,7 @@ std::unique_ptr DesktopCapturer::CreateRawScreenCapturer( const DesktopCaptureOptions& options) { #if defined(WEBRTC_USE_PIPEWIRE) if (options.allow_pipewire() && DesktopCapturer::IsRunningUnderWayland()) { - return BaseCapturerPipeWire::CreateRawScreenCapturer(options); + return ScreenCapturerPipeWire::CreateRawScreenCapturer(options); } #endif // defined(WEBRTC_USE_PIPEWIRE) diff --git a/modules/desktop_capture/window_capturer_linux.cc b/modules/desktop_capture/window_capturer_linux.cc index c0b6154621..41dbf836b0 100644 --- a/modules/desktop_capture/window_capturer_linux.cc +++ b/modules/desktop_capture/window_capturer_linux.cc @@ -14,7 +14,7 @@ #include "modules/desktop_capture/desktop_capturer.h" #if defined(WEBRTC_USE_PIPEWIRE) -#include "modules/desktop_capture/linux/base_capturer_pipewire.h" +#include "modules/desktop_capture/linux/window_capturer_pipewire.h" #endif // defined(WEBRTC_USE_PIPEWIRE) #if defined(WEBRTC_USE_X11) @@ -28,7 +28,7 @@ std::unique_ptr DesktopCapturer::CreateRawWindowCapturer( const DesktopCaptureOptions& options) { #if defined(WEBRTC_USE_PIPEWIRE) if (options.allow_pipewire() && DesktopCapturer::IsRunningUnderWayland()) { - return BaseCapturerPipeWire::CreateRawWindowCapturer(options); + return WindowCapturerPipeWire::CreateRawWindowCapturer(options); } #endif // defined(WEBRTC_USE_PIPEWIRE)