Bug#1005824: QtWebEngine: build with pipewire support
Control: affects -1 + qutebrowser
Control: tags -1 + patch
On Tue, 15 Feb 2022 22:31:33 +0530 Pirate Praveen <praveen@onenetbeyond.org> wrote:
> Hi! I have seen https://mail.kde.org/pipermail/falkon/2022-February/000869.html – FYI, whether screensharing works under Wayland or not depends on how QtWebEngine is built, see: https://github.com/qutebrowser/qutebrowser/issues/5421
>
> Looking at the Fedora package, it is not currently built with Pipewire, so no way it will work on Fedora. But that is not Falkon's fault. We need to fix our QtWebEngine package.
>
> It is the same for other affected distros.
>
> That said, whether it will work then or hit other bugs, I cannot tell, since we have not enabled it yet.
Patch (thanks to ArchLinux [1]) in attachment works under pipewire + wayland + qutebrowser.
[1] https://github.com/archlinux/svntogit-packages/commit/5d4742100b9ddbcf4f374276335bb42dfcc5423d
--
Cédric Hannotier
>From f238e94bc767d0aedaf750ab1ab509ad70d7c673 Mon Sep 17 00:00:00 2001
Subject: [PATCH] Enable PipeWire screencasting
---
debian/control | 1 +
.../patches/qt5-webengine-pipewire-0.3.patch | 1824 +++++++++++++++++
debian/patches/series | 1 +
debian/rules | 1 +
4 files changed, 1827 insertions(+)
create mode 100644 debian/patches/qt5-webengine-pipewire-0.3.patch
diff --git a/debian/control b/debian/control
index 827e12c..6f4086f 100644
--- a/debian/control
+++ b/debian/control
@@ -39,6 +39,7 @@ Build-Depends: binutils (>= 2.32-8~),
libopenjp2-7-dev,
libopus-dev (>= 1.3.1),
libpci-dev,
+ libpipewire-0.3-dev,
libpng-dev,
libprotobuf-dev,
libpulse-dev,
diff --git a/debian/patches/qt5-webengine-pipewire-0.3.patch b/debian/patches/qt5-webengine-pipewire-0.3.patch
new file mode 100644
index 0000000..67b5a33
--- /dev/null
+++ b/debian/patches/qt5-webengine-pipewire-0.3.patch
@@ -0,0 +1,1824 @@
+Description: Enable WebRTC screen sharing through PipeWire
+Origin: https://github.com/archlinux/svntogit-packages/blob/packages/qt5-webengine/trunk/qt5-webengine-pipewire-0.3.patch
+Bug: 1005824
+Last-Update: 2023-02-06
+
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn
+index 5235512735d..8259442f811 100644
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn
++++ b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn
+@@ -11,6 +11,11 @@ import("//build/config/ui.gni")
+ import("//tools/generate_stubs/rules.gni")
+ import("../../webrtc.gni")
+
++if (rtc_use_pipewire) {
++ assert(rtc_pipewire_version == "0.2" || rtc_pipewire_version == "0.3",
++ "Unsupported PipeWire version")
++}
++
+ use_desktop_capture_differ_sse2 = current_cpu == "x86" || current_cpu == "x64"
+
+ config("x11_config") {
+@@ -200,22 +205,41 @@ if (is_linux || is_chromeos) {
+ ]
+ }
+
+- if (rtc_link_pipewire) {
++ if (rtc_pipewire_version == "0.3") {
+ pkg_config("pipewire") {
+- packages = [ "libpipewire-0.2" ]
++ packages = [ "libpipewire-0.3" ]
++ if (!rtc_link_pipewire) {
++ ignore_libs = true
++ }
+ }
+ } else {
++ pkg_config("pipewire") {
++ packages = [ "libpipewire-0.2" ]
++ if (!rtc_link_pipewire) {
++ ignore_libs = true
++ }
++ }
++ }
++
++ if (!rtc_link_pipewire) {
+ # When libpipewire is not directly linked, use stubs to allow for dlopening of
+ # the binary.
+ generate_stubs("pipewire_stubs") {
+- configs = [ "../../:common_config" ]
++ configs = [
++ "../../:common_config",
++ ":pipewire",
++ ]
+ deps = [ "../../rtc_base" ]
+ extra_header = "linux/pipewire_stub_header.fragment"
+ logging_function = "RTC_LOG(LS_VERBOSE)"
+ logging_include = "rtc_base/logging.h"
+ output_name = "linux/pipewire_stubs"
+ path_from_source = "modules/desktop_capture/linux"
+- sigs = [ "linux/pipewire.sigs" ]
++ if (rtc_pipewire_version == "0.3") {
++ sigs = [ "linux/pipewire03.sigs" ]
++ } else {
++ sigs = [ "linux/pipewire02.sigs" ]
++ }
+ }
+ }
+
+@@ -506,6 +530,7 @@ 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) {
+@@ -526,20 +551,15 @@ rtc_library("desktop_capture_generic") {
+ sources += [
+ "linux/base_capturer_pipewire.cc",
+ "linux/base_capturer_pipewire.h",
+- "linux/screen_capturer_pipewire.cc",
+- "linux/screen_capturer_pipewire.h",
+- "linux/window_capturer_pipewire.cc",
+- "linux/window_capturer_pipewire.h",
+ ]
+
+ configs += [
+ ":pipewire_config",
+ ":gio",
++ ":pipewire",
+ ]
+
+- if (rtc_link_pipewire) {
+- configs += [ ":pipewire" ]
+- } else {
++ if (!rtc_link_pipewire) {
+ deps += [ ":pipewire_stubs" ]
+ }
+ }
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc
+index 2640e93aa98..c302a086ead 100644
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc
++++ b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc
+@@ -14,8 +14,14 @@
+ #include <glib-object.h>
+ #include <spa/param/format-utils.h>
+ #include <spa/param/props.h>
++#if !PW_CHECK_VERSION(0, 3, 0)
+ #include <spa/param/video/raw-utils.h>
+ #include <spa/support/type-map.h>
++#endif
++
++#include <sys/ioctl.h>
++#include <sys/mman.h>
++#include <sys/syscall.h>
+
+ #include <memory>
+ #include <utility>
+@@ -30,7 +36,11 @@
+ #include "modules/desktop_capture/linux/pipewire_stubs.h"
+
+ using modules_desktop_capture_linux::InitializeStubs;
+-using modules_desktop_capture_linux::kModulePipewire;
++#if PW_CHECK_VERSION(0, 3, 0)
++using modules_desktop_capture_linux::kModulePipewire03;
++#else
++using modules_desktop_capture_linux::kModulePipewire02;
++#endif
+ using modules_desktop_capture_linux::StubPathMap;
+ #endif // defined(WEBRTC_DLOPEN_PIPEWIRE)
+
+@@ -47,9 +57,156 @@ const char kScreenCastInterfaceName[] = "org.freedesktop.portal.ScreenCast";
+ const int kBytesPerPixel = 4;
+
+ #if defined(WEBRTC_DLOPEN_PIPEWIRE)
++#if PW_CHECK_VERSION(0, 3, 0)
++const char kPipeWireLib[] = "libpipewire-0.3.so.0";
++#else
+ const char kPipeWireLib[] = "libpipewire-0.2.so.1";
+ #endif
++#endif
+
++// static
++struct dma_buf_sync {
++ uint64_t flags;
++};
++#define DMA_BUF_SYNC_READ (1 << 0)
++#define DMA_BUF_SYNC_START (0 << 2)
++#define DMA_BUF_SYNC_END (1 << 2)
++#define DMA_BUF_BASE 'b'
++#define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
++
++static void 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;
++ }
++ }
++}
++
++class ScopedBuf {
++ public:
++ ScopedBuf() {}
++ ScopedBuf(unsigned char* map, int map_size, bool is_dma_buf, int fd)
++ : map_(map), map_size_(map_size), is_dma_buf_(is_dma_buf), fd_(fd) {}
++ ~ScopedBuf() {
++ if (map_ != MAP_FAILED) {
++ if (is_dma_buf_) {
++ SyncDmaBuf(fd_, DMA_BUF_SYNC_END);
++ }
++ munmap(map_, map_size_);
++ }
++ }
++
++ operator bool() { return map_ != MAP_FAILED; }
++
++ void initialize(unsigned char* map, int map_size, bool is_dma_buf, int fd) {
++ map_ = map;
++ map_size_ = map_size;
++ is_dma_buf_ = is_dma_buf;
++ fd_ = fd;
++ }
++
++ unsigned char* get() { return map_; }
++
++ protected:
++ unsigned char* map_ = nullptr;
++ int map_size_;
++ bool is_dma_buf_;
++ int fd_;
++};
++
++template <class T>
++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<GError>::~Scoped() {
++ if (ptr_) {
++ g_error_free(ptr_);
++ }
++}
++
++template <>
++Scoped<gchar>::~Scoped() {
++ if (ptr_) {
++ g_free(ptr_);
++ }
++}
++
++template <>
++Scoped<GVariant>::~Scoped() {
++ if (ptr_) {
++ g_variant_unref(ptr_);
++ }
++}
++
++template <>
++Scoped<GVariantIter>::~Scoped() {
++ if (ptr_) {
++ g_variant_iter_free(ptr_);
++ }
++}
++
++template <>
++Scoped<GDBusMessage>::~Scoped() {
++ if (ptr_) {
++ g_object_unref(ptr_);
++ }
++}
++
++template <>
++Scoped<GUnixFDList>::~Scoped() {
++ if (ptr_) {
++ g_object_unref(ptr_);
++ }
++}
++
++#if PW_CHECK_VERSION(0, 3, 0)
++void BaseCapturerPipeWire::OnCoreError(void* data,
++ uint32_t id,
++ int seq,
++ int res,
++ const char* message) {
++ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);
++ RTC_DCHECK(that);
++
++ RTC_LOG(LS_ERROR) << "PipeWire remote error: " << message;
++}
++#else
+ // static
+ void BaseCapturerPipeWire::OnStateChanged(void* data,
+ pw_remote_state old_state,
+@@ -64,7 +221,7 @@ void BaseCapturerPipeWire::OnStateChanged(void* data,
+ break;
+ case PW_REMOTE_STATE_CONNECTED:
+ RTC_LOG(LS_INFO) << "PipeWire remote state: connected.";
+- that->CreateReceivingStream();
++ that->pw_stream_ = that->CreateReceivingStream();
+ break;
+ case PW_REMOTE_STATE_CONNECTING:
+ RTC_LOG(LS_INFO) << "PipeWire remote state: connecting.";
+@@ -74,6 +231,7 @@ void BaseCapturerPipeWire::OnStateChanged(void* data,
+ break;
+ }
+ }
++#endif
+
+ // static
+ void BaseCapturerPipeWire::OnStreamStateChanged(void* data,
+@@ -83,6 +241,18 @@ void BaseCapturerPipeWire::OnStreamStateChanged(void* data,
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);
+ RTC_DCHECK(that);
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ switch (state) {
++ case PW_STREAM_STATE_ERROR:
++ RTC_LOG(LS_ERROR) << "PipeWire stream state error: " << error_message;
++ break;
++ case PW_STREAM_STATE_PAUSED:
++ case PW_STREAM_STATE_STREAMING:
++ case PW_STREAM_STATE_UNCONNECTED:
++ case PW_STREAM_STATE_CONNECTING:
++ break;
++ }
++#else
+ switch (state) {
+ case PW_STREAM_STATE_ERROR:
+ RTC_LOG(LS_ERROR) << "PipeWire stream state error: " << error_message;
+@@ -97,36 +267,74 @@ void BaseCapturerPipeWire::OnStreamStateChanged(void* data,
+ case PW_STREAM_STATE_STREAMING:
+ break;
+ }
++#endif
+ }
+
+ // static
++#if PW_CHECK_VERSION(0, 3, 0)
++void BaseCapturerPipeWire::OnStreamParamChanged(void* data,
++ uint32_t id,
++ const struct spa_pod* format) {
++#else
+ void BaseCapturerPipeWire::OnStreamFormatChanged(void* data,
+ const struct spa_pod* format) {
++#endif
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);
+ RTC_DCHECK(that);
+
+ RTC_LOG(LS_INFO) << "PipeWire stream format changed.";
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (!format || id != SPA_PARAM_Format) {
++#else
+ if (!format) {
+ pw_stream_finish_format(that->pw_stream_, /*res=*/0, /*params=*/nullptr,
+ /*n_params=*/0);
++#endif
+ return;
+ }
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ spa_format_video_raw_parse(format, &that->spa_video_format_);
++#else
+ that->spa_video_format_ = new spa_video_info_raw();
+ spa_format_video_raw_parse(format, that->spa_video_format_,
+ &that->pw_type_->format_video);
++#endif
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ auto width = that->spa_video_format_.size.width;
++ auto height = that->spa_video_format_.size.height;
++#else
+ auto width = that->spa_video_format_->size.width;
+ auto height = that->spa_video_format_->size.height;
++#endif
+ 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[2];
++ const struct spa_pod* params[3];
++#if PW_CHECK_VERSION(0, 3, 0)
++ params[0] = reinterpret_cast<spa_pod*>(spa_pod_builder_add_object(
++ &builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
++ SPA_PARAM_BUFFERS_size, SPA_POD_Int(size), SPA_PARAM_BUFFERS_stride,
++ SPA_POD_Int(stride), SPA_PARAM_BUFFERS_buffers,
++ SPA_POD_CHOICE_RANGE_Int(8, 1, 32)));
++ params[1] = reinterpret_cast<spa_pod*>(spa_pod_builder_add_object(
++ &builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type,
++ SPA_POD_Id(SPA_META_Header), SPA_PARAM_META_size,
++ SPA_POD_Int(sizeof(struct spa_meta_header))));
++ params[2] = reinterpret_cast<spa_pod*>(spa_pod_builder_add_object(
++ &builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type,
++ SPA_POD_Id(SPA_META_VideoCrop), SPA_PARAM_META_size,
++ SPA_POD_Int(sizeof(struct spa_meta_region))));
++ pw_stream_update_params(that->pw_stream_, params, 3);
++#else
+ params[0] = reinterpret_cast<spa_pod*>(spa_pod_builder_object(
+ &builder,
+ // id to enumerate buffer requirements
+@@ -155,8 +363,18 @@ void BaseCapturerPipeWire::OnStreamFormatChanged(void* data,
+ // 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);
++ params[2] = reinterpret_cast<spa_pod*>(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.VideoCrop,
++ // Size: size of the metadata, specified as integer (i)
++ ":", 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);
++#endif
+ }
+
+ // static
+@@ -164,15 +382,26 @@ void BaseCapturerPipeWire::OnStreamProcess(void* data) {
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);
+ RTC_DCHECK(that);
+
+- pw_buffer* buf = nullptr;
++ 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 (!(buf = pw_stream_dequeue_buffer(that->pw_stream_))) {
++ if (next_buffer) {
++ pw_stream_queue_buffer(that->pw_stream_, buffer);
++ }
++ }
++
++ if (!buffer) {
+ return;
+ }
+
+- that->HandleBuffer(buf);
++ that->HandleBuffer(buffer);
+
+- pw_stream_queue_buffer(that->pw_stream_, buf);
++ pw_stream_queue_buffer(that->pw_stream_, buffer);
+ }
+
+ BaseCapturerPipeWire::BaseCapturerPipeWire(CaptureSourceType source_type)
+@@ -183,6 +412,7 @@ BaseCapturerPipeWire::~BaseCapturerPipeWire() {
+ pw_thread_loop_stop(pw_main_loop_);
+ }
+
++#if !PW_CHECK_VERSION(0, 3, 0)
+ if (pw_type_) {
+ delete pw_type_;
+ }
+@@ -190,30 +420,41 @@ BaseCapturerPipeWire::~BaseCapturerPipeWire() {
+ if (spa_video_format_) {
+ delete spa_video_format_;
+ }
++#endif
+
+ if (pw_stream_) {
+ pw_stream_destroy(pw_stream_);
+ }
+
++#if !PW_CHECK_VERSION(0, 3, 0)
+ if (pw_remote_) {
+ pw_remote_destroy(pw_remote_);
+ }
++#endif
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (pw_core_) {
++ pw_core_disconnect(pw_core_);
++ }
++
++ if (pw_context_) {
++ pw_context_destroy(pw_context_);
++ }
++#else
+ if (pw_core_) {
+ pw_core_destroy(pw_core_);
+ }
++#endif
+
+ if (pw_main_loop_) {
+ pw_thread_loop_destroy(pw_main_loop_);
+ }
+
++#if !PW_CHECK_VERSION(0, 3, 0)
+ if (pw_loop_) {
+ pw_loop_destroy(pw_loop_);
+ }
+-
+- if (current_frame_) {
+- free(current_frame_);
+- }
++#endif
+
+ if (start_request_signal_id_) {
+ g_dbus_connection_signal_unsubscribe(connection_, start_request_signal_id_);
+@@ -228,18 +469,16 @@ BaseCapturerPipeWire::~BaseCapturerPipeWire() {
+ }
+
+ 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,
++ Scoped<GDBusMessage> message(g_dbus_message_new_method_call(
++ kDesktopBusName, session_handle_, kSessionInterfaceName, "Close"));
++ if (message.get()) {
++ Scoped<GError> error;
++ g_dbus_connection_send_message(connection_, message.get(),
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE,
+- /*out_serial=*/nullptr, &error);
+- if (error) {
++ /*out_serial=*/nullptr, error.receive());
++ if (error.get()) {
+ RTC_LOG(LS_ERROR) << "Failed to close the session: " << error->message;
+- g_error_free(error);
+ }
+- g_object_unref(message);
+ }
+ }
+
+@@ -274,7 +513,11 @@ void BaseCapturerPipeWire::InitPipeWire() {
+ StubPathMap paths;
+
+ // Check if the PipeWire library is available.
+- paths[kModulePipewire].push_back(kPipeWireLib);
++#if PW_CHECK_VERSION(0, 3, 0)
++ paths[kModulePipewire03].push_back(kPipeWireLib);
++#else
++ paths[kModulePipewire02].push_back(kPipeWireLib);
++#endif
+ if (!InitializeStubs(paths)) {
+ RTC_LOG(LS_ERROR) << "Failed to load the PipeWire library and symbols.";
+ portal_init_failed_ = true;
+@@ -284,16 +527,46 @@ void BaseCapturerPipeWire::InitPipeWire() {
+
+ pw_init(/*argc=*/nullptr, /*argc=*/nullptr);
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ pw_main_loop_ = pw_thread_loop_new("pipewire-main-loop", nullptr);
++
++ pw_thread_loop_lock(pw_main_loop_);
++
++ pw_context_ =
++ pw_context_new(pw_thread_loop_get_loop(pw_main_loop_), nullptr, 0);
++ if (!pw_context_) {
++ RTC_LOG(LS_ERROR) << "Failed to create PipeWire context";
++ return;
++ }
++
++ pw_core_ = pw_context_connect(pw_context_, nullptr, 0);
++ if (!pw_core_) {
++ RTC_LOG(LS_ERROR) << "Failed to connect PipeWire context";
++ return;
++ }
++#else
+ 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();
++#endif
+
+ // Initialize event handlers, remote end and stream-related.
++#if PW_CHECK_VERSION(0, 3, 0)
++ pw_core_events_.version = PW_VERSION_CORE_EVENTS;
++ pw_core_events_.error = &OnCoreError;
++
++ pw_stream_events_.version = PW_VERSION_STREAM_EVENTS;
++ pw_stream_events_.state_changed = &OnStreamStateChanged;
++ pw_stream_events_.param_changed = &OnStreamParamChanged;
++ pw_stream_events_.process = &OnStreamProcess;
++#else
+ pw_remote_events_.version = PW_VERSION_REMOTE_EVENTS;
+ pw_remote_events_.state_changed = &OnStateChanged;
+
+@@ -301,19 +574,33 @@ void BaseCapturerPipeWire::InitPipeWire() {
+ pw_stream_events_.state_changed = &OnStreamStateChanged;
+ pw_stream_events_.format_changed = &OnStreamFormatChanged;
+ pw_stream_events_.process = &OnStreamProcess;
++#endif
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ pw_core_add_listener(pw_core_, &spa_core_listener_, &pw_core_events_, this);
++
++ pw_stream_ = CreateReceivingStream();
++ if (!pw_stream_) {
++ RTC_LOG(LS_ERROR) << "Failed to create PipeWire stream";
++ return;
++ }
++#else
+ pw_remote_add_listener(pw_remote_, &spa_remote_listener_, &pw_remote_events_,
+ this);
+ pw_remote_connect_fd(pw_remote_, pw_fd_);
++#endif
+
+ if (pw_thread_loop_start(pw_main_loop_) < 0) {
+ RTC_LOG(LS_ERROR) << "Failed to start main PipeWire loop";
+ portal_init_failed_ = true;
+ }
+
++ pw_thread_loop_unlock(pw_main_loop_);
++
+ RTC_LOG(LS_INFO) << "PipeWire remote opened.";
+ }
+
++#if !PW_CHECK_VERSION(0, 3, 0)
+ void BaseCapturerPipeWire::InitPipeWireTypes() {
+ spa_type_map* map = pw_core_type_->map;
+ pw_type_ = new PipeWireType();
+@@ -323,23 +610,44 @@ void BaseCapturerPipeWire::InitPipeWireTypes() {
+ spa_type_format_video_map(map, &pw_type_->format_video);
+ spa_type_video_format_map(map, &pw_type_->video_format);
+ }
++#endif
+
+-void BaseCapturerPipeWire::CreateReceivingStream() {
++pw_stream* BaseCapturerPipeWire::CreateReceivingStream() {
++#if !PW_CHECK_VERSION(0, 3, 0)
++ if (pw_remote_get_state(pw_remote_, nullptr) != PW_REMOTE_STATE_CONNECTED) {
++ RTC_LOG(LS_ERROR) << "Cannot create pipewire stream";
++ return nullptr;
++ }
++#endif
+ spa_rectangle pwMinScreenBounds = spa_rectangle{1, 1};
+- spa_rectangle pwScreenBounds =
+- spa_rectangle{static_cast<uint32_t>(desktop_size_.width()),
+- static_cast<uint32_t>(desktop_size_.height())};
+-
+- spa_fraction pwFrameRateMin = spa_fraction{0, 1};
+- spa_fraction pwFrameRateMax = spa_fraction{60, 1};
++ spa_rectangle pwMaxScreenBounds = spa_rectangle{UINT32_MAX, UINT32_MAX};
+
+ pw_properties* reuseProps =
+ pw_properties_new_string("pipewire.client.reuse=1");
+- pw_stream_ = pw_stream_new(pw_remote_, "webrtc-consume-stream", reuseProps);
++#if PW_CHECK_VERSION(0, 3, 0)
++ auto stream = pw_stream_new(pw_core_, "webrtc-consume-stream", reuseProps);
++#else
++ auto stream = pw_stream_new(pw_remote_, "webrtc-consume-stream", reuseProps);
++#endif
+
+ uint8_t buffer[1024] = {};
+ const spa_pod* params[1];
+ spa_pod_builder builder = spa_pod_builder{buffer, sizeof(buffer)};
++
++#if PW_CHECK_VERSION(0, 3, 0)
++ params[0] = reinterpret_cast<spa_pod*>(spa_pod_builder_add_object(
++ &builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
++ SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
++ SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
++ SPA_FORMAT_VIDEO_format,
++ SPA_POD_CHOICE_ENUM_Id(5, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_RGBx,
++ SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_BGRx,
++ SPA_VIDEO_FORMAT_BGRA),
++ SPA_FORMAT_VIDEO_size,
++ SPA_POD_CHOICE_RANGE_Rectangle(&pwMinScreenBounds, &pwMinScreenBounds,
++ &pwMaxScreenBounds),
++ 0));
++#else
+ params[0] = reinterpret_cast<spa_pod*>(spa_pod_builder_object(
+ &builder,
+ // id to enumerate formats
+@@ -349,69 +657,218 @@ void BaseCapturerPipeWire::CreateReceivingStream() {
+ // 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),
++ 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", &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_,
++ ":", pw_type_->format_video.size, "Rru", &pwMinScreenBounds,
++ SPA_POD_PROP_MIN_MAX(&pwMinScreenBounds, &pwMaxScreenBounds)));
++#endif
++
++ pw_stream_add_listener(stream, &spa_stream_listener_, &pw_stream_events_,
+ this);
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (pw_stream_connect(stream, PW_DIRECTION_INPUT, pw_stream_node_id_,
++ PW_STREAM_FLAG_AUTOCONNECT, params, 1) != 0) {
++#else
+ pw_stream_flags flags = static_cast<pw_stream_flags>(
+- 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,
++ PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_INACTIVE);
++ if (pw_stream_connect(stream, PW_DIRECTION_INPUT, /*port_path=*/nullptr,
+ flags, params,
+ /*n_params=*/1) != 0) {
++#endif
+ RTC_LOG(LS_ERROR) << "Could not connect receiving stream.";
+ portal_init_failed_ = true;
+- return;
++ return nullptr;
+ }
++
++ return stream;
+ }
+
+ void BaseCapturerPipeWire::HandleBuffer(pw_buffer* buffer) {
+ spa_buffer* spaBuffer = buffer->buffer;
+- void* src = nullptr;
++ ScopedBuf map;
++ uint8_t* src = nullptr;
++
++ if (spaBuffer->datas[0].chunk->size == 0) {
++ RTC_LOG(LS_ERROR) << "Failed to get video stream: Zero size.";
++ return;
++ }
++
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (spaBuffer->datas[0].type == SPA_DATA_MemFd ||
++ spaBuffer->datas[0].type == SPA_DATA_DmaBuf) {
++#else
++ if (spaBuffer->datas[0].type == pw_core_type_->data.MemFd ||
++ spaBuffer->datas[0].type == pw_core_type_->data.DmaBuf) {
++#endif
++ map.initialize(
++ static_cast<uint8_t*>(
++ mmap(nullptr,
++ spaBuffer->datas[0].maxsize + spaBuffer->datas[0].mapoffset,
++ PROT_READ, MAP_PRIVATE, spaBuffer->datas[0].fd, 0)),
++ spaBuffer->datas[0].maxsize + spaBuffer->datas[0].mapoffset,
++#if PW_CHECK_VERSION(0, 3, 0)
++ spaBuffer->datas[0].type == SPA_DATA_DmaBuf,
++#else
++ spaBuffer->datas[0].type == pw_core_type_->data.DmaBuf,
++#endif
++ spaBuffer->datas[0].fd);
++
++ if (!map) {
++ RTC_LOG(LS_ERROR) << "Failed to mmap the memory: "
++ << std::strerror(errno);
++ return;
++ }
++
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (spaBuffer->datas[0].type == SPA_DATA_DmaBuf) {
++#else
++ if (spaBuffer->datas[0].type == pw_core_type_->data.DmaBuf) {
++#endif
++ SyncDmaBuf(spaBuffer->datas[0].fd, DMA_BUF_SYNC_START);
++ }
++
++ src = SPA_MEMBER(map.get(), spaBuffer->datas[0].mapoffset, uint8_t);
++#if PW_CHECK_VERSION(0, 3, 0)
++ } else if (spaBuffer->datas[0].type == SPA_DATA_MemPtr) {
++#else
++ } else if (spaBuffer->datas[0].type == pw_core_type_->data.MemPtr) {
++#endif
++ src = static_cast<uint8_t*>(spaBuffer->datas[0].data);
++ }
+
+- if (!(src = spaBuffer->datas[0].data)) {
++ if (!src) {
++ return;
++ }
++
++#if PW_CHECK_VERSION(0, 3, 0)
++ struct spa_meta_region* video_metadata =
++ static_cast<struct spa_meta_region*>(spa_buffer_find_meta_data(
++ spaBuffer, SPA_META_VideoCrop, sizeof(*video_metadata)));
++#else
++ struct spa_meta_video_crop* video_metadata =
++ static_cast<struct spa_meta_video_crop*>(
++ spa_buffer_find_meta(spaBuffer, pw_core_type_->meta.VideoCrop));
++#endif
++
++ // Video size from metadata is bigger than an actual video stream size.
++ // The metadata are wrong or we should up-scale the video...in both cases
++ // just quit now.
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (video_metadata && (video_metadata->region.size.width >
++ static_cast<uint32_t>(desktop_size_.width()) ||
++ video_metadata->region.size.height >
++ static_cast<uint32_t>(desktop_size_.height()))) {
++#else
++ if (video_metadata && (video_metadata->width > desktop_size_.width() ||
++ video_metadata->height > desktop_size_.height())) {
++#endif
++ RTC_LOG(LS_ERROR) << "Stream metadata sizes are wrong!";
+ return;
+ }
+
+- uint32_t maxSize = spaBuffer->datas[0].maxsize;
+- int32_t srcStride = spaBuffer->datas[0].chunk->stride;
+- if (srcStride != (desktop_size_.width() * kBytesPerPixel)) {
++ // Use video metadata when video size from metadata is set and smaller than
++ // video stream size, so we need to adjust it.
++ bool video_is_full_width = true;
++ bool video_is_full_height = true;
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (video_metadata && video_metadata->region.size.width != 0 &&
++ video_metadata->region.size.height != 0) {
++ if (video_metadata->region.size.width <
++ static_cast<uint32_t>(desktop_size_.width())) {
++ video_is_full_width = false;
++ } else if (video_metadata->region.size.height <
++ static_cast<uint32_t>(desktop_size_.height())) {
++ video_is_full_height = false;
++ }
++ }
++#else
++ if (video_metadata && video_metadata->width != 0 &&
++ video_metadata->height != 0) {
++ if (video_metadata->width < desktop_size_.width()) {
++ } else if (video_metadata->height < desktop_size_.height()) {
++ video_is_full_height = false;
++ }
++ }
++#endif
++
++ DesktopSize video_size_prev = video_size_;
++ if (!video_is_full_height || !video_is_full_width) {
++#if PW_CHECK_VERSION(0, 3, 0)
++ video_size_ = DesktopSize(video_metadata->region.size.width,
++ video_metadata->region.size.height);
++#else
++ video_size_ = DesktopSize(video_metadata->width, video_metadata->height);
++#endif
++ } else {
++ video_size_ = desktop_size_;
++ }
++
++ webrtc::MutexLock lock(¤t_frame_lock_);
++ if (!current_frame_ || !video_size_.equals(video_size_prev)) {
++ current_frame_ = std::make_unique<uint8_t[]>(
++ video_size_.width() * video_size_.height() * kBytesPerPixel);
++ }
++
++ const int32_t dst_stride = video_size_.width() * kBytesPerPixel;
++ const int32_t src_stride = spaBuffer->datas[0].chunk->stride;
++
++ if (src_stride != (desktop_size_.width() * kBytesPerPixel)) {
+ RTC_LOG(LS_ERROR) << "Got buffer with stride different from screen stride: "
+- << srcStride
++ << src_stride
+ << " != " << (desktop_size_.width() * kBytesPerPixel);
+ portal_init_failed_ = true;
++
+ return;
+ }
+
+- if (!current_frame_) {
+- current_frame_ = static_cast<uint8_t*>(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<uint8_t*>(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);
++ // Adjust source content based on metadata video position
++#if PW_CHECK_VERSION(0, 3, 0)
++ if (!video_is_full_height &&
++ (video_metadata->region.position.y + video_size_.height() <=
++ desktop_size_.height())) {
++ src += src_stride * video_metadata->region.position.y;
++ }
++ const int x_offset =
++ !video_is_full_width &&
++ (video_metadata->region.position.x + video_size_.width() <=
++ desktop_size_.width())
++ ? video_metadata->region.position.x * kBytesPerPixel
++ : 0;
++#else
++ if (!video_is_full_height &&
++ (video_metadata->y + video_size_.height() <= desktop_size_.height())) {
++ src += src_stride * video_metadata->y;
++ }
++
++ const int x_offset =
++ !video_is_full_width &&
++ (video_metadata->x + video_size_.width() <= desktop_size_.width())
++ ? video_metadata->x * kBytesPerPixel
++ : 0;
++#endif
++
++ uint8_t* dst = current_frame_.get();
++ for (int i = 0; i < video_size_.height(); ++i) {
++ // Adjust source content based on crop video position if needed
++ src += x_offset;
++ std::memcpy(dst, src, dst_stride);
++ // 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 PW_CHECK_VERSION(0, 3, 0)
++ if (spa_video_format_.format == SPA_VIDEO_FORMAT_RGBx ||
++ spa_video_format_.format == SPA_VIDEO_FORMAT_RGBA) {
++#else
++ if (spa_video_format_->format == pw_type_->video_format.RGBx ||
++ spa_video_format_->format == pw_type_->video_format.RGBA) {
++#endif
++ ConvertRGBxToBGRx(dst, dst_stride);
++ }
++ src += src_stride - x_offset;
++ dst += dst_stride;
+ }
+ }
+
+@@ -441,14 +898,13 @@ void BaseCapturerPipeWire::OnProxyRequested(GObject* /*object*/,
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(user_data);
+ RTC_DCHECK(that);
+
+- GError* error = nullptr;
+- GDBusProxy *proxy = g_dbus_proxy_new_finish(result, &error);
++ Scoped<GError> error;
++ GDBusProxy* proxy = g_dbus_proxy_new_finish(result, error.receive());
+ if (!proxy) {
+- if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++ if (g_error_matches(error.get(), 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;
+ }
+@@ -462,38 +918,36 @@ void BaseCapturerPipeWire::OnProxyRequested(GObject* /*object*/,
+ // 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] = '_';
++ Scoped<gchar> 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, "/",
++ gchar* handle = g_strconcat(kDesktopRequestObjectPath, "/", sender.get(), "/",
+ token, /*end of varargs*/ nullptr);
+- g_free(sender);
+
+ return handle;
+ }
+
+ void BaseCapturerPipeWire::SessionRequest() {
+ GVariantBuilder builder;
+- gchar* variant_string;
++ Scoped<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);
++ 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));
++ g_variant_new_string(variant_string.get()));
+
+- portal_handle_ = PrepareSignalHandle(connection_, variant_string);
++ portal_handle_ = PrepareSignalHandle(connection_, variant_string.get());
+ session_request_signal_id_ = SetupRequestResponseSignal(
+ portal_handle_, OnSessionRequestResponseSignal);
+- g_free(variant_string);
+
+ RTC_LOG(LS_INFO) << "Screen cast session requested.";
+ g_dbus_proxy_call(
+@@ -509,22 +963,21 @@ void BaseCapturerPipeWire::OnSessionRequested(GDBusProxy *proxy,
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(user_data);
+ RTC_DCHECK(that);
+
+- GError* error = nullptr;
+- GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error);
++ Scoped<GError> error;
++ Scoped<GVariant> variant(
++ g_dbus_proxy_call_finish(proxy, result, error.receive()));
+ if (!variant) {
+- if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++ if (g_error_matches(error.get(), 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);
++ Scoped<gchar> handle;
++ g_variant_get_child(variant.get(), 0, "o", &handle);
+ if (!handle) {
+ RTC_LOG(LS_ERROR) << "Failed to initialize the screen cast session.";
+ if (that->session_request_signal_id_) {
+@@ -536,8 +989,6 @@ void BaseCapturerPipeWire::OnSessionRequested(GDBusProxy *proxy,
+ return;
+ }
+
+- g_free(handle);
+-
+ RTC_LOG(LS_INFO) << "Subscribing to the screen cast session.";
+ }
+
+@@ -557,11 +1008,11 @@ void BaseCapturerPipeWire::OnSessionRequestResponseSignal(
+ << "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",
++ Scoped<GVariant> response_data;
++ g_variant_get(parameters, "(u@a{sv})", &portal_response,
++ response_data.receive());
++ g_variant_lookup(response_data.get(), "session_handle", "s",
+ &that->session_handle_);
+- g_variant_unref(response_data);
+
+ if (!that->session_handle_ || portal_response) {
+ RTC_LOG(LS_ERROR)
+@@ -575,23 +1026,23 @@ void BaseCapturerPipeWire::OnSessionRequestResponseSignal(
+
+ void BaseCapturerPipeWire::SourcesRequest() {
+ GVariantBuilder builder;
+- gchar* variant_string;
++ Scoped<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_));
++ g_variant_builder_add(
++ &builder, "{sv}", "types",
++ g_variant_new_uint32(static_cast<uint32_t>(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));
++ g_variant_new_string(variant_string.get()));
+
+- sources_handle_ = PrepareSignalHandle(connection_, variant_string);
++ sources_handle_ = PrepareSignalHandle(connection_, variant_string.get());
+ 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(
+@@ -608,22 +1059,21 @@ void BaseCapturerPipeWire::OnSourcesRequested(GDBusProxy *proxy,
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(user_data);
+ RTC_DCHECK(that);
+
+- GError* error = nullptr;
+- GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error);
++ Scoped<GError> error;
++ Scoped<GVariant> variant(
++ g_dbus_proxy_call_finish(proxy, result, error.receive()));
+ if (!variant) {
+- if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++ if (g_error_matches(error.get(), 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);
++ Scoped<gchar> 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 (that->sources_request_signal_id_) {
+@@ -635,8 +1085,6 @@ void BaseCapturerPipeWire::OnSourcesRequested(GDBusProxy *proxy,
+ return;
+ }
+
+- g_free(handle);
+-
+ RTC_LOG(LS_INFO) << "Subscribed to sources signal.";
+ }
+
+@@ -668,17 +1116,16 @@ void BaseCapturerPipeWire::OnSourcesRequestResponseSignal(
+
+ void BaseCapturerPipeWire::StartRequest() {
+ GVariantBuilder builder;
+- gchar* variant_string;
++ Scoped<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));
++ g_variant_new_string(variant_string.get()));
+
+- start_handle_ = PrepareSignalHandle(connection_, variant_string);
++ start_handle_ = PrepareSignalHandle(connection_, variant_string.get());
+ 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[] = "";
+@@ -698,23 +1145,22 @@ void BaseCapturerPipeWire::OnStartRequested(GDBusProxy *proxy,
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(user_data);
+ RTC_DCHECK(that);
+
+- GError* error = nullptr;
+- GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error);
++ Scoped<GError> error;
++ Scoped<GVariant> variant(
++ g_dbus_proxy_call_finish(proxy, result, error.receive()));
+ if (!variant) {
+- if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++ if (g_error_matches(error.get(), 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);
++ Scoped<gchar> handle;
++ g_variant_get_child(variant.get(), 0, "o", handle.receive());
+ if (!handle) {
+ RTC_LOG(LS_ERROR)
+ << "Failed to initialize the start of the screen cast session.";
+@@ -727,8 +1173,6 @@ void BaseCapturerPipeWire::OnStartRequested(GDBusProxy *proxy,
+ return;
+ }
+
+- g_free(handle);
+-
+ RTC_LOG(LS_INFO) << "Subscribed to the start signal.";
+ }
+
+@@ -746,9 +1190,10 @@ void BaseCapturerPipeWire::OnStartRequestResponseSignal(
+
+ 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);
++ Scoped<GVariant> response_data;
++ Scoped<GVariantIter> 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.";
+ that->portal_init_failed_ = true;
+@@ -758,28 +1203,28 @@ void BaseCapturerPipeWire::OnStartRequestResponseSignal(
+ // Array of PipeWire streams. See
+ // https://github.com/flatpak/xdg-desktop-portal/blob/master/data/org.freedesktop.portal.ScreenCast.xml
+ // documentation for <method name="Start">.
+- if (g_variant_lookup(response_data, "streams", "a(ua{sv})", &iter)) {
+- GVariant* variant;
++ if (g_variant_lookup(response_data.get(), "streams", "a(ua{sv})",
++ iter.receive())) {
++ Scoped<GVariant> variant;
+
+- while (g_variant_iter_next(iter, "@(ua{sv})", &variant)) {
++ while (g_variant_iter_next(iter.get(), "@(ua{sv})", variant.receive())) {
+ guint32 stream_id;
+- gint32 width;
+- gint32 height;
+- GVariant* options;
++ guint32 type;
++ Scoped<GVariant> options;
+
+- g_variant_get(variant, "(u@a{sv})", &stream_id, &options);
+- RTC_DCHECK(options != nullptr);
++ g_variant_get(variant.get(), "(u@a{sv})", &stream_id, options.receive());
++ RTC_DCHECK(options.get());
+
+- g_variant_lookup(options, "size", "(ii)", &width, &height);
++ if (g_variant_lookup(options.get(), "source_type", "u", &type)) {
++ that->capture_source_type_ =
++ static_cast<BaseCapturerPipeWire::CaptureSourceType>(type);
++ }
+
+- that->desktop_size_.set(width, height);
++ that->pw_stream_node_id_ = stream_id;
+
+- g_variant_unref(options);
+- g_variant_unref(variant);
++ break;
+ }
+ }
+- g_variant_iter_free(iter);
+- g_variant_unref(response_data);
+
+ that->OpenPipeWireRemote();
+ }
+@@ -807,35 +1252,30 @@ void BaseCapturerPipeWire::OnOpenPipeWireRemoteRequested(
+ BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(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);
++ Scoped<GError> error;
++ Scoped<GUnixFDList> outlist;
++ Scoped<GVariant> variant(g_dbus_proxy_call_with_unix_fd_list_finish(
++ proxy, outlist.receive(), result, error.receive()));
+ if (!variant) {
+- if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
++ if (g_error_matches(error.get(), 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);
++ g_variant_get(variant.get(), "(h)", &index);
+
+- if ((that->pw_fd_ = g_unix_fd_list_get(outlist, index, &error)) == -1) {
++ if ((that->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;
+- g_error_free(error);
+- g_variant_unref(variant);
+ that->portal_init_failed_ = true;
+ return;
+ }
+
+- g_variant_unref(variant);
+- g_object_unref(outlist);
+-
+ that->InitPipeWire();
+ }
+
+@@ -854,15 +1294,18 @@ void BaseCapturerPipeWire::CaptureFrame() {
+ return;
+ }
+
++ webrtc::MutexLock lock(¤t_frame_lock_);
+ if (!current_frame_) {
+ callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
+ return;
+ }
+
+- std::unique_ptr<DesktopFrame> result(new BasicDesktopFrame(desktop_size_));
++ DesktopSize frame_size = video_size_;
++
++ std::unique_ptr<DesktopFrame> result(new BasicDesktopFrame(frame_size));
+ result->CopyPixelsFrom(
+- current_frame_, (desktop_size_.width() * kBytesPerPixel),
+- DesktopRect::MakeWH(desktop_size_.width(), desktop_size_.height()));
++ current_frame_.get(), (frame_size.width() * kBytesPerPixel),
++ DesktopRect::MakeWH(frame_size.width(), frame_size.height()));
+ if (!result) {
+ callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
+ return;
+@@ -887,4 +1330,11 @@ bool BaseCapturerPipeWire::SelectSource(SourceId id) {
+ return true;
+ }
+
++// static
++std::unique_ptr<DesktopCapturer> BaseCapturerPipeWire::CreateRawCapturer(
++ const DesktopCaptureOptions& options) {
++ return std::make_unique<BaseCapturerPipeWire>(
++ BaseCapturerPipeWire::CaptureSourceType::kAny);
++}
++
+ } // namespace webrtc
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h
+index f28d7a558bc..75d20dbf1db 100644
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h
++++ b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h
+@@ -10,18 +10,23 @@
+
+ #ifndef MODULES_DESKTOP_CAPTURE_LINUX_BASE_CAPTURER_PIPEWIRE_H_
+ #define MODULES_DESKTOP_CAPTURE_LINUX_BASE_CAPTURER_PIPEWIRE_H_
+-
+ #include <gio/gio.h>
+ #define typeof __typeof__
+ #include <pipewire/pipewire.h>
+ #include <spa/param/video/format-utils.h>
++#if PW_CHECK_VERSION(0, 3, 0)
++#include <spa/utils/result.h>
++#endif
+
++#include "absl/types/optional.h"
+ #include "modules/desktop_capture/desktop_capture_options.h"
+ #include "modules/desktop_capture/desktop_capturer.h"
+ #include "rtc_base/constructor_magic.h"
++#include "rtc_base/synchronization/mutex.h"
+
+ namespace webrtc {
+
++#if !PW_CHECK_VERSION(0, 3, 0)
+ class PipeWireType {
+ public:
+ spa_type_media_type media_type;
+@@ -29,14 +34,25 @@ class PipeWireType {
+ spa_type_format_video format_video;
+ spa_type_video_format video_format;
+ };
++#endif
+
+ class BaseCapturerPipeWire : public DesktopCapturer {
+ public:
+- enum CaptureSourceType { Screen = 1, Window };
++ // Values are set based on source type property in
++ // xdg-desktop-portal/screencast
++ // https://github.com/flatpak/xdg-desktop-portal/blob/master/data/org.freedesktop.portal.ScreenCast.xml
++ enum class CaptureSourceType : uint32_t {
++ kScreen = 0b01,
++ kWindow = 0b10,
++ kAny = 0b11
++ };
+
+ explicit BaseCapturerPipeWire(CaptureSourceType source_type);
+ ~BaseCapturerPipeWire() override;
+
++ static std::unique_ptr<DesktopCapturer> CreateRawCapturer(
++ const DesktopCaptureOptions& options);
++
+ // DesktopCapturer interface.
+ void Start(Callback* delegate) override;
+ void CaptureFrame() override;
+@@ -45,6 +61,21 @@ class BaseCapturerPipeWire : public DesktopCapturer {
+
+ private:
+ // PipeWire types -->
++#if PW_CHECK_VERSION(0, 3, 0)
++ struct pw_context* pw_context_ = nullptr;
++ struct pw_core* pw_core_ = nullptr;
++ struct pw_stream* pw_stream_ = nullptr;
++ struct pw_thread_loop* pw_main_loop_ = nullptr;
++
++ spa_hook spa_core_listener_;
++ spa_hook spa_stream_listener_;
++
++ // event handlers
++ pw_core_events pw_core_events_ = {};
++ pw_stream_events pw_stream_events_ = {};
++
++ struct spa_video_info_raw spa_video_format_;
++#else
+ pw_core* pw_core_ = nullptr;
+ pw_type* pw_core_type_ = nullptr;
+ pw_stream* pw_stream_ = nullptr;
+@@ -60,11 +91,13 @@ class BaseCapturerPipeWire : public DesktopCapturer {
+ pw_remote_events pw_remote_events_ = {};
+
+ spa_video_info_raw* spa_video_format_ = nullptr;
++#endif
+
++ guint32 pw_stream_node_id_ = 0;
+ gint32 pw_fd_ = -1;
+
+ CaptureSourceType capture_source_type_ =
+- BaseCapturerPipeWire::CaptureSourceType::Screen;
++ BaseCapturerPipeWire::CaptureSourceType::kScreen;
+
+ // <-- end of PipeWire types
+
+@@ -79,10 +112,12 @@ class BaseCapturerPipeWire : public DesktopCapturer {
+ guint sources_request_signal_id_ = 0;
+ guint start_request_signal_id_ = 0;
+
++ DesktopSize video_size_;
+ DesktopSize desktop_size_ = {};
+ DesktopCaptureOptions options_ = {};
+
+- uint8_t* current_frame_ = nullptr;
++ webrtc::Mutex current_frame_lock_;
++ std::unique_ptr<uint8_t[]> current_frame_;
+ Callback* callback_ = nullptr;
+
+ bool portal_init_failed_ = false;
+@@ -91,21 +126,32 @@ class BaseCapturerPipeWire : public DesktopCapturer {
+ void InitPipeWire();
+ void InitPipeWireTypes();
+
+- void CreateReceivingStream();
++ pw_stream* CreateReceivingStream();
+ void HandleBuffer(pw_buffer* buffer);
+
+ void ConvertRGBxToBGRx(uint8_t* frame, uint32_t size);
+
++#if PW_CHECK_VERSION(0, 3, 0)
++ static void OnCoreError(void* data,
++ uint32_t id,
++ int seq,
++ int res,
++ const char* message);
++ static void OnStreamParamChanged(void* data,
++ uint32_t id,
++ const struct spa_pod* format);
++#else
+ static void OnStateChanged(void* data,
+ pw_remote_state old_state,
+ pw_remote_state state,
+ const char* error);
++ static void OnStreamFormatChanged(void* data, const struct spa_pod* format);
++#endif
+ 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);
+
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire.sigs b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire.sigs
+deleted file mode 100644
+index 3e21e9dc07c..00000000000
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire.sigs
++++ /dev/null
+@@ -1,44 +0,0 @@
+-// 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.
+-
+-//------------------------------------------------
+-// Functions from PipeWire used in capturer code.
+-//------------------------------------------------
+-
+-// core.h
+-void pw_core_destroy(pw_core *core);
+-pw_type *pw_core_get_type(pw_core *core);
+-pw_core * pw_core_new(pw_loop *main_loop, pw_properties *props);
+-
+-// loop.h
+-void pw_loop_destroy(pw_loop *loop);
+-pw_loop * pw_loop_new(pw_properties *properties);
+-
+-// pipewire.h
+-void pw_init(int *argc, char **argv[]);
+-
+-// properties.h
+-pw_properties * pw_properties_new_string(const char *args);
+-
+-// remote.h
+-void pw_remote_add_listener(pw_remote *remote, spa_hook *listener, const pw_remote_events *events, void *data);
+-int pw_remote_connect_fd(pw_remote *remote, int fd);
+-void pw_remote_destroy(pw_remote *remote);
+-pw_remote * pw_remote_new(pw_core *core, pw_properties *properties, size_t user_data_size);
+-
+-// stream.h
+-void pw_stream_add_listener(pw_stream *stream, spa_hook *listener, const pw_stream_events *events, void *data);
+-int pw_stream_connect(pw_stream *stream, enum pw_direction direction, const char *port_path, enum pw_stream_flags flags, const spa_pod **params, uint32_t n_params);
+-pw_buffer *pw_stream_dequeue_buffer(pw_stream *stream);
+-void pw_stream_destroy(pw_stream *stream);
+-void pw_stream_finish_format(pw_stream *stream, int res, const spa_pod **params, uint32_t n_params);
+-pw_stream * pw_stream_new(pw_remote *remote, const char *name, pw_properties *props);
+-int pw_stream_queue_buffer(pw_stream *stream, pw_buffer *buffer);
+-int pw_stream_set_active(pw_stream *stream, bool active);
+-
+-// thread-loop.h
+-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);
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.cc b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.cc
+deleted file mode 100644
+index fe672140cca..00000000000
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.cc
++++ /dev/null
+@@ -1,29 +0,0 @@
+-/*
+- * 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 <memory>
+-
+-
+-namespace webrtc {
+-
+-ScreenCapturerPipeWire::ScreenCapturerPipeWire()
+- : BaseCapturerPipeWire(BaseCapturerPipeWire::CaptureSourceType::Screen) {}
+-ScreenCapturerPipeWire::~ScreenCapturerPipeWire() {}
+-
+-// static
+-std::unique_ptr<DesktopCapturer>
+-ScreenCapturerPipeWire::CreateRawScreenCapturer(
+- const DesktopCaptureOptions& options) {
+- return std::make_unique<ScreenCapturerPipeWire>();
+-}
+-
+-} // namespace webrtc
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.h b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.h
+deleted file mode 100644
+index 66dcd680e06..00000000000
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.h
++++ /dev/null
+@@ -1,33 +0,0 @@
+-/*
+- * 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 <memory>
+-
+-#include "modules/desktop_capture/linux/base_capturer_pipewire.h"
+-
+-namespace webrtc {
+-
+-class ScreenCapturerPipeWire : public BaseCapturerPipeWire {
+- public:
+- ScreenCapturerPipeWire();
+- ~ScreenCapturerPipeWire() override;
+-
+- static std::unique_ptr<DesktopCapturer> CreateRawScreenCapturer(
+- const DesktopCaptureOptions& options);
+-
+- RTC_DISALLOW_COPY_AND_ASSIGN(ScreenCapturerPipeWire);
+-};
+-
+-} // namespace webrtc
+-
+-#endif // MODULES_DESKTOP_CAPTURE_LINUX_SCREEN_CAPTURER_PIPEWIRE_H_
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.cc b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.cc
+deleted file mode 100644
+index b4559156dce..00000000000
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.cc
++++ /dev/null
+@@ -1,29 +0,0 @@
+-/*
+- * 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 <memory>
+-
+-
+-namespace webrtc {
+-
+-WindowCapturerPipeWire::WindowCapturerPipeWire()
+- : BaseCapturerPipeWire(BaseCapturerPipeWire::CaptureSourceType::Window) {}
+-WindowCapturerPipeWire::~WindowCapturerPipeWire() {}
+-
+-// static
+-std::unique_ptr<DesktopCapturer>
+-WindowCapturerPipeWire::CreateRawWindowCapturer(
+- const DesktopCaptureOptions& options) {
+- return std::make_unique<WindowCapturerPipeWire>();
+-}
+-
+-} // namespace webrtc
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.h b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.h
+deleted file mode 100644
+index 7f184ef2999..00000000000
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.h
++++ /dev/null
+@@ -1,33 +0,0 @@
+-/*
+- * 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 <memory>
+-
+-#include "modules/desktop_capture/linux/base_capturer_pipewire.h"
+-
+-namespace webrtc {
+-
+-class WindowCapturerPipeWire : public BaseCapturerPipeWire {
+- public:
+- WindowCapturerPipeWire();
+- ~WindowCapturerPipeWire() override;
+-
+- static std::unique_ptr<DesktopCapturer> CreateRawWindowCapturer(
+- const DesktopCaptureOptions& options);
+-
+- RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerPipeWire);
+-};
+-
+-} // namespace webrtc
+-
+-#endif // MODULES_DESKTOP_CAPTURE_LINUX_WINDOW_CAPTURER_PIPEWIRE_H_
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/screen_capturer_linux.cc b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/screen_capturer_linux.cc
+index 82dbae48137..ed48b7d6d59 100644
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/screen_capturer_linux.cc
++++ b/src/3rdparty/chromium/third_party/webrtc/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/screen_capturer_pipewire.h"
++#include "modules/desktop_capture/linux/base_capturer_pipewire.h"
+ #endif // defined(WEBRTC_USE_PIPEWIRE)
+
+ #if defined(WEBRTC_USE_X11)
+@@ -28,7 +28,7 @@ std::unique_ptr<DesktopCapturer> DesktopCapturer::CreateRawScreenCapturer(
+ const DesktopCaptureOptions& options) {
+ #if defined(WEBRTC_USE_PIPEWIRE)
+ if (options.allow_pipewire() && DesktopCapturer::IsRunningUnderWayland()) {
+- return ScreenCapturerPipeWire::CreateRawScreenCapturer(options);
++ return BaseCapturerPipeWire::CreateRawCapturer(options);
+ }
+ #endif // defined(WEBRTC_USE_PIPEWIRE)
+
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/window_capturer_linux.cc b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/window_capturer_linux.cc
+index 41dbf836b03..2b142ae3b92 100644
+--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/window_capturer_linux.cc
++++ b/src/3rdparty/chromium/third_party/webrtc/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/window_capturer_pipewire.h"
++#include "modules/desktop_capture/linux/base_capturer_pipewire.h"
+ #endif // defined(WEBRTC_USE_PIPEWIRE)
+
+ #if defined(WEBRTC_USE_X11)
+@@ -28,7 +28,7 @@ std::unique_ptr<DesktopCapturer> DesktopCapturer::CreateRawWindowCapturer(
+ const DesktopCaptureOptions& options) {
+ #if defined(WEBRTC_USE_PIPEWIRE)
+ if (options.allow_pipewire() && DesktopCapturer::IsRunningUnderWayland()) {
+- return WindowCapturerPipeWire::CreateRawWindowCapturer(options);
++ return BaseCapturerPipeWire::CreateRawCapturer(options);
+ }
+ #endif // defined(WEBRTC_USE_PIPEWIRE)
+
+diff --git a/src/3rdparty/chromium/third_party/webrtc/webrtc.gni b/src/3rdparty/chromium/third_party/webrtc/webrtc.gni
+index ca8acdbf259..505c975cece 100644
+--- a/src/3rdparty/chromium/third_party/webrtc/webrtc.gni
++++ b/src/3rdparty/chromium/third_party/webrtc/webrtc.gni
+@@ -117,6 +117,10 @@ declare_args() {
+ # Set this to link PipeWire directly instead of using the dlopen.
+ rtc_link_pipewire = false
+
++ # Set this to use certain PipeWire version
++ # Currently we support PipeWire 0.2 (default) and PipeWire 0.3
++ rtc_pipewire_version = "0.3"
++
+ # Enable to use the Mozilla internal settings.
+ build_with_mozilla = false
+
+diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire02.sigs b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire02.sigs
+new file mode 100644
+index 00000000000..5ac3d1d22b8
+--- /dev/null
++++ b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire02.sigs
+@@ -0,0 +1,47 @@
++// 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.
++
++//------------------------------------------------
++// Functions from PipeWire used in capturer code.
++//------------------------------------------------
++
++// core.h
++void pw_core_destroy(pw_core *core);
++pw_type *pw_core_get_type(pw_core *core);
++pw_core * pw_core_new(pw_loop *main_loop, pw_properties *props);
++
++// loop.h
++void pw_loop_destroy(pw_loop *loop);
++pw_loop * pw_loop_new(pw_properties *properties);
++
++// pipewire.h
++void pw_init(int *argc, char **argv[]);
++
++// properties.h
++pw_properties * pw_properties_new_string(const char *args);
++
++// remote.h
++void pw_remote_add_listener(pw_remote *remote, spa_hook *listener, const pw_remote_events *events, void *data);
++int pw_remote_connect_fd(pw_remote *remote, int fd);
++void pw_remote_destroy(pw_remote *remote);
++pw_remote * pw_remote_new(pw_core *core, pw_properties *properties, size_t user_data_size);
++enum pw_remote_state pw_remote_get_state(pw_remote *remote, const char **error);
++
++// stream.h
++void pw_stream_add_listener(pw_stream *stream, spa_hook *listener, const pw_stream_events *events, void *data);
++int pw_stream_connect(pw_stream *stream, enum pw_direction direction, const char *port_path, enum pw_stream_flags flags, const spa_pod **params, uint32_t n_params);
++pw_buffer *pw_stream_dequeue_buffer(pw_stream *stream);
++void pw_stream_destroy(pw_stream *stream);
++void pw_stream_finish_format(pw_stream *stream, int res, const spa_pod **params, uint32_t n_params);
++pw_stream * pw_stream_new(pw_remote *remote, const char *name, pw_properties *props);
++int pw_stream_queue_buffer(pw_stream *stream, pw_buffer *buffer);
++int pw_stream_set_active(pw_stream *stream, bool active);
++
++// thread-loop.h
++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/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire03.sigs b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire03.sigs
+new file mode 100644
+index 00000000000..78d241f40c6
+--- /dev/null
++++ b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire03.sigs
+@@ -0,0 +1,46 @@
++// 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.
++
++//------------------------------------------------
++// Functions from PipeWire used in capturer code.
++//------------------------------------------------
++
++// core.h
++int pw_core_disconnect(pw_core *core);
++
++// loop.h
++void pw_loop_destroy(pw_loop *loop);
++pw_loop * pw_loop_new(const spa_dict *props);
++
++
++// pipewire.h
++void pw_init(int *argc, char **argv[]);
++
++// properties.h
++pw_properties * pw_properties_new_string(const char *args);
++
++// stream.h
++void pw_stream_add_listener(pw_stream *stream, spa_hook *listener, const pw_stream_events *events, void *data);
++int pw_stream_connect(pw_stream *stream, enum pw_direction direction, uint32_t target_id, enum pw_stream_flags flags, const spa_pod **params, uint32_t n_params);
++pw_buffer *pw_stream_dequeue_buffer(pw_stream *stream);
++void pw_stream_destroy(pw_stream *stream);
++pw_stream * pw_stream_new(pw_core *core, const char *name, pw_properties *props);
++int pw_stream_queue_buffer(pw_stream *stream, pw_buffer *buffer);
++int pw_stream_set_active(pw_stream *stream, bool active);
++int pw_stream_update_params(pw_stream *stream, const spa_pod **params, uint32_t n_params);
++
++// thread-loop.h
++void pw_thread_loop_destroy(pw_thread_loop *loop);
++pw_thread_loop * pw_thread_loop_new(const char *name, const spa_dict *props);
++int pw_thread_loop_start(pw_thread_loop *loop);
++void pw_thread_loop_stop(pw_thread_loop *loop);
++void pw_thread_loop_lock(pw_thread_loop *loop);
++void pw_thread_loop_unlock(pw_thread_loop *loop);
++pw_loop * pw_thread_loop_get_loop(pw_thread_loop *loop);
++
++
++// context.h
++void pw_context_destroy(pw_context *context);
++pw_context *pw_context_new(pw_loop *main_loop, pw_properties *props, size_t user_data_size);
++pw_core * pw_context_connect(pw_context *context, pw_properties *properties, size_t user_data_size);
diff --git a/debian/patches/series b/debian/patches/series
index 9b396af..ebdd4bd 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -25,3 +25,4 @@ mips64el-kernel_stat64.patch
armhf-no-thumb.patch
gcc-12.patch
disable-catapult.patch
+qt5-webengine-pipewire-0.3.patch
diff --git a/debian/rules b/debian/rules
index 0cbc395..997b045 100755
--- a/debian/rules
+++ b/debian/rules
@@ -44,6 +44,7 @@ config_args = -proprietary-codecs \
-system-opus \
-system-webp \
-system-webengine-icu \
+ -webengine-webrtc-pipewire \
-webengine-kerberos
touch_files = src/3rdparty/chromium/third_party/devtools-frontend/src/front_end/third_party/lighthouse/lighthouse-dt-bundle.js \
--
2.39.1
Reply to: