Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 456 insertions, 0 deletions

diff --git a/third_party/pipewire/libpipewire/moz.build b/third_party/pipewire/libpipewire/moz.build
new file mode 100644
index 0000000000..3102b3cb69
--- /dev/null
+++ b/third_party/pipewire/libpipewire/moz.build
@@ -0,0 +1,16 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+SOURCES += [
+    'mozpipewire.cpp',
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+    CXXFLAGS += CONFIG['MOZ_GTK3_CFLAGS']
+
+LOCAL_INCLUDES += ['/third_party/pipewire']
+
+FINAL_LIBRARY = 'xul'
diff --git a/third_party/pipewire/libpipewire/mozpipewire.cpp b/third_party/pipewire/libpipewire/mozpipewire.cpp
new file mode 100644
index 0000000000..b806829674
--- /dev/null
+++ b/third_party/pipewire/libpipewire/mozpipewire.cpp
@@ -0,0 +1,440 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <glib.h>
+#include "mozilla/Types.h"
+#include "prlink.h"
+
+#include <pipewire/pipewire.h>
+
+#define GET_FUNC(func, lib)                                  \
+    func##_fn =                                              \
+      (decltype(func##_fn))PR_FindFunctionSymbol(lib, #func) \
+
+#define IS_FUNC_LOADED(func)                                          \
+    (func != nullptr)                                                 \
+
+struct GUnixFDList;
+
+extern "C" gint
+g_unix_fd_list_get(struct GUnixFDList *list,
+                   gint index_,
+                   GError **error)
+{
+  static PRLibrary* gioLib = nullptr;
+  static bool gioInitialized = false;
+  static gint (*g_unix_fd_list_get_fn)(struct GUnixFDList *list,
+               gint index_, GError **error) = nullptr;
+
+  if (!gioInitialized) {
+    gioInitialized = true;
+    gioLib = PR_LoadLibrary("libgio-2.0.so.0");
+    if (!gioLib) {
+      return -1;
+    }
+    GET_FUNC(g_unix_fd_list_get, gioLib);
+  }
+
+  if (!g_unix_fd_list_get_fn) {
+    return -1;
+  }
+
+  return g_unix_fd_list_get_fn(list, index_, error);
+}
+
+static struct pw_core * (*pw_context_connect_fn)(struct pw_context *context,
+                                              struct pw_properties *properties,
+                                              size_t user_data_size);
+static struct pw_core * (*pw_context_connect_fd_fn)(struct pw_context *context,
+                                                    int fd,
+                                                    struct pw_properties *properties,
+                                                    size_t user_data_size);
+static void (*pw_context_destroy_fn)(struct pw_context *context);
+struct pw_context * (*pw_context_new_fn)(struct pw_loop *main_loop,
+                                      struct pw_properties *props,
+                                      size_t user_data_size);
+static int (*pw_core_disconnect_fn)(struct pw_core *core);
+static void (*pw_init_fn)(int *argc, char **argv[]);
+static void (*pw_proxy_destroy_fn)(struct pw_proxy *proxy);
+static void (*pw_stream_add_listener_fn)(struct pw_stream *stream,
+                                      struct spa_hook *listener,
+                                      const struct pw_stream_events *events,
+                                      void *data);
+static int (*pw_stream_connect_fn)(struct pw_stream *stream,
+                                enum pw_direction direction,
+                                uint32_t target_id,
+                                enum pw_stream_flags flags,
+                                const struct spa_pod **params,
+                                uint32_t n_params);
+static int (*pw_stream_disconnect_fn)(struct pw_stream *stream);
+static struct pw_buffer* (*pw_stream_dequeue_buffer_fn)(struct pw_stream *stream);
+static void (*pw_stream_destroy_fn)(struct pw_stream *stream);
+static struct pw_stream* (*pw_stream_new_fn)(struct pw_core *core,
+                                          const char *name,
+                                          struct pw_properties *props);
+
+static int (*pw_stream_queue_buffer_fn)(struct pw_stream *stream,
+                                     struct pw_buffer *buffer);
+static const char * (*pw_stream_state_as_string_fn)(enum pw_stream_state state);
+static int (*pw_stream_update_params_fn)(struct pw_stream *stream,
+                                      const struct spa_pod **params,
+                                      uint32_t n_params);
+static void (*pw_thread_loop_destroy_fn)(struct pw_thread_loop *loop);
+static struct pw_loop* (*pw_thread_loop_get_loop_fn)(struct pw_thread_loop *loop);
+static struct pw_thread_loop* (*pw_thread_loop_new_fn)(const char *name,
+                                                const struct spa_dict *props);
+static int (*pw_thread_loop_start_fn)(struct pw_thread_loop *loop);
+static void (*pw_thread_loop_stop_fn)(struct pw_thread_loop *loop);
+static void (*pw_thread_loop_lock_fn)(struct pw_thread_loop *loop);
+static void (*pw_thread_loop_unlock_fn)(struct pw_thread_loop *loop);
+static void (*pw_thread_loop_wait_fn)(struct pw_thread_loop *loop);
+static void (*pw_thread_loop_signal_fn)(struct pw_thread_loop *loop, bool wait_for_accept);
+static struct pw_properties* (*pw_properties_new_string_fn)(const char *str);
+static const char* (*pw_get_library_version_fn)();
+
+bool IsPwLibraryLoaded() {
+  static bool isLoaded =
+         (IS_FUNC_LOADED(pw_context_connect_fn) &&
+          IS_FUNC_LOADED(pw_context_connect_fd_fn) &&
+          IS_FUNC_LOADED(pw_context_destroy_fn) &&
+          IS_FUNC_LOADED(pw_context_new_fn) &&
+          IS_FUNC_LOADED(pw_core_disconnect_fn) &&
+          IS_FUNC_LOADED(pw_init_fn) &&
+          IS_FUNC_LOADED(pw_proxy_destroy_fn) &&
+          IS_FUNC_LOADED(pw_stream_add_listener_fn) &&
+          IS_FUNC_LOADED(pw_stream_connect_fn) &&
+          IS_FUNC_LOADED(pw_stream_disconnect_fn) &&
+          IS_FUNC_LOADED(pw_stream_dequeue_buffer_fn) &&
+          IS_FUNC_LOADED(pw_stream_destroy_fn) &&
+          IS_FUNC_LOADED(pw_stream_new_fn) &&
+          IS_FUNC_LOADED(pw_stream_queue_buffer_fn) &&
+          IS_FUNC_LOADED(pw_stream_state_as_string_fn) &&
+          IS_FUNC_LOADED(pw_stream_update_params_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_destroy_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_get_loop_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_new_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_start_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_stop_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_lock_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_unlock_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_signal_fn) &&
+          IS_FUNC_LOADED(pw_thread_loop_wait_fn) &&
+          IS_FUNC_LOADED(pw_properties_new_string_fn) &&
+          IS_FUNC_LOADED(pw_get_library_version_fn));
+
+  return isLoaded;
+}
+
+bool LoadPWLibrary() {
+  static PRLibrary* pwLib = nullptr;
+  static bool pwInitialized = false;
+
+  //TODO Thread safe
+  if (!pwInitialized) {
+    pwInitialized = true;
+    pwLib = PR_LoadLibrary("libpipewire-0.3.so.0");
+    if (!pwLib) {
+      return false;
+    }
+
+    GET_FUNC(pw_context_connect, pwLib);
+    GET_FUNC(pw_context_connect_fd, pwLib);
+    GET_FUNC(pw_context_destroy, pwLib);
+    GET_FUNC(pw_context_new, pwLib);
+    GET_FUNC(pw_core_disconnect, pwLib);
+    GET_FUNC(pw_init, pwLib);
+    GET_FUNC(pw_stream_add_listener, pwLib);
+    GET_FUNC(pw_stream_connect, pwLib);
+    GET_FUNC(pw_stream_disconnect, pwLib);
+    GET_FUNC(pw_stream_dequeue_buffer, pwLib);
+    GET_FUNC(pw_stream_destroy, pwLib);
+    GET_FUNC(pw_stream_new, pwLib);
+    GET_FUNC(pw_stream_queue_buffer, pwLib);
+    GET_FUNC(pw_stream_update_params, pwLib);
+    GET_FUNC(pw_stream_state_as_string, pwLib);
+    GET_FUNC(pw_thread_loop_destroy, pwLib);
+    GET_FUNC(pw_thread_loop_get_loop, pwLib);
+    GET_FUNC(pw_thread_loop_new, pwLib);
+    GET_FUNC(pw_thread_loop_start, pwLib);
+    GET_FUNC(pw_thread_loop_stop, pwLib);
+    GET_FUNC(pw_thread_loop_lock, pwLib);
+    GET_FUNC(pw_thread_loop_unlock, pwLib);
+    GET_FUNC(pw_thread_loop_signal, pwLib);
+    GET_FUNC(pw_thread_loop_wait, pwLib);
+    GET_FUNC(pw_properties_new_string, pwLib);
+    GET_FUNC(pw_get_library_version, pwLib);
+    GET_FUNC(pw_proxy_destroy, pwLib);
+  }
+
+  return IsPwLibraryLoaded();
+}
+
+struct pw_core *
+pw_context_connect(struct pw_context *context,
+                   struct pw_properties *properties,
+                   size_t user_data_size)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_context_connect_fn(context, properties, user_data_size);
+}
+
+struct pw_core *
+pw_context_connect_fd(struct pw_context *context,
+                      int fd,
+                      struct pw_properties *properties,
+                      size_t user_data_size)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_context_connect_fd_fn(context, fd, properties, user_data_size);
+}
+
+void
+pw_context_destroy(struct pw_context *context)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  pw_context_destroy_fn(context);
+}
+
+struct pw_context *
+pw_context_new(struct pw_loop *main_loop,
+               struct pw_properties *props,
+               size_t user_data_size)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_context_new_fn(main_loop, props, user_data_size);
+}
+
+int
+pw_core_disconnect(struct pw_core *core)
+{
+  if (!LoadPWLibrary()) {
+    return 0;
+  }
+  return pw_core_disconnect_fn(core);
+}
+
+void
+pw_init(int *argc, char **argv[])
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_init_fn(argc, argv);
+}
+
+void
+pw_proxy_destroy(struct pw_proxy *proxy)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_proxy_destroy_fn(proxy);
+}
+
+void
+pw_stream_add_listener(struct pw_stream *stream,
+                       struct spa_hook *listener,
+                       const struct pw_stream_events *events,
+                       void *data)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_stream_add_listener_fn(stream, listener, events, data);
+}
+
+int
+pw_stream_connect(struct pw_stream *stream,
+                  enum pw_direction direction,
+                  uint32_t target_id,
+                  enum pw_stream_flags flags,
+                  const struct spa_pod **params,
+                  uint32_t n_params)
+{
+  if (!LoadPWLibrary()) {
+    return 0;
+  }
+  return pw_stream_connect_fn(stream, direction, target_id, flags,
+                              params, n_params);
+}
+
+int
+pw_stream_disconnect(struct pw_stream *stream)
+{
+  if (!LoadPWLibrary()) {
+    return 0;
+  }
+  return pw_stream_disconnect_fn(stream);
+}
+
+struct pw_buffer *
+pw_stream_dequeue_buffer(struct pw_stream *stream)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_stream_dequeue_buffer_fn(stream);
+}
+
+void
+pw_stream_destroy(struct pw_stream *stream)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_stream_destroy_fn(stream);
+}
+
+struct pw_stream *
+pw_stream_new(struct pw_core *core,
+              const char *name,
+              struct pw_properties *props)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_stream_new_fn(core, name, props);
+}
+
+int
+pw_stream_queue_buffer(struct pw_stream *stream,
+                       struct pw_buffer *buffer)
+{
+  if (!LoadPWLibrary()) {
+    return 0;
+  }
+  return pw_stream_queue_buffer_fn(stream, buffer);
+}
+
+const char *
+pw_stream_state_as_string(enum pw_stream_state state)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_stream_state_as_string_fn(state);
+}
+
+int
+pw_stream_update_params(struct pw_stream *stream,
+                        const struct spa_pod **params,
+                        uint32_t n_params)
+{
+  if (!LoadPWLibrary()) {
+    return 0;
+  }
+  return pw_stream_update_params_fn(stream, params, n_params);
+}
+
+void
+pw_thread_loop_destroy(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_thread_loop_destroy_fn(loop);
+}
+
+struct pw_loop *
+pw_thread_loop_get_loop(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_thread_loop_get_loop_fn(loop);
+}
+
+struct pw_thread_loop *
+pw_thread_loop_new(const char *name,
+                   const struct spa_dict *props)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_thread_loop_new_fn(name, props);
+}
+
+int
+pw_thread_loop_start(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return 0;
+  }
+  return pw_thread_loop_start_fn(loop);
+}
+
+void
+pw_thread_loop_stop(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_thread_loop_stop_fn(loop);
+}
+
+void
+pw_thread_loop_lock(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_thread_loop_lock_fn(loop);
+}
+
+void
+pw_thread_loop_unlock(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_thread_loop_unlock_fn(loop);
+}
+
+void
+pw_thread_loop_signal(struct pw_thread_loop *loop, bool wait_for_accept)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_thread_loop_signal_fn(loop, wait_for_accept);
+}
+
+void
+pw_thread_loop_wait(struct pw_thread_loop *loop)
+{
+  if (!LoadPWLibrary()) {
+    return;
+  }
+  return pw_thread_loop_wait_fn(loop);
+}
+
+struct pw_properties *
+pw_properties_new_string(const char *str)
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_properties_new_string_fn(str);
+}
+
+const char*
+pw_get_library_version()
+{
+  if (!LoadPWLibrary()) {
+    return nullptr;
+  }
+  return pw_get_library_version_fn();
+}
+