From d2307e32375087e2c3b21f64b1037e638c9c43b0 Mon Sep 17 00:00:00 2001 From: Kevin Mihelich Date: Sun, 20 Feb 2022 14:50:17 +0000 Subject: [PATCH] extra/qt5-webengine to 5.15.8-9 --- extra/qt5-webengine/PKGBUILD | 9 +- .../qt5-webengine-pipewire-0.3.patch | 1819 +++++++++++++++++ 2 files changed, 1825 insertions(+), 3 deletions(-) create mode 100644 extra/qt5-webengine/qt5-webengine-pipewire-0.3.patch diff --git a/extra/qt5-webengine/PKGBUILD b/extra/qt5-webengine/PKGBUILD index fee1c171d..c7a8514db 100644 --- a/extra/qt5-webengine/PKGBUILD +++ b/extra/qt5-webengine/PKGBUILD @@ -11,15 +11,15 @@ highmem=1 pkgname=qt5-webengine _qtver=5.15.8 pkgver=${_qtver/-/} -pkgrel=8 +pkgrel=9 arch=('x86_64') url='https://www.qt.io' license=('LGPL3' 'LGPL2.1' 'BSD') pkgdesc='Provides support for web applications using the Chromium browser project' depends=('qt5-webchannel' 'qt5-location' 'libxcomposite' 'libxrandr' 'pciutils' 'libxss' 'libxkbfile' 'libevent' 'snappy' 'nss' 'libxslt' 'minizip' 'ffmpeg' 're2' 'libvpx' 'libxtst' 'ttf-font') -makedepends=('git' 'python' 'gperf' 'jsoncpp' 'ninja' 'qt5-tools' 'poppler' 'libpipewire02' 'nodejs') -optdepends=('libpipewire02: WebRTC desktop sharing under Wayland') +makedepends=('git' 'python' 'gperf' 'jsoncpp' 'ninja' 'qt5-tools' 'poppler' 'pipewire' 'nodejs') +optdepends=('pipewire: WebRTC desktop sharing under Wayland') groups=('qt' 'qt5') _pkgfqn=qtwebengine source=(git+https://code.qt.io/qt/qtwebengine.git#tag=v${pkgver}-lts @@ -28,6 +28,7 @@ source=(git+https://code.qt.io/qt/qtwebengine.git#tag=v${pkgver}-lts qt5-webengine-python3.patch qt5-webengine-chromium-python3.patch qt5-webengine-ffmpeg5.patch + qt5-webengine-pipewire-0.3.patch 0001-ARM-toolchain-fixes.patch 0002-Fix-ARM-skia-ICE.patch 0003-bind-gen-Support-single_process-flag-in-generate_bin.patch @@ -38,6 +39,7 @@ sha256sums=('SKIP' '398c996cb5b606695ac93645143df39e23fa67e768b09e0da6dbd37342a43f32' 'fda4ff16790799fb285847918a677f4f3f7c0f513d4751f846ffc5aa5d873932' 'c50d3019626183e753c53a997dc8a55938847543aa3178d4c51f377be741c693' + '5e3a3c4711d964d5152a04059a2b5c1d14bb13dd29bce370120f60e85b476b6f' '81b7a62368f40d757b165b88df4813413f30db797e4f93a84dd75e12e1ebd679' '298037fcbc132f1539616cdf6149ad5da104f8e2345a9c1af1e7bf8b0dd52c70' 'b878770648437c9bc24023b1d5a47bcd51382d7142b695864c3379826511bcd9' @@ -57,6 +59,7 @@ prepare() { patch -p1 -d src/3rdparty -i "$srcdir"/qt5-webengine-chromium-python3.patch patch -p1 -d src/3rdparty -i "$srcdir"/qt5-webengine-ffmpeg5.patch # Fix build with ffmpeg 5 + patch -p1 -d src/3rdparty -i "$srcdir"/qt5-webengine-pipewire-0.3.patch # Port to pipewire 0.3 # Update catapult for python3 compatibility rm -r src/3rdparty/chromium/third_party/catapult diff --git a/extra/qt5-webengine/qt5-webengine-pipewire-0.3.patch b/extra/qt5-webengine/qt5-webengine-pipewire-0.3.patch new file mode 100644 index 000000000..f8047e088 --- /dev/null +++ b/extra/qt5-webengine/qt5-webengine-pipewire-0.3.patch @@ -0,0 +1,1819 @@ +diff --git a/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn b/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn +index 5235512735d..8259442f811 100644 +--- a/chromium/third_party/webrtc/modules/desktop_capture/BUILD.gn ++++ b/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/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc b/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc +index 2640e93aa98..c302a086ead 100644 +--- a/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc ++++ b/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc +@@ -14,8 +14,14 @@ + #include + #include + #include ++#if !PW_CHECK_VERSION(0, 3, 0) + #include + #include ++#endif ++ ++#include ++#include ++#include + + #include + #include +@@ -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 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_); ++ } ++} ++ ++#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(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(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(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_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_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_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_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_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(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 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); +- 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(desktop_size_.width()), +- static_cast(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_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_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_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( ++ 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(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(spa_buffer_find_meta_data( ++ spaBuffer, SPA_META_VideoCrop, sizeof(*video_metadata))); ++#else ++ struct spa_meta_video_crop* video_metadata = ++ static_cast( ++ 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(desktop_size_.width()) || ++ video_metadata->region.size.height > ++ static_cast(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(desktop_size_.width())) { ++ video_is_full_width = false; ++ } else if (video_metadata->region.size.height < ++ static_cast(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( ++ 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(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); ++ // 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(user_data); + RTC_DCHECK(that); + +- GError* error = nullptr; +- GDBusProxy *proxy = g_dbus_proxy_new_finish(result, &error); ++ Scoped 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 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 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(user_data); + RTC_DCHECK(that); + +- GError* error = nullptr; +- GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error); ++ Scoped error; ++ Scoped 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 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 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 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(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(user_data); + RTC_DCHECK(that); + +- GError* error = nullptr; +- GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error); ++ Scoped error; ++ Scoped 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 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 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(user_data); + RTC_DCHECK(that); + +- GError* error = nullptr; +- GVariant* variant = g_dbus_proxy_call_finish(proxy, result, &error); ++ Scoped error; ++ Scoped 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 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 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."; + 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 . +- 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 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 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(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(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 error; ++ Scoped outlist; ++ Scoped 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 result(new BasicDesktopFrame(desktop_size_)); ++ DesktopSize frame_size = video_size_; ++ ++ std::unique_ptr 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 BaseCapturerPipeWire::CreateRawCapturer( ++ const DesktopCaptureOptions& options) { ++ return std::make_unique( ++ BaseCapturerPipeWire::CaptureSourceType::kAny); ++} ++ + } // namespace webrtc +diff --git a/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h b/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h +index f28d7a558bc..75d20dbf1db 100644 +--- a/chromium/third_party/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.h ++++ b/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 + #define typeof __typeof__ + #include + #include ++#if PW_CHECK_VERSION(0, 3, 0) ++#include ++#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 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 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/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire.sigs b/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire.sigs +deleted file mode 100644 +index 3e21e9dc07c..00000000000 +--- a/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/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.cc b/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.cc +deleted file mode 100644 +index fe672140cca..00000000000 +--- a/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 +- +- +-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/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.h b/chromium/third_party/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.h +deleted file mode 100644 +index 66dcd680e06..00000000000 +--- a/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 +- +-#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/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.cc b/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.cc +deleted file mode 100644 +index b4559156dce..00000000000 +--- a/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 +- +- +-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/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.h b/chromium/third_party/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.h +deleted file mode 100644 +index 7f184ef2999..00000000000 +--- a/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 +- +-#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/chromium/third_party/webrtc/modules/desktop_capture/screen_capturer_linux.cc b/chromium/third_party/webrtc/modules/desktop_capture/screen_capturer_linux.cc +index 82dbae48137..ed48b7d6d59 100644 +--- a/chromium/third_party/webrtc/modules/desktop_capture/screen_capturer_linux.cc ++++ b/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::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/chromium/third_party/webrtc/modules/desktop_capture/window_capturer_linux.cc b/chromium/third_party/webrtc/modules/desktop_capture/window_capturer_linux.cc +index 41dbf836b03..2b142ae3b92 100644 +--- a/chromium/third_party/webrtc/modules/desktop_capture/window_capturer_linux.cc ++++ b/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::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/chromium/third_party/webrtc/webrtc.gni b/chromium/third_party/webrtc/webrtc.gni +index ca8acdbf259..505c975cece 100644 +--- a/chromium/third_party/webrtc/webrtc.gni ++++ b/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/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire02.sigs b/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire02.sigs +new file mode 100644 +index 00000000000..5ac3d1d22b8 +--- /dev/null ++++ b/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/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire03.sigs b/chromium/third_party/webrtc/modules/desktop_capture/linux/pipewire03.sigs +new file mode 100644 +index 00000000000..78d241f40c6 +--- /dev/null ++++ b/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);