diff -up firefox-60.3.0/config/system-headers.mozbuild.pipewire firefox-60.3.0/config/system-headers.mozbuild

--- firefox-60.3.0/config/system-headers.mozbuild.pipewire	2018-10-17 22:39:27.000000000 +0200

+++ firefox-60.3.0/config/system-headers.mozbuild	2019-01-07 14:53:17.200061752 +0100

@@ -314,6 +314,7 @@ system_headers = [

     'Gestalt.h',

     'getopt.h',

     'gio/gio.h',

+    'gio/gunixfdlist.h',

     'glibconfig.h',

     'glib.h',

     'glib-object.h',

@@ -607,6 +608,7 @@ system_headers = [

     'Pgenerr.h',

     'PGenErr.h',

     'Ph.h',

+    'pipewire/pipewire.h',

     'pixman.h',

     'pk11func.h',

     'pk11pqg.h',

diff -up firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_linux.cc.pipewire firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_linux.cc

--- firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_linux.cc.pipewire	2019-01-07 14:53:17.200061752 +0100

+++ firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_linux.cc	2019-01-07 14:53:17.200061752 +0100

@@ -0,0 +1,39 @@

+/*

+ *  Copyright (c) 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 "webrtc/modules/desktop_capture/desktop_capture_options.h"

+#include "webrtc/modules/desktop_capture/desktop_capturer.h"

+

+#if defined(USE_X11)

+#include "webrtc/modules/desktop_capture/app_capturer_x11.h"

+#endif // defined(USE_X11)

+

+namespace webrtc {

+

+// static

+AppCapturer* AppCapturer::Create(const DesktopCaptureOptions& options) {

+#if defined(USE_X11)

+    return AppCapturerX11::Create(options);

+#endif // defined(USE_X11)

+

+  return nullptr;

+}

+

+// static

+std::unique_ptr<DesktopCapturer> DesktopCapturer::CreateRawAppCapturer(

+    const DesktopCaptureOptions& options) {

+#if defined(USE_X11)

+  return AppCapturerX11::CreateRawAppCapturer(options);

+#endif // defined(USE_X11)

+

+  return nullptr;

+}

+

+}  // namespace webrtc

diff -up firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.cc.pipewire firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.cc

--- firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.cc.pipewire	2018-10-17 22:39:32.000000000 +0200

+++ firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.cc	2019-01-07 14:53:17.201061764 +0100

@@ -7,9 +7,6 @@

 *  in the file PATENTS.  All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

 */

-#include "webrtc/modules/desktop_capture/app_capturer.h"

-#include "webrtc/modules/desktop_capture/shared_desktop_frame.h"

-#include "webrtc/modules/desktop_capture/x11/shared_x_util.h"

 #include <assert.h>

 #include <string.h>

@@ -21,80 +18,19 @@

 #include <algorithm>

+#include "webrtc/modules/desktop_capture/app_capturer_x11.h"

+

 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"

 #include "webrtc/modules/desktop_capture/desktop_frame.h"

 #include "webrtc/modules/desktop_capture/x11/shared_x_display.h"

+#include "webrtc/modules/desktop_capture/x11/shared_x_util.h"

 #include "webrtc/modules/desktop_capture/x11/x_error_trap.h"

 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"

 #include "webrtc/system_wrappers/include/logging.h"

 namespace webrtc {

-namespace {

-

-class ScreenCapturerProxy : DesktopCapturer::Callback {

-public:

-  ScreenCapturerProxy()

-    : screen_capturer_(DesktopCapturer::CreateScreenCapturer(DesktopCaptureOptions::CreateDefault())) {

-    screen_capturer_->SelectSource(kFullDesktopScreenId);

-    screen_capturer_->Start(this);

-  }

-  void CaptureFrame() { screen_capturer_->CaptureFrame(); }

-  std::unique_ptr<DesktopFrame> GetFrame() { return std::move(frame_); }

-

-   // Callback interface

-  virtual void OnCaptureResult(DesktopCapturer::Result result,

-                               std::unique_ptr<DesktopFrame> frame) {

-    frame_ = std::move(frame);

-  }

-

-protected:

-  std::unique_ptr<DesktopCapturer> screen_capturer_;

-  std::unique_ptr<DesktopFrame> frame_;

-};

-

-class AppCapturerLinux : public AppCapturer {

-public:

-  AppCapturerLinux(const DesktopCaptureOptions& options);

-  virtual ~AppCapturerLinux();

-

-  // AppCapturer interface.

-  virtual bool GetAppList(AppList* apps) override;

-  virtual bool SelectApp(ProcessId processId) override;

-  virtual bool BringAppToFront() override;

-

-  // DesktopCapturer interface.

-  virtual void Start(Callback* callback) override;

-  virtual void Stop() override;

-  virtual void CaptureFrame() override;

-  virtual bool SelectSource(SourceId id) override

-  {

-    return SelectApp(static_cast<ProcessId>(id));

-  }

-

-protected:

-  Display* GetDisplay() { return x_display_->display(); }

-  bool UpdateRegions();

-

-  void FillDesktopFrameRegionWithColor(DesktopFrame* pDesktopFrame,Region rgn, uint32_t color);

-private:

-  Callback* callback_;

-  ProcessId selected_process_;

-

-  // Sample Mode

-  ScreenCapturerProxy screen_capturer_proxy_;

-  // Mask of foreground (non-app windows in front of selected)

-  Region rgn_mask_;

-  // Region of selected windows

-  Region rgn_visual_;

-  // Mask of background (desktop, non-app windows behind selected)

-  Region rgn_background_;

-

-  rtc::scoped_refptr<SharedXDisplay> x_display_;

-  RTC_DISALLOW_COPY_AND_ASSIGN(AppCapturerLinux);

-};

-

-AppCapturerLinux::AppCapturerLinux(const DesktopCaptureOptions& options)

+AppCapturerX11::AppCapturerX11(const DesktopCaptureOptions& options)

     : callback_(NULL),

       selected_process_(0),

       x_display_(options.x_display()) {

@@ -103,7 +39,7 @@ AppCapturerLinux::AppCapturerLinux(const

   rgn_background_ = XCreateRegion();

 }

-AppCapturerLinux::~AppCapturerLinux() {

+AppCapturerX11::~AppCapturerX11() {

   if (rgn_mask_) {

     XDestroyRegion(rgn_mask_);

   }

@@ -116,32 +52,32 @@ AppCapturerLinux::~AppCapturerLinux() {

 }

 // AppCapturer interface.

-bool AppCapturerLinux::GetAppList(AppList* apps) {

+bool AppCapturerX11::GetAppList(AppList* apps) {

   // Implemented in DesktopDeviceInfo

   return true;

 }

-bool AppCapturerLinux::SelectApp(ProcessId processId) {

+bool AppCapturerX11::SelectApp(ProcessId processId) {

   selected_process_ = processId;

   return true;

 }

-bool AppCapturerLinux::BringAppToFront() {

+bool AppCapturerX11::BringAppToFront() {

   // Not implemented yet: See Bug 1036653

   return true;

 }

 // DesktopCapturer interface.

-void AppCapturerLinux::Start(Callback* callback) {

+void AppCapturerX11::Start(Callback* callback) {

   assert(!callback_);

   assert(callback);

   callback_ = callback;

 }

-void AppCapturerLinux::Stop() {

+void AppCapturerX11::Stop() {

   callback_ = NULL;

 }

-void AppCapturerLinux::CaptureFrame() {

+void AppCapturerX11::CaptureFrame() {

   XErrorTrap error_trap(GetDisplay());

   //Capture screen >> set root window as capture window

@@ -169,7 +105,7 @@ void AppCapturerLinux::CaptureFrame() {

   }

 }

-void AppCapturerLinux::FillDesktopFrameRegionWithColor(DesktopFrame* pDesktopFrame, Region rgn, uint32_t color) {

+void AppCapturerX11::FillDesktopFrameRegionWithColor(DesktopFrame* pDesktopFrame, Region rgn, uint32_t color) {

   XErrorTrap error_trap(GetDisplay());

   if (!pDesktopFrame) {

@@ -192,7 +128,7 @@ void AppCapturerLinux::FillDesktopFrameR

   }

 }

-bool AppCapturerLinux::UpdateRegions() {

+bool AppCapturerX11::UpdateRegions() {

   XErrorTrap error_trap(GetDisplay());

   XSubtractRegion(rgn_visual_, rgn_visual_, rgn_visual_);

@@ -269,21 +205,19 @@ bool AppCapturerLinux::UpdateRegions() {

   return true;

 }

-}  // namespace

-

 // static

-AppCapturer* AppCapturer::Create(const DesktopCaptureOptions& options) {

-  return new AppCapturerLinux(options);

+AppCapturer* AppCapturerX11::Create(const DesktopCaptureOptions& options) {

+  return new AppCapturerX11(options);

 }

 // static

-std::unique_ptr<DesktopCapturer> DesktopCapturer::CreateRawAppCapturer(

+std::unique_ptr<DesktopCapturer> AppCapturerX11::CreateRawAppCapturer(

     const DesktopCaptureOptions& options) {

   if (!options.x_display())

     return nullptr;

-  std::unique_ptr<AppCapturerLinux> capturer(new AppCapturerLinux(options));

+  std::unique_ptr<AppCapturerX11> capturer(new AppCapturerX11(options));

   return std::unique_ptr<DesktopCapturer>(std::move(capturer));

 }

diff -up firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.h.pipewire firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.h

--- firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.h.pipewire	2019-01-07 14:53:17.201061764 +0100

+++ firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/app_capturer_x11.h	2019-01-07 14:53:17.201061764 +0100

@@ -0,0 +1,98 @@

+/*

+ *  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_APP_CAPTURER_X11_H_

+#define MODULES_DESKTOP_CAPTURE_APP_CAPTURER_X11_H_

+

+#include <X11/X.h>

+#include <X11/Xlib.h>

+#include <memory>

+#include <string>

+

+#include "webrtc/modules/desktop_capture/app_capturer.h"

+#include "webrtc/modules/desktop_capture/shared_desktop_frame.h"

+#include "webrtc/modules/desktop_capture/desktop_capture_options.h"

+#include "webrtc/modules/desktop_capture/desktop_capturer.h"

+#include "webrtc/modules/desktop_capture/desktop_geometry.h"

+#include "webrtc/modules/desktop_capture/x11/shared_x_display.h"

+#include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"

+#include "webrtc/base/constructormagic.h"

+#include "webrtc/base/scoped_ref_ptr.h"

+

+namespace webrtc {

+

+class ScreenCapturerProxy : DesktopCapturer::Callback {

+public:

+  ScreenCapturerProxy()

+    : screen_capturer_(DesktopCapturer::CreateScreenCapturer(DesktopCaptureOptions::CreateDefault())) {

+    screen_capturer_->SelectSource(kFullDesktopScreenId);

+    screen_capturer_->Start(this);

+  }

+  void CaptureFrame() { screen_capturer_->CaptureFrame(); }

+  std::unique_ptr<DesktopFrame> GetFrame() { return std::move(frame_); }

+

+   // Callback interface

+  virtual void OnCaptureResult(DesktopCapturer::Result result,

+                               std::unique_ptr<DesktopFrame> frame) {

+    frame_ = std::move(frame);

+  }

+

+protected:

+  std::unique_ptr<DesktopCapturer> screen_capturer_;

+  std::unique_ptr<DesktopFrame> frame_;

+};

+

+class AppCapturerX11 : public AppCapturer {

+public:

+  AppCapturerX11(const DesktopCaptureOptions& options);

+  virtual ~AppCapturerX11();

+

+  static AppCapturer* Create(const DesktopCaptureOptions& options);

+  static std::unique_ptr<DesktopCapturer> CreateRawAppCapturer(const DesktopCaptureOptions& options);

+

+  // AppCapturer interface.

+  virtual bool GetAppList(AppList* apps) override;

+  virtual bool SelectApp(ProcessId processId) override;

+  virtual bool BringAppToFront() override;

+

+  // DesktopCapturer interface.

+  virtual void Start(Callback* callback) override;

+  virtual void Stop() override;

+  virtual void CaptureFrame() override;

+  virtual bool SelectSource(SourceId id) override

+  {

+    return SelectApp(static_cast<ProcessId>(id));

+  }

+

+protected:

+  Display* GetDisplay() { return x_display_->display(); }

+  bool UpdateRegions();

+

+  void FillDesktopFrameRegionWithColor(DesktopFrame* pDesktopFrame,Region rgn, uint32_t color);

+private:

+  Callback* callback_;

+  ProcessId selected_process_;

+

+  // Sample Mode

+  ScreenCapturerProxy screen_capturer_proxy_;

+  // Mask of foreground (non-app windows in front of selected)

+  Region rgn_mask_;

+  // Region of selected windows

+  Region rgn_visual_;

+  // Mask of background (desktop, non-app windows behind selected)

+  Region rgn_background_;

+

+  rtc::scoped_refptr<SharedXDisplay> x_display_;

+  RTC_DISALLOW_COPY_AND_ASSIGN(AppCapturerX11);

+};

+

+}  // namespace webrtc

+

+#endif  // MODULES_DESKTOP_CAPTURE_APP_CAPTURER_X11_H_

diff -up firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/base_capturer_pipewire.cc.pipewire firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/base_capturer_pipewire.cc

--- firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/base_capturer_pipewire.cc.pipewire	2019-01-07 14:53:17.201061764 +0100

+++ firefox-60.3.0/media/webrtc/trunk/webrtc/modules/desktop_capture/base_capturer_pipewire.cc	2019-01-07 14:53:17.201061764 +0100

@@ -0,0 +1,849 @@

+/*

+ *  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 <cstring>

+#include <gio/gunixfdlist.h>

+#include <glib-object.h>

+

+#include <spa/param/format-utils.h>

+#include <spa/param/props.h>

+#include <spa/param/video/raw-utils.h>

+#include <spa/support/type-map.h>

+

+#include "webrtc/modules/desktop_capture/base_capturer_pipewire.h"

+

+#include "webrtc/modules/desktop_capture/desktop_capture_options.h"

+#include "webrtc/modules/desktop_capture/desktop_capturer.h"

+#include "webrtc/base/checks.h"

+#include "webrtc/base/logging.h"

+

+namespace webrtc {

+

+const char kDesktopBusName[] = "org.freedesktop.portal.Desktop";

+const char kDesktopObjectPath[] = "/org/freedesktop/portal/desktop";

+const char kDesktopRequestObjectPath[] =

+    "/org/freedesktop/portal/desktop/request";

+const char kSessionInterfaceName[] = "org.freedesktop.portal.Session";

+const char kRequestInterfaceName[] = "org.freedesktop.portal.Request";

+const char kScreenCastInterfaceName[] = "org.freedesktop.portal.ScreenCast";

+

+const int kBytesPerPixelPw = 4;

+

+// static

+void BaseCapturerPipeWire::OnStateChanged(void* data,

+                                            pw_remote_state old_state,

+                                            pw_remote_state state,

+                                            const char* error_message) {

+  BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);

+  RTC_DCHECK(that);

+

+  switch (state) {

+    case PW_REMOTE_STATE_ERROR:

+      LOG(LS_ERROR) << "PipeWire remote state error: " << error_message;

+      break;

+    case PW_REMOTE_STATE_CONNECTED:

+      LOG(LS_INFO) << "PipeWire remote state: connected.";

+      that->CreateReceivingStream();

+      break;

+    case PW_REMOTE_STATE_CONNECTING:

+      LOG(LS_INFO) << "PipeWire remote state: connecting.";

+      break;

+    case PW_REMOTE_STATE_UNCONNECTED:

+      LOG(LS_INFO) << "PipeWire remote state: unconnected.";

+      break;

+  }

+}

+

+// static

+void BaseCapturerPipeWire::OnStreamStateChanged(void* data,

+                                                  pw_stream_state old_state,

+                                                  pw_stream_state state,

+                                                  const char* error_message) {

+  BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);

+  RTC_DCHECK(that);

+

+  switch (state) {

+    case PW_STREAM_STATE_ERROR:

+      LOG(LS_ERROR) << "PipeWire stream state error: " << error_message;

+      break;

+    case PW_STREAM_STATE_CONFIGURE:

+      pw_stream_set_active(that->pw_stream_, true);

+      break;

+    case PW_STREAM_STATE_UNCONNECTED:

+    case PW_STREAM_STATE_CONNECTING:

+    case PW_STREAM_STATE_READY:

+    case PW_STREAM_STATE_PAUSED:

+    case PW_STREAM_STATE_STREAMING:

+      break;

+  }

+}

+

+// static

+void BaseCapturerPipeWire::OnStreamFormatChanged(

+    void* data,

+    const struct spa_pod* format) {

+  BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);

+  RTC_DCHECK(that);

+

+  LOG(LS_INFO) << "PipeWire stream format changed.";

+

+  if (!format) {

+    pw_stream_finish_format(that->pw_stream_, /*res=*/0, /*params=*/nullptr,

+                            /*n_params=*/0);

+    return;

+  }

+

+  that->spa_video_format_ = new spa_video_info_raw();

+  spa_format_video_raw_parse(format, that->spa_video_format_,

+                             &that->pw_type_->format_video);

+

+  auto width = that->spa_video_format_->size.width;

+  auto height = that->spa_video_format_->size.height;

+  auto stride = SPA_ROUND_UP_N(width * kBytesPerPixelPw, 4);

+  auto size = height * stride;

+

+  uint8_t buffer[1024] = {};

+  auto builder = spa_pod_builder{buffer, sizeof(buffer)};

+

+  // Setup buffers and meta header for new format.

+  const struct spa_pod* params[2];

+  params[0] = reinterpret_cast<spa_pod*>(spa_pod_builder_object(

+      &builder,

+      // id to enumerate buffer requirements

+      that->pw_core_type_->param.idBuffers,

+      that->pw_core_type_->param_buffers.Buffers,

+      // Size: specified as integer (i) and set to specified size

+      ":", that->pw_core_type_->param_buffers.size, "i", size,

+      // Stride: specified as integer (i) and set to specified stride

+      ":", that->pw_core_type_->param_buffers.stride, "i", stride,

+      // Buffers: specifies how many buffers we want to deal with, set as

+      // integer (i) where preferred number is 8, then allowed number is defined

+      // as range (r) from min and max values and it is undecided (u) to allow

+      // negotiation

+      ":", that->pw_core_type_->param_buffers.buffers, "iru", 8,

+      SPA_POD_PROP_MIN_MAX(1, 32),

+      // Align: memory alignment of the buffer, set as integer (i) to specified

+      // value

+      ":", that->pw_core_type_->param_buffers.align, "i", 16));

+  params[1] = reinterpret_cast<spa_pod*>(spa_pod_builder_object(

+      &builder,

+      // id to enumerate supported metadata

+      that->pw_core_type_->param.idMeta, that->pw_core_type_->param_meta.Meta,

+      // Type: specified as id or enum (I)

+      ":", that->pw_core_type_->param_meta.type, "I",

+      that->pw_core_type_->meta.Header,

+      // Size: size of the metadata, specified as integer (i)

+      ":", that->pw_core_type_->param_meta.size, "i",

+      sizeof(struct spa_meta_header)));

+

+  pw_stream_finish_format(that->pw_stream_, /*res=*/0, params, /*n_params=*/2);

+}

+

+// static

+void BaseCapturerPipeWire::OnStreamProcess(void* data) {

+  BaseCapturerPipeWire* that = static_cast<BaseCapturerPipeWire*>(data);

+  RTC_DCHECK(that);

+

+  pw_buffer* buf = nullptr;

+

+  if (!(buf = pw_stream_dequeue_buffer(that->pw_stream_))) {

+    return;

+  }

+

+  that->HandleBuffer(buf);

+

+  pw_stream_queue_buffer(that->pw_stream_, buf);

+}

+

+BaseCapturerPipeWire::BaseCapturerPipeWire(CaptureSourceType source_type)

+    : capture_source_type_(source_type) {}

+

+BaseCapturerPipeWire::~BaseCapturerPipeWire() {

+  if (pw_main_loop_) {

+    pw_thread_loop_stop(pw_main_loop_);

+  }

+

+  if (pw_type_) {

+    delete pw_type_;

+  }

+

+  if (spa_video_format_) {

+    delete spa_video_format_;

+  }

+

+  if (pw_stream_) {

+    pw_stream_destroy(pw_stream_);

+  }

+

+  if (pw_remote_) {

+    pw_remote_destroy(pw_remote_);

+  }

+

+  if (pw_core_) {

+    pw_core_destroy(pw_core_);

+  }

+

+  if (pw_main_loop_) {

+    pw_thread_loop_destroy(pw_main_loop_);

+  }

+

+  if (pw_loop_) {

+    pw_loop_destroy(pw_loop_);

+  }

+

+  if (current_frame_) {

+    free(current_frame_);

+  }

+

+  if (start_request_signal_id_) {

+    g_dbus_connection_signal_unsubscribe(connection_, start_request_signal_id_);

+  }

+  if (sources_request_signal_id_) {

+    g_dbus_connection_signal_unsubscribe(connection_,

+                                         sources_request_signal_id_);

+  }

+  if (session_request_signal_id_) {

+    g_dbus_connection_signal_unsubscribe(connection_,

+                                         session_request_signal_id_);

+  }

+

+  if (session_handle_) {

+    GDBusMessage* message = g_dbus_message_new_method_call(

+        kDesktopBusName, session_handle_, kSessionInterfaceName, "Close");

+    if (message) {

+      GError* error = nullptr;

+      g_dbus_connection_send_message(connection_, message,

+                                     G_DBUS_SEND_MESSAGE_FLAGS_NONE,

+                                     /*out_serial=*/nullptr, &error);

+      if (error) {

+        LOG(LS_ERROR) << "Failed to close the session: " << error->message;

+        g_error_free(error);

+      }

+      g_object_unref(message);

+    }

+  }

+

+  g_free(start_handle_);

+  g_free(sources_handle_);

+  g_free(session_handle_);

+  g_free(portal_handle_);

+

+  if (proxy_) {

+    g_clear_object(&proxy_);

+  }

+}

+

+void BaseCapturerPipeWire::InitPortals() {

+  g_dbus_proxy_new_for_bus(

+      G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, /*info=*/nullptr,

+      kDesktopBusName, kDesktopObjectPath, kScreenCastInterfaceName,

+      /*cancellable=*/nullptr,

+      reinterpret_cast<GAsyncReadyCallback>(OnProxyRequested), this);

+}

+

+void BaseCapturerPipeWire::InitPipeWire() {

+  pw_init(/*argc=*/nullptr, /*argc=*/nullptr);

+

+  pw_loop_ = pw_loop_new(/*properties=*/nullptr);

+  pw_main_loop_ = pw_thread_loop_new(pw_loop_, "pipewire-main-loop");

+

+  pw_core_ = pw_core_new(pw_loop_, /*properties=*/nullptr);

+  pw_core_type_ = pw_core_get_type(pw_core_);

+  pw_remote_ = pw_remote_new(pw_core_, nullptr, /*user_data_size=*/0);

+

+  InitPipeWireTypes();

+

+  // Initialize event handlers, remote end and stream-related.

+  pw_remote_events_.version = PW_VERSION_REMOTE_EVENTS;

+  pw_remote_events_.state_changed = &OnStateChanged;

+

+  pw_stream_events_.version = PW_VERSION_STREAM_EVENTS;

+  pw_stream_events_.state_changed = &OnStreamStateChanged;

+  pw_stream_events_.format_changed = &OnStreamFormatChanged;

+  pw_stream_events_.process = &OnStreamProcess;

+

+  pw_remote_add_listener(pw_remote_, &spa_remote_listener_, &pw_remote_events_,

+                         this);

+  pw_remote_connect_fd(pw_remote_, pw_fd_);

+

+  if (pw_thread_loop_start(pw_main_loop_) < 0) {

+    LOG(LS_ERROR) << "Failed to start main PipeWire loop";

+    portal_init_failed_ = true;

+  }

+}

+

+void BaseCapturerPipeWire::InitPipeWireTypes() {

+  spa_type_map* map = pw_core_type_->map;

+  pw_type_ = new PipeWireType();

+

+  spa_type_media_type_map(map, &pw_type_->media_type);

+  spa_type_media_subtype_map(map, &pw_type_->media_subtype);

+  spa_type_format_video_map(map, &pw_type_->format_video);

+  spa_type_video_format_map(map, &pw_type_->video_format);

+}

+

+void BaseCapturerPipeWire::CreateReceivingStream() {

+  spa_rectangle pwMinScreenBounds = spa_rectangle{1, 1};

+  spa_rectangle pwScreenBounds =

+      spa_rectangle{static_cast<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};

+

+  pw_properties* reuseProps = pw_properties_new("pipewire.client.reuse", "1",

+                                                /*end of varargs*/ nullptr);

+  pw_stream_ = pw_stream_new(pw_remote_, "webrtc-consume-stream", reuseProps);

+

+  uint8_t buffer[1024] = {};

+  const spa_pod* params[1];

+  spa_pod_builder builder = spa_pod_builder{buffer, sizeof(buffer)};

+  params[0] = reinterpret_cast<spa_pod*>(spa_pod_builder_object(

+      &builder,

+      // id to enumerate formats

+      pw_core_type_->param.idEnumFormat, pw_core_type_->spa_format, "I",

+      pw_type_->media_type.video, "I", pw_type_->media_subtype.raw,

+      // Video format: specified as id or enum (I), preferred format is BGRx,

+      // then allowed formats are enumerated (e) and the format is undecided (u)

+      // to allow negotiation

+      ":", pw_type_->format_video.format, "Ieu", pw_type_->video_format.BGRx,

+      SPA_POD_PROP_ENUM(2, pw_type_->video_format.RGBx,

+                        pw_type_->video_format.BGRx),

+      // Video size: specified as rectangle (R), preferred size is specified as

+      // first parameter, then allowed size is defined as range (r) from min and

+      // max values and the format is undecided (u) to allow negotiation

+      ":", pw_type_->format_video.size, "Rru", &pwScreenBounds, 2,

+      &pwMinScreenBounds, &pwScreenBounds,

+      // Frame rate: specified as fraction (F) and set to minimum frame rate

+      // value

+      ":", pw_type_->format_video.framerate, "F", &pwFrameRateMin,

+      // Max frame rate: specified as fraction (F), preferred frame rate is set

+      // to maximum value, then allowed frame rate is defined as range (r) from

+      // min and max values and it is undecided (u) to allow negotiation

+      ":", pw_type_->format_video.max_framerate, "Fru", &pwFrameRateMax, 2,

+      &pwFrameRateMin, &pwFrameRateMax));

+

+  pw_stream_add_listener(pw_stream_, &spa_stream_listener_, &pw_stream_events_,

+                         this);

+  pw_stream_flags flags = static_cast<pw_stream_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,

+                        flags, params,

+                        /*n_params=*/1) != 0) {

+    LOG(LS_ERROR) << "Could not connect receiving stream.";

+    portal_init_failed_ = true;

+    return;

+  }

+}

+

+void BaseCapturerPipeWire::HandleBuffer(pw_buffer* buffer) {

+  spa_buffer* spaBuffer = buffer->buffer;

+  void* src = nullptr;

+

+  if (!(src = spaBuffer->datas[0].data)) {

+    return;

+  }

+

+  uint32_t maxSize = spaBuffer->datas[0].maxsize;

+  int32_t srcStride = spaBuffer->datas[0].chunk->stride;

+  if (srcStride != (desktop_size_.width() * kBytesPerPixelPw)) {

+    LOG(LS_ERROR) << "Got buffer with stride different from screen stride: "

+                      << srcStride

+                      << " != " << (desktop_size_.width() * kBytesPerPixelPw);