diff --git a/config/system-headers.mozbuild b/config/system-headers.mozbuild

--- a/config/system-headers.mozbuild

+++ b/config/system-headers.mozbuild

     'Gestalt.h',

     'getopt.h',

     'gio/gio.h',

+    'gio/gunixfdlist.h',

     'glibconfig.h',

     'glib.h',

     'glib-object.h',

     'Pgenerr.h',

     'PGenErr.h',

     'Ph.h',

+    'pipewire/pipewire.h',

     'pixman.h',

     'pk11func.h',

     'pk11pqg.h',

diff --git a/media/webrtc/trunk/webrtc/modules/desktop_capture/BUILD.gn b/media/webrtc/trunk/webrtc/modules/desktop_capture/BUILD.gn

--- a/media/webrtc/trunk/webrtc/modules/desktop_capture/BUILD.gn

+++ b/media/webrtc/trunk/webrtc/modules/desktop_capture/BUILD.gn

 if (is_linux) {

   if (rtc_use_pipewire) {

     pkg_config("pipewire") {

-      packages = [ "libpipewire-0.2" ]

+      packages = [ "libpipewire-0.3" ]

       defines = [ "WEBRTC_USE_PIPEWIRE" ]

     }

diff --git a/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_generic_gn/moz.build b/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_generic_gn/moz.build

--- a/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_generic_gn/moz.build

+++ b/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_generic_gn/moz.build

     ]

+# PipeWire specific files

+if CONFIG["OS_TARGET"] == "Linux":

+

+    DEFINES["WEBRTC_USE_PIPEWIRE"] = "1"

+

+    OS_LIBS += [

+        "rt",

+        "pipewire-0.3",

+        "glib-2.0",

+        "gio-2.0",

+        "gobject-2.0"

+    ]

+

+    CXXFLAGS += CONFIG['TK_CFLAGS']

+    CXXFLAGS += [ "-I/usr/include/pipewire-0.3" ]

+    CXXFLAGS += [ "-I/usr/include/spa-0.2" ]

+

+    UNIFIED_SOURCES += [

+        "/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc",

+        "/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/screen_capturer_pipewire.cc",

+        "/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/window_capturer_pipewire.cc"

+    ]

+

+

 if CONFIG["OS_TARGET"] == "NetBSD":

     DEFINES["USE_X11"] = "1"

diff --git a/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_options.h b/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_options.h

--- a/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_options.h

+++ b/media/webrtc/trunk/webrtc/modules/desktop_capture/desktop_capture_options.h

   bool disable_effects_ = true;

   bool detect_updated_region_ = false;

 #if defined(WEBRTC_USE_PIPEWIRE)

-  bool allow_pipewire_ = false;

+  bool allow_pipewire_ = true;

 #endif

 };

diff --git a/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc b/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc

--- a/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc

+++ b/media/webrtc/trunk/webrtc/modules/desktop_capture/linux/base_capturer_pipewire.cc

 #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 <linux/dma-buf.h>

+#include <sys/mman.h>

+#include <sys/ioctl.h>

+#include <sys/syscall.h>

 #include <memory>

 #include <utility>

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

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

-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:

-      RTC_LOG(LS_ERROR) << "PipeWire remote state error: " << error_message;

+  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;

-    case PW_REMOTE_STATE_UNCONNECTED:

-      RTC_LOG(LS_INFO) << "PipeWire remote state: unconnected.";

+    }

   }

 }

+void BaseCapturerPipeWire::OnCoreError(void *data,

+                                       uint32_t id,

+                                       int seq,

+                                       int res,

+                                       const char *message) {

+  RTC_LOG(LS_ERROR) << "core error: " << message;

+}

+

 void BaseCapturerPipeWire::OnStreamStateChanged(void* data,

                                                 pw_stream_state old_state,

     case PW_STREAM_STATE_ERROR:

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

       break;

-    case PW_STREAM_STATE_CONFIGURE:

-      pw_stream_set_active(that->pw_stream_, true);

-      break;

-    case PW_STREAM_STATE_READY:

       break;

   }

 }

 // static

-void BaseCapturerPipeWire::OnStreamFormatChanged(void* data,

-                                                 const struct spa_pod* format) {

+void BaseCapturerPipeWire::OnStreamParamChanged(void *data, uint32_t id,

+                                                const struct spa_pod *format) {

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

   RTC_DCHECK(that);

-  RTC_LOG(LS_INFO) << "PipeWire stream format changed.";

+  RTC_LOG(LS_INFO) << "PipeWire stream param changed.";

-  if (!format) {

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

-                            /*n_params=*/0);

+  if (!format || id != SPA_PARAM_Format) {

     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);

+  spa_format_video_raw_parse(format, &that->spa_video_format_);

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

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

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

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

   auto stride = SPA_ROUND_UP_N(width * kBytesPerPixel, 4);

   auto size = height * stride;

+  that->desktop_size_ = DesktopSize(width, height);

+

   uint8_t buffer[1024] = {};

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

   // Setup buffers and meta header for new format.

-  const struct spa_pod* params[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);

+  const struct spa_pod* params[3];

+  params[0] = reinterpret_cast<spa_pod *>(spa_pod_builder_add_object(&builder,

+              SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,

+              SPA_PARAM_BUFFERS_size, SPA_POD_Int(size),

+              SPA_PARAM_BUFFERS_stride, SPA_POD_Int(stride),

+              SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(8, 1, 32)));

+  params[1] = reinterpret_cast<spa_pod *>(spa_pod_builder_add_object(&builder,

+              SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,

+              SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),

+              SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header))));

+  params[2] = reinterpret_cast<spa_pod *>(spa_pod_builder_add_object(&builder,

+              SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,

+              SPA_PARAM_META_type, SPA_POD_Id (SPA_META_VideoCrop),

+              SPA_PARAM_META_size, SPA_POD_Int (sizeof(struct spa_meta_region))));

+  pw_stream_update_params(that->pw_stream_, params, 3);

 }

 // static

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

   RTC_DCHECK(that);

-  pw_buffer* buf = nullptr;

+  struct pw_buffer *next_buffer;

+  struct pw_buffer *buffer = nullptr;

+  next_buffer = pw_stream_dequeue_buffer(that->pw_stream_);

+  while (next_buffer) {

+    buffer = next_buffer;

+    next_buffer = pw_stream_dequeue_buffer(that->pw_stream_);

+    if (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)

     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_disconnect(pw_core_);

   }

-  if (pw_core_) {

-    pw_core_destroy(pw_core_);

+  if (pw_context_) {

+    pw_context_destroy(pw_context_);

   }

   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_);

   }

 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_main_loop_ = pw_thread_loop_new("pipewire-main-loop", nullptr);

+  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;

+  }

-  InitPipeWireTypes();

+  pw_core_ = pw_context_connect(pw_context_, nullptr, 0);

+  if (!pw_core_) {

+    RTC_LOG(LS_ERROR) << "Failed to connect PipeWire context";

+    return;

+  }

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

-  pw_remote_events_.version = PW_VERSION_REMOTE_EVENTS;

-  pw_remote_events_.state_changed = &OnStateChanged;

+  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_.format_changed = &OnStreamFormatChanged;

+  pw_stream_events_.param_changed = &OnStreamParamChanged;

   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_);

+  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;

+  }

   if (pw_thread_loop_start(pw_main_loop_) < 0) {

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

   }

 }

-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 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);

+  if (!stream) {

+    RTC_LOG(LS_ERROR) << "Could not create receiving stream.";

+    return nullptr;

+  }

   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,