Updated to 83.0, Updated PipeWire patches from mozbz#1672944

1 files changed, 18928 insertions, 0 deletions

diff --git a/pw4.patch b/pw4.patch
new file mode 100644
index 0000000..03bda37
--- /dev/null
+++ b/pw4.patch
@@ -0,0 +1,18928 @@
+
+# HG changeset patch
+# User stransky <stransky@redhat.com>
+# Date 1604009732 0
+# Node ID e5e706b532041baa3ef46420c9bf10629b0cb3ba
+# Parent  7dad14e6de1a80a5c6a194df8a7b16504fb3d617
+Bug 1672945 Ship PipeWire 0.3 headers and library wrapper to build PW support out of the box, r=dminor
+
+- Ship PipeWire 0.3 headers at third_party/pipewire/pipewire
+- Ship SPA 0.2 headers at third_party/pipewire/spa
+- Ship PipeWire library wrapper at third_party/pipewire/libpipewire
+
+Differential Revision: https://phabricator.services.mozilla.com/D94580
+
+diff --git a/third_party/pipewire/README b/third_party/pipewire/README
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/README
+@@ -0,0 +1,4 @@
++Libpipewire is a pipewire library wrapper needed to build and run Firefox with
++Pipewire support on Linux (https://pipewire.org/).
++
++Pipewire directory stores headers of pipewire-0.2 and spa-0.2 needed for build only.
+diff --git a/third_party/pipewire/libpipewire/moz.build b/third_party/pipewire/libpipewire/moz.build
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/libpipewire/moz.build
+@@ -0,0 +1,15 @@
++# -*- 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',
++]
++
++CXXFLAGS += CONFIG['TK_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
+--- /dev/null
++++ b/third_party/pipewire/libpipewire/mozpipewire.cpp
+@@ -0,0 +1,312 @@
++/* -*- 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 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_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 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 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);
++
++bool IsPwLibraryLoaded() {
++  static bool isLoaded =
++         (IS_FUNC_LOADED(pw_context_connect_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_stream_add_listener_fn) &&
++          IS_FUNC_LOADED(pw_stream_connect_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_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));
++
++  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_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_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_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);
++  }
++
++  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);
++}
++
++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_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);
++}
++
++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);
++}
++
++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);
++}
+diff --git a/third_party/pipewire/pipewire/array.h b/third_party/pipewire/pipewire/array.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/array.h
+@@ -0,0 +1,165 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_ARRAY_H
++#define PIPEWIRE_ARRAY_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <errno.h>
++
++#include <spa/utils/defs.h>
++
++/** \class pw_array
++ *
++ * \brief An array object
++ *
++ * The array is a dynamically resizable data structure that can
++ * hold items of the same size.
++ */
++struct pw_array {
++	void *data;		/**< pointer to array data */
++	size_t size;		/**< length of array in bytes */
++	size_t alloc;		/**< number of allocated memory in \a data */
++	size_t extend;		/**< number of bytes to extend with */
++};
++
++#define PW_ARRAY_INIT(extend) (struct pw_array) { NULL, 0, 0, extend }
++
++#define pw_array_get_len_s(a,s)			((a)->size / (s))
++#define pw_array_get_unchecked_s(a,idx,s,t)	SPA_MEMBER((a)->data,(idx)*(s),t)
++#define pw_array_check_index_s(a,idx,s)		((idx) < pw_array_get_len_s(a,s))
++
++/** Get the number of items of type \a t in array \memberof pw_array */
++#define pw_array_get_len(a,t)			pw_array_get_len_s(a,sizeof(t))
++/** Get the item with index \a idx and type \a t from array \memberof pw_array */
++#define pw_array_get_unchecked(a,idx,t)		pw_array_get_unchecked_s(a,idx,sizeof(t),t)
++/** Check if an item with index \a idx and type \a t exist in array \memberof pw_array */
++#define pw_array_check_index(a,idx,t)		pw_array_check_index_s(a,idx,sizeof(t))
++
++#define pw_array_first(a)	((a)->data)
++#define pw_array_end(a)		SPA_MEMBER((a)->data, (a)->size, void)
++#define pw_array_check(a,p)	(SPA_MEMBER(p,sizeof(*p),void) <= pw_array_end(a))
++
++#define pw_array_for_each(pos, array)					\
++	for (pos = (__typeof__(pos)) pw_array_first(array);		\
++	     pw_array_check(array, pos);				\
++	     (pos)++)
++
++#define pw_array_consume(pos, array)					\
++	for (pos = (__typeof__(pos)) pw_array_first(array);		\
++	     pw_array_check(array, pos);				\
++	     pos = (__typeof__(pos)) pw_array_first(array))
++
++#define pw_array_remove(a,p)						\
++({									\
++	(a)->size -= sizeof(*(p));					\
++	memmove(p, SPA_MEMBER((p), sizeof(*(p)), void),			\
++                SPA_PTRDIFF(pw_array_end(a),(p)));			\
++})
++
++/** Initialize the array with given extend \memberof pw_array */
++static inline void pw_array_init(struct pw_array *arr, size_t extend)
++{
++	arr->data = NULL;
++	arr->size = arr->alloc = 0;
++	arr->extend = extend;
++}
++
++/** Clear the array */
++static inline void pw_array_clear(struct pw_array *arr)
++{
++	free(arr->data);
++}
++
++/** Reset the array */
++static inline void pw_array_reset(struct pw_array *arr)
++{
++	arr->size = 0;
++}
++
++/** Make sure \a size bytes can be added to the array \memberof pw_array */
++static inline int pw_array_ensure_size(struct pw_array *arr, size_t size)
++{
++	size_t alloc, need;
++
++	alloc = arr->alloc;
++	need = arr->size + size;
++
++	if (SPA_UNLIKELY(alloc < need)) {
++		void *data;
++		alloc = SPA_MAX(alloc, arr->extend);
++		while (alloc < need)
++			alloc *= 2;
++		if (SPA_UNLIKELY((data = realloc(arr->data, alloc)) == NULL))
++			return -errno;
++		arr->data = data;
++		arr->alloc = alloc;
++	}
++	return 0;
++}
++
++/** Add \a ref size bytes to \a arr. A pointer to memory that can
++ * hold at least \a size bytes is returned \memberof pw_array */
++static inline void *pw_array_add(struct pw_array *arr, size_t size)
++{
++	void *p;
++
++	if (pw_array_ensure_size(arr, size) < 0)
++		return NULL;
++
++	p = SPA_MEMBER(arr->data, arr->size, void);
++	arr->size += size;
++
++	return p;
++}
++
++/** Add \a ref size bytes to \a arr. When there is not enough memory to
++ * hold \a size bytes, NULL is returned \memberof pw_array */
++static inline void *pw_array_add_fixed(struct pw_array *arr, size_t size)
++{
++	void *p;
++
++	if (SPA_UNLIKELY(arr->alloc < arr->size + size)) {
++		errno = ENOSPC;
++		return NULL;
++	}
++
++	p = SPA_MEMBER(arr->data, arr->size, void);
++	arr->size += size;
++
++	return p;
++}
++
++/** Add a pointer to array \memberof pw_array */
++#define pw_array_add_ptr(a,p)					\
++	*((void**) pw_array_add(a, sizeof(void*))) = (p)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_ARRAY_H */
+diff --git a/third_party/pipewire/pipewire/buffers.h b/third_party/pipewire/pipewire/buffers.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/buffers.h
+@@ -0,0 +1,60 @@
++/* PipeWire
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_BUFFERS_H
++#define PIPEWIRE_BUFFERS_H
++
++#include <spa/node/node.h>
++
++#include <pipewire/context.h>
++#include <pipewire/mem.h>
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#define PW_BUFFERS_FLAG_NONE		0
++#define PW_BUFFERS_FLAG_NO_MEM		(1<<0)	/**< don't allocate buffer memory */
++#define PW_BUFFERS_FLAG_SHARED		(1<<1)	/**< buffers can be shared */
++#define PW_BUFFERS_FLAG_DYNAMIC		(1<<2)	/**< buffers have dynamic data */
++
++struct pw_buffers {
++	struct pw_memblock *mem;	/**< allocated buffer memory */
++	struct spa_buffer **buffers;	/**< port buffers */
++	uint32_t n_buffers;		/**< number of port buffers */
++	uint32_t flags;			/**< flags */
++};
++
++int pw_buffers_negotiate(struct pw_context *context, uint32_t flags,
++		struct spa_node *outnode, uint32_t out_port_id,
++		struct spa_node *innode, uint32_t in_port_id,
++		struct pw_buffers *result);
++
++void pw_buffers_clear(struct pw_buffers *buffers);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_BUFFERS_H */
+diff --git a/third_party/pipewire/pipewire/client.h b/third_party/pipewire/pipewire/client.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/client.h
+@@ -0,0 +1,171 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_CLIENT_H
++#define PIPEWIRE_CLIENT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/param/param.h>
++
++#include <pipewire/proxy.h>
++#include <pipewire/permission.h>
++
++#define PW_TYPE_INTERFACE_Client	PW_TYPE_INFO_INTERFACE_BASE "Client"
++
++#define PW_VERSION_CLIENT		3
++struct pw_client;
++
++/* default ID of the current client after connect */
++#define PW_ID_CLIENT			1
++
++/** The client information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_client_info {
++	uint32_t id;			/**< id of the global */
++#define PW_CLIENT_CHANGE_MASK_PROPS	(1 << 0)
++#define PW_CLIENT_CHANGE_MASK_ALL	((1 << 1)-1)
++	uint64_t change_mask;		/**< bitfield of changed fields since last call */
++	struct spa_dict *props;		/**< extra properties */
++};
++
++/** Update and existing \ref pw_client_info with \a update \memberof pw_introspect */
++struct pw_client_info *
++pw_client_info_update(struct pw_client_info *info,
++		      const struct pw_client_info *update);
++
++/** Free a \ref pw_client_info \memberof pw_introspect */
++void pw_client_info_free(struct pw_client_info *info);
++
++
++#define PW_CLIENT_EVENT_INFO		0
++#define PW_CLIENT_EVENT_PERMISSIONS	1
++#define PW_CLIENT_EVENT_NUM		2
++
++/** Client events */
++struct pw_client_events {
++#define PW_VERSION_CLIENT_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify client info
++	 *
++	 * \param info info about the client
++	 */
++	void (*info) (void *object, const struct pw_client_info *info);
++	/**
++	 * Notify a client permission
++	 *
++	 * Event emitted as a result of the get_permissions method.
++	 *
++	 * \param default_permissions the default permissions
++	 * \param index the index of the first permission entry
++	 * \param n_permissions the number of permissions
++	 * \param permissions the permissions
++	 */
++	void (*permissions) (void *object,
++			     uint32_t index,
++			     uint32_t n_permissions,
++			     const struct pw_permission *permissions);
++};
++
++
++#define PW_CLIENT_METHOD_ADD_LISTENER		0
++#define PW_CLIENT_METHOD_ERROR			1
++#define PW_CLIENT_METHOD_UPDATE_PROPERTIES	2
++#define PW_CLIENT_METHOD_GET_PERMISSIONS	3
++#define PW_CLIENT_METHOD_UPDATE_PERMISSIONS	4
++#define PW_CLIENT_METHOD_NUM			5
++
++/** Client methods */
++struct pw_client_methods {
++#define PW_VERSION_CLIENT_METHODS	0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_client_events *events,
++			void *data);
++	/**
++	 * Send an error to a client
++	 *
++	 * \param id the global id to report the error on
++	 * \param res an errno style error code
++	 * \param message an error string
++	 */
++	int (*error) (void *object, uint32_t id, int res, const char *message);
++	/**
++	 * Update client properties
++	 *
++	 * \param props new properties
++	 */
++	int (*update_properties) (void *object, const struct spa_dict *props);
++
++	/**
++	 * Get client permissions
++	 *
++	 * A permissions event will be emitted with the permissions.
++	 *
++	 * \param index the first index to query, 0 for first
++	 * \param num the maximum number of items to get
++	 */
++	int (*get_permissions) (void *object, uint32_t index, uint32_t num);
++	/**
++	 * Manage the permissions of the global objects for this
++	 * client
++	 *
++	 * Update the permissions of the global objects using the
++	 * provided array with permissions
++	 *
++	 * Globals can use the default permissions or can have specific
++	 * permissions assigned to them.
++	 *
++	 * \param n_permissions number of permissions
++	 * \param permissions array of permissions
++	 */
++	int (*update_permissions) (void *object, uint32_t n_permissions,
++			const struct pw_permission *permissions);
++};
++
++#define pw_client_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_client_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_client_add_listener(c,...)		pw_client_method(c,add_listener,0,__VA_ARGS__)
++#define pw_client_error(c,...)			pw_client_method(c,error,0,__VA_ARGS__)
++#define pw_client_update_properties(c,...)	pw_client_method(c,update_properties,0,__VA_ARGS__)
++#define pw_client_get_permissions(c,...)	pw_client_method(c,get_permissions,0,__VA_ARGS__)
++#define pw_client_update_permissions(c,...)	pw_client_method(c,update_permissions,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_CLIENT_H */
+diff --git a/third_party/pipewire/pipewire/context.h b/third_party/pipewire/pipewire/context.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/context.h
+@@ -0,0 +1,188 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_CONTEXT_H
++#define PIPEWIRE_CONTEXT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++/** \class pw_context
++ *
++ * \brief the PipeWire context
++ *
++ * The context object manages all locally available resources. It
++ * is used by both clients and servers.
++ *
++ * The context is used to:
++ *
++ *  - Load modules and extend the functionality. This includes
++ *    extending the protocol with new object types or creating
++ *    any of the available objects.
++ *
++ *  - Create implementations of various objects like nodes,
++ *    devices, factories, modules, etc.. This will usually also
++ *    create pw_global objects that can then be shared with
++ *    clients.
++ *
++ *  - Connect to another PipeWire instance (the main daemon, for
++ *    example) and interact with it (See \subpage page_core_api).
++ *
++ *  - Export a local implementation of an object to another
++ *    instance.
++ */
++struct pw_context;
++
++struct pw_global;
++struct pw_impl_client;
++
++#include <pipewire/core.h>
++#include <pipewire/loop.h>
++#include <pipewire/properties.h>
++
++/** \page page_context_api Core API
++ *
++ * \section page_context_overview Overview
++ *
++ * \subpage page_context
++ *
++ * \subpage page_global
++ *
++ * \subpage page_client
++ *
++ * \subpage page_resource
++ *
++ * \subpage page_node
++ *
++ * \subpage page_port
++ *
++ * \subpage page_link
++ */
++
++/** \page page_context Context
++ *
++ * \section page_context_overview Overview
++ *
++ * The context object is an object that manages the state and
++ * resources of a PipeWire instance.
++ */
++
++/** context events emitted by the context object added with \ref pw_context_add_listener */
++struct pw_context_events {
++#define PW_VERSION_CONTEXT_EVENTS	0
++	uint32_t version;
++
++	/** The context is being destroyed */
++	void (*destroy) (void *data);
++	/** The context is being freed */
++	void (*free) (void *data);
++	/** a new client object is added */
++	void (*check_access) (void *data, struct pw_impl_client *client);
++	/** a new global object was added */
++	void (*global_added) (void *data, struct pw_global *global);
++	/** a global object was removed */
++	void (*global_removed) (void *data, struct pw_global *global);
++};
++
++/** Make a new context object for a given main_loop. Ownership of the properties is taken */
++struct pw_context * pw_context_new(struct pw_loop *main_loop,		/**< a main loop to run in */
++			     struct pw_properties *props,	/**< extra properties */
++			     size_t user_data_size		/**< extra user data size */);
++
++/** destroy a context object, all resources except the main_loop will be destroyed */
++void pw_context_destroy(struct pw_context *context);
++
++/** Get the context user data */
++void *pw_context_get_user_data(struct pw_context *context);
++
++/** Add a new event listener to a context */
++void pw_context_add_listener(struct pw_context *context,
++			  struct spa_hook *listener,
++			  const struct pw_context_events *events,
++			  void *data);
++
++/** Get the context properties */
++const struct pw_properties *pw_context_get_properties(struct pw_context *context);
++
++/** Update the context properties */
++int pw_context_update_properties(struct pw_context *context, const struct spa_dict *dict);
++
++/** Get the context support objects */
++const struct spa_support *pw_context_get_support(struct pw_context *context, uint32_t *n_support);
++
++/** get the context main loop */
++struct pw_loop *pw_context_get_main_loop(struct pw_context *context);
++
++/** Iterate the globals of the context. The callback should return
++ * 0 to fetch the next item, any other value stops the iteration and returns
++ * the value. When all callbacks return 0, this function returns 0 when all
++ * globals are iterated. */
++int pw_context_for_each_global(struct pw_context *context,	/**< the context */
++			    int (*callback) (void *data, struct pw_global *global),
++			    void *data);
++
++/** Find a context global by id */
++struct pw_global *pw_context_find_global(struct pw_context *context,	/**< the context */
++				      uint32_t id		/**< the global id */);
++
++/** add a spa library for the given factory_name regex */
++int pw_context_add_spa_lib(struct pw_context *context, const char *factory_regex, const char *lib);
++
++/** find the library name for a spa factory */
++const char * pw_context_find_spa_lib(struct pw_context *context, const char *factory_name);
++
++struct spa_handle *pw_context_load_spa_handle(struct pw_context *context,
++		const char *factory_name,
++		const struct spa_dict *info);
++
++
++/** data for registering export functions */
++struct pw_export_type {
++	struct spa_list link;
++	const char *type;
++	struct pw_proxy * (*func) (struct pw_core *core,
++		const char *type, const struct spa_dict *props, void *object,
++		size_t user_data_size);
++};
++
++/** register a type that can be exported on a context_proxy. This is usually used by
++ * extension modules */
++int pw_context_register_export_type(struct pw_context *context, struct pw_export_type *type);
++/** find information about registered export type */
++const struct pw_export_type *pw_context_find_export_type(struct pw_context *context, const char *type);
++
++/** add an object to the context */
++int pw_context_set_object(struct pw_context *context, const char *type, void *value);
++/** get an object from the context */
++void *pw_context_get_object(struct pw_context *context, const char *type);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_CONTEXT_H */
+diff --git a/third_party/pipewire/pipewire/control.h b/third_party/pipewire/pipewire/control.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/control.h
+@@ -0,0 +1,79 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_CONTROL_H
++#define PIPEWIRE_CONTROL_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++/** \page page_control Control
++ *
++ * \section page_control_overview Overview
++ *
++ * A control can be used to control a port property.
++ */
++/** \class pw_control
++ *
++ * The control object
++ */
++struct pw_control;
++
++#include <pipewire/impl.h>
++
++/** Port events, use \ref pw_control_add_listener */
++struct pw_control_events {
++#define PW_VERSION_CONTROL_EVENTS 0
++	uint32_t version;
++
++	/** The control is destroyed */
++	void (*destroy) (void *data);
++
++	/** The control is freed */
++	void (*free) (void *data);
++
++	/** control is linked to another control */
++	void (*linked) (void *data, struct pw_control *other);
++	/** control is unlinked from another control */
++	void (*unlinked) (void *data, struct pw_control *other);
++
++};
++
++/** Get the control parent port or NULL when not set */
++struct pw_impl_port *pw_control_get_port(struct pw_control *control);
++
++/** Add an event listener on the control */
++void pw_control_add_listener(struct pw_control *control,
++			     struct spa_hook *listener,
++			     const struct pw_control_events *events,
++			     void *data);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_CONTROL_H */
+diff --git a/third_party/pipewire/pipewire/core.h b/third_party/pipewire/pipewire/core.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/core.h
+@@ -0,0 +1,584 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_CORE_H
++#define PIPEWIRE_CORE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++#include <errno.h>
++
++#include <spa/utils/hook.h>
++
++#define PW_TYPE_INTERFACE_Core		PW_TYPE_INFO_INTERFACE_BASE "Core"
++#define PW_TYPE_INTERFACE_Registry	PW_TYPE_INFO_INTERFACE_BASE "Registry"
++
++#define PW_VERSION_CORE		3
++struct pw_core;
++#define PW_VERSION_REGISTRY	3
++struct pw_registry;
++
++/* the default remote name to connect to */
++#define PW_DEFAULT_REMOTE	"pipewire-0"
++
++/* default ID for the core object after connect */
++#define PW_ID_CORE		0
++
++/* invalid ID that matches any object when used for permissions */
++#define PW_ID_ANY		(uint32_t)(0xffffffff)
++
++/**  The core information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_core_info {
++	uint32_t id;			/**< id of the global */
++	uint32_t cookie;		/**< a random cookie for identifying this instance of PipeWire */
++	const char *user_name;		/**< name of the user that started the core */
++	const char *host_name;		/**< name of the machine the core is running on */
++	const char *version;		/**< version of the core */
++	const char *name;		/**< name of the core */
++#define PW_CORE_CHANGE_MASK_PROPS      (1 << 0)
++#define PW_CORE_CHANGE_MASK_ALL        ((1 << 1)-1)
++	uint64_t change_mask;		/**< bitfield of changed fields since last call */
++	struct spa_dict *props;		/**< extra properties */
++};
++
++#include <pipewire/context.h>
++#include <pipewire/properties.h>
++#include <pipewire/proxy.h>
++
++/** Update and existing \ref pw_core_info with \a update  \memberof pw_introspect */
++struct pw_core_info *
++pw_core_info_update(struct pw_core_info *info,
++		    const struct pw_core_info *update);
++
++/** Free a \ref pw_core_info  \memberof pw_introspect */
++void pw_core_info_free(struct pw_core_info *info);
++
++/**
++ * \page page_iface_pw_core pw_core
++ * \section page_iface_pw_core_desc Description
++ *
++ * The core global object.  This is a special singleton object.  It
++ * is used for internal PipeWire protocol features.
++ * \section page_iface_pw_core API
++ */
++
++/** Core */
++
++#define PW_CORE_EVENT_INFO	0
++#define PW_CORE_EVENT_DONE	1
++#define PW_CORE_EVENT_PING	2
++#define PW_CORE_EVENT_ERROR	3
++#define PW_CORE_EVENT_REMOVE_ID	4
++#define PW_CORE_EVENT_BOUND_ID	5
++#define PW_CORE_EVENT_ADD_MEM	6
++#define PW_CORE_EVENT_REMOVE_MEM	7
++#define PW_CORE_EVENT_NUM		8
++
++/** \struct pw_core_events
++ *  \brief Core events
++ *  \ingroup pw_core_interface The pw_core interface
++ */
++struct pw_core_events {
++#define PW_VERSION_CORE_EVENTS	0
++	uint32_t version;
++
++	/**
++	 * Notify new core info
++	 *
++	 * This event is emitted when first bound to the core or when the
++	 * hello method is called.
++	 *
++	 * \param info new core info
++	 */
++	void (*info) (void *object, const struct pw_core_info *info);
++	/**
++	 * Emit a done event
++	 *
++	 * The done event is emitted as a result of a sync method with the
++	 * same seq number.
++	 *
++	 * \param seq the seq number passed to the sync method call
++	 */
++	void (*done) (void *object, uint32_t id, int seq);
++
++	/** Emit a ping event
++	 *
++	 * The client should reply with a pong reply with the same seq
++	 * number.
++	 */
++	void (*ping) (void *object, uint32_t id, int seq);
++
++	/**
++	 * Fatal error event
++         *
++         * The error event is sent out when a fatal (non-recoverable)
++         * error has occurred. The id argument is the proxy object where
++         * the error occurred, most often in response to a request to that
++         * object. The message is a brief description of the error,
++         * for (debugging) convenience.
++	 *
++	 * This event is usually also emitted on the proxy object with
++	 * \a id.
++	 *
++         * \param id object where the error occurred
++         * \param seq the sequence number that generated the error
++         * \param res error code
++         * \param message error description
++	 */
++	void (*error) (void *object, uint32_t id, int seq, int res, const char *message);
++	/**
++	 * Remove an object ID
++         *
++         * This event is used internally by the object ID management
++         * logic. When a client deletes an object, the server will send
++         * this event to acknowledge that it has seen the delete request.
++         * When the client receives this event, it will know that it can
++         * safely reuse the object ID.
++	 *
++         * \param id deleted object ID
++	 */
++	void (*remove_id) (void *object, uint32_t id);
++
++	/**
++	 * Notify an object binding
++	 *
++	 * This event is emitted when a local object ID is bound to a
++	 * global ID. It is emitted before the global becomes visible in the
++	 * registry.
++	 *
++	 * \param id bound object ID
++	 * \param global_id the global id bound to
++	 */
++	void (*bound_id) (void *object, uint32_t id, uint32_t global_id);
++
++	/**
++	 * Add memory for a client
++	 *
++	 * Memory is given to a client as \a fd of a certain
++	 * memory \a type.
++	 *
++	 * Further references to this fd will be made with the per memory
++	 * unique identifier \a id.
++	 *
++	 * \param id the unique id of the memory
++	 * \param type the memory type, one of enum spa_data_type
++	 * \param fd the file descriptor
++	 * \param flags extra flags
++	 */
++	void (*add_mem) (void *object, uint32_t id, uint32_t type, int fd, uint32_t flags);
++
++	/**
++	 * Remove memory for a client
++	 *
++	 * \param id the memory id to remove
++	 */
++	void (*remove_mem) (void *object, uint32_t id);
++};
++
++#define PW_CORE_METHOD_ADD_LISTENER	0
++#define PW_CORE_METHOD_HELLO		1
++#define PW_CORE_METHOD_SYNC		2
++#define PW_CORE_METHOD_PONG		3
++#define PW_CORE_METHOD_ERROR		4
++#define PW_CORE_METHOD_GET_REGISTRY	5
++#define PW_CORE_METHOD_CREATE_OBJECT	6
++#define PW_CORE_METHOD_DESTROY		7
++#define PW_CORE_METHOD_NUM		8
++
++/**
++ * \struct pw_core_methods
++ * \brief Core methods
++ *
++ * The core global object. This is a singleton object used for
++ * creating new objects in the remote PipeWire instance. It is
++ * also used for internal features.
++ */
++struct pw_core_methods {
++#define PW_VERSION_CORE_METHODS	0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_core_events *events,
++			void *data);
++	/**
++	 * Start a conversation with the server. This will send
++	 * the core info and will destroy all resources for the client
++	 * (except the core and client resource).
++	 */
++	int (*hello) (void *object, uint32_t version);
++	/**
++	 * Do server roundtrip
++	 *
++	 * Ask the server to emit the 'done' event with \a seq.
++	 *
++	 * Since methods are handled in-order and events are delivered
++	 * in-order, this can be used as a barrier to ensure all previous
++	 * methods and the resulting events have been handled.
++	 *
++	 * \param seq the seq number passed to the done event
++	 */
++	int (*sync) (void *object, uint32_t id, int seq);
++	/**
++	 * Reply to a server ping event.
++	 *
++	 * Reply to the server ping event with the same seq.
++	 *
++	 * \param seq the seq number received in the ping event
++	 */
++	int (*pong) (void *object, uint32_t id, int seq);
++	/**
++	 * Fatal error event
++         *
++         * The error method is sent out when a fatal (non-recoverable)
++         * error has occurred. The id argument is the proxy object where
++         * the error occurred, most often in response to an event on that
++         * object. The message is a brief description of the error,
++         * for (debugging) convenience.
++	 *
++	 * This method is usually also emitted on the resource object with
++	 * \a id.
++	 *
++         * \param id object where the error occurred
++         * \param res error code
++         * \param message error description
++	 */
++	int (*error) (void *object, uint32_t id, int seq, int res, const char *message);
++	/**
++	 * Get the registry object
++	 *
++	 * Create a registry object that allows the client to list and bind
++	 * the global objects available from the PipeWire server
++	 * \param version the client version
++	 * \param user_data_size extra size
++	 */
++	struct pw_registry * (*get_registry) (void *object, uint32_t version,
++			size_t user_data_size);
++
++	/**
++	 * Create a new object on the PipeWire server from a factory.
++	 *
++	 * \param factory_name the factory name to use
++	 * \param type the interface to bind to
++	 * \param version the version of the interface
++	 * \param props extra properties
++	 * \param user_data_size extra size
++	 */
++	void * (*create_object) (void *object,
++			       const char *factory_name,
++			       const char *type,
++			       uint32_t version,
++			       const struct spa_dict *props,
++			       size_t user_data_size);
++	/**
++	 * Destroy an resource
++	 *
++	 * Destroy the server resource for the given proxy.
++	 *
++	 * \param obj the proxy to destroy
++	 */
++	int (*destroy) (void *object, void *proxy);
++};
++
++#define pw_core_method(o,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_core_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_core_add_listener(c,...)	pw_core_method(c,add_listener,0,__VA_ARGS__)
++#define pw_core_hello(c,...)		pw_core_method(c,hello,0,__VA_ARGS__)
++#define pw_core_sync(c,...)		pw_core_method(c,sync,0,__VA_ARGS__)
++#define pw_core_pong(c,...)		pw_core_method(c,pong,0,__VA_ARGS__)
++#define pw_core_error(c,...)		pw_core_method(c,error,0,__VA_ARGS__)
++
++
++static inline
++SPA_PRINTF_FUNC(5, 0) int
++pw_core_errorv(struct pw_core *core, uint32_t id, int seq,
++		int res, const char *message, va_list args)
++{
++	char buffer[1024];
++	vsnprintf(buffer, sizeof(buffer), message, args);
++	buffer[1023] = '\0';
++	return pw_core_error(core, id, seq, res, buffer);
++}
++
++static inline
++SPA_PRINTF_FUNC(5, 6) int
++pw_core_errorf(struct pw_core *core, uint32_t id, int seq,
++		int res, const char *message, ...)
++{
++        va_list args;
++	int r;
++	va_start(args, message);
++	r = pw_core_errorv(core, id, seq, res, message, args);
++	va_end(args);
++	return r;
++}
++
++static inline struct pw_registry *
++pw_core_get_registry(struct pw_core *core, uint32_t version, size_t user_data_size)
++{
++	struct pw_registry *res = NULL;
++	spa_interface_call_res((struct spa_interface*)core,
++			struct pw_core_methods, res,
++			get_registry, 0, version, user_data_size);
++	return res;
++}
++
++static inline void *
++pw_core_create_object(struct pw_core *core,
++			    const char *factory_name,
++			    const char *type,
++			    uint32_t version,
++			    const struct spa_dict *props,
++			    size_t user_data_size)
++{
++	void *res = NULL;
++	spa_interface_call_res((struct spa_interface*)core,
++			struct pw_core_methods, res,
++			create_object, 0, factory_name,
++			type, version, props, user_data_size);
++	return res;
++}
++
++#define pw_core_destroy(c,...)		pw_core_method(c,destroy,0,__VA_ARGS__)
++
++/** \page page_registry Registry
++ *
++ * \section page_registry_overview Overview
++ *
++ * The registry object is a singleton object that keeps track of
++ * global objects on the PipeWire instance. See also \ref page_global.
++ *
++ * Global objects typically represent an actual object in PipeWire
++ * (for example, a module or node) or they are singleton
++ * objects such as the core.
++ *
++ * When a client creates a registry object, the registry object
++ * will emit a global event for each global currently in the
++ * registry.  Globals come and go as a result of device hotplugs or
++ * reconfiguration or other events, and the registry will send out
++ * global and global_remove events to keep the client up to date
++ * with the changes.  To mark the end of the initial burst of
++ * events, the client can use the pw_core.sync methosd immediately
++ * after calling pw_core.get_registry.
++ *
++ * A client can bind to a global object by using the bind
++ * request.  This creates a client-side proxy that lets the object
++ * emit events to the client and lets the client invoke methods on
++ * the object. See \ref page_proxy
++ *
++ * Clients can also change the permissions of the global objects that
++ * it can see. This is interesting when you want to configure a
++ * pipewire session before handing it to another application. You
++ * can, for example, hide certain existing or new objects or limit
++ * the access permissions on an object.
++ */
++
++#define PW_REGISTRY_EVENT_GLOBAL             0
++#define PW_REGISTRY_EVENT_GLOBAL_REMOVE      1
++#define PW_REGISTRY_EVENT_NUM                2
++
++/** Registry events */
++struct pw_registry_events {
++#define PW_VERSION_REGISTRY_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify of a new global object
++	 *
++	 * The registry emits this event when a new global object is
++	 * available.
++	 *
++	 * \param id the global object id
++	 * \param permissions the permissions of the object
++	 * \param type the type of the interface
++	 * \param version the version of the interface
++	 * \param props extra properties of the global
++	 */
++	void (*global) (void *object, uint32_t id,
++		       uint32_t permissions, const char *type, uint32_t version,
++		       const struct spa_dict *props);
++	/**
++	 * Notify of a global object removal
++	 *
++	 * Emitted when a global object was removed from the registry.
++	 * If the client has any bindings to the global, it should destroy
++	 * those.
++	 *
++	 * \param id the id of the global that was removed
++	 */
++	void (*global_remove) (void *object, uint32_t id);
++};
++
++#define PW_REGISTRY_METHOD_ADD_LISTENER	0
++#define PW_REGISTRY_METHOD_BIND		1
++#define PW_REGISTRY_METHOD_DESTROY	2
++#define PW_REGISTRY_METHOD_NUM		3
++
++/** Registry methods */
++struct pw_registry_methods {
++#define PW_VERSION_REGISTRY_METHODS	0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_registry_events *events,
++			void *data);
++	/**
++	 * Bind to a global object
++	 *
++	 * Bind to the global object with \a id and use the client proxy
++	 * with new_id as the proxy. After this call, methods can be
++	 * send to the remote global object and events can be received
++	 *
++	 * \param id the global id to bind to
++	 * \param type the interface type to bind to
++	 * \param version the interface version to use
++	 * \returns the new object
++	 */
++	void * (*bind) (void *object, uint32_t id, const char *type, uint32_t version,
++			size_t use_data_size);
++
++	/**
++	 * Attempt to destroy a global object
++	 *
++	 * Try to destroy the global object.
++	 *
++	 * \param id the global id to destroy
++	 */
++	int (*destroy) (void *object, uint32_t id);
++};
++
++#define pw_registry_method(o,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_registry_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++/** Registry */
++#define pw_registry_add_listener(p,...)	pw_registry_method(p,add_listener,0,__VA_ARGS__)
++
++static inline void *
++pw_registry_bind(struct pw_registry *registry,
++		       uint32_t id, const char *type, uint32_t version,
++		       size_t user_data_size)
++{
++	void *res = NULL;
++	spa_interface_call_res((struct spa_interface*)registry,
++			struct pw_registry_methods, res,
++			bind, 0, id, type, version, user_data_size);
++	return res;
++}
++
++#define pw_registry_destroy(p,...)	pw_registry_method(p,destroy,0,__VA_ARGS__)
++
++
++/** Connect to a PipeWire instance \memberof pw_core
++ * \return a pw_core on success or NULL with errno set on error. The core
++ * will have an id of PW_ID_CORE (0) */
++struct pw_core *
++pw_context_connect(struct pw_context *context,		/**< a \ref pw_context */
++	      struct pw_properties *properties,	/**< optional properties, ownership of
++						  *  the properties is taken.*/
++	      size_t user_data_size		/**< extra user data size */);
++
++/** Connect to a PipeWire instance on the given socket \memberof pw_core
++ * \param fd the connected socket to use, the socket will be closed
++ *	automatically on disconnect or error.
++ * \return a pw_core on success or NULL with errno set on error */
++struct pw_core *
++pw_context_connect_fd(struct pw_context *context,	/**< a \ref pw_context */
++	      int fd,				/**< an fd */
++	      struct pw_properties *properties,	/**< optional properties, ownership of
++						  *  the properties is taken.*/
++	      size_t user_data_size		/**< extra user data size */);
++
++/** Connect to a given PipeWire instance \memberof pw_core
++ * \return a pw_core on success or NULL with errno set on error */
++struct pw_core *
++pw_context_connect_self(struct pw_context *context,	/**< a \ref pw_context to connect to */
++	      struct pw_properties *properties,	/**< optional properties, ownership of
++						  *  the properties is taken.*/
++	      size_t user_data_size		/**< extra user data size */);
++
++/** Steal the fd of the core connection or < 0 on error. The core
++  * will be disconnected after this call. */
++int pw_core_steal_fd(struct pw_core *core);
++
++/** Pause or resume the core. When the core is paused, no new events
++ *  will be dispatched until the core is resumed again. */
++int pw_core_set_paused(struct pw_core *core, bool paused);
++
++/** disconnect and destroy a core */
++int pw_core_disconnect(struct pw_core *core);
++
++/** Get the user_data. It is of the size specified when this object was
++ * constructed */
++void *pw_core_get_user_data(struct pw_core *core);
++
++/** Get the client proxy of the connected core. This will have the id
++ * of PW_ID_CLIENT (1) */
++struct pw_client * pw_core_get_client(struct pw_core *core);
++
++/** Get the context object used to created this core */
++struct pw_context * pw_core_get_context(struct pw_core *core);
++
++/** Get properties from the core */
++const struct pw_properties *pw_core_get_properties(struct pw_core *core);
++
++/** Update the core properties. This updates the properties
++ * of the associated client.
++ * \return the number of properties that were updated */
++int pw_core_update_properties(struct pw_core *core, const struct spa_dict *dict);
++
++/** Get the core mempool object */
++struct pw_mempool * pw_core_get_mempool(struct pw_core *core);
++
++/** Get the proxy with the given id */
++struct pw_proxy *pw_core_find_proxy(struct pw_core *core, uint32_t id);
++
++/** Export an object into the PipeWire instance associated with core */
++struct pw_proxy *pw_core_export(struct pw_core *core,			/**< the core */
++				  const char *type,			/**< the type of object */
++				  const struct spa_dict *props,		/**< extra properties */
++				  void *object,				/**< object to export */
++				  size_t user_data_size			/**< extra user data */);
++
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_CORE_H */
+diff --git a/third_party/pipewire/pipewire/data-loop.h b/third_party/pipewire/pipewire/data-loop.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/data-loop.h
+@@ -0,0 +1,95 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_DATA_LOOP_H
++#define PIPEWIRE_DATA_LOOP_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++/** \class pw_data_loop
++ *
++ * PipeWire rt-loop object. This loop starts a new real-time thread that
++ * is designed to run the processing graph.
++ */
++struct pw_data_loop;
++
++#include <pipewire/loop.h>
++#include <pipewire/properties.h>
++
++/** Loop events, use \ref pw_data_loop_add_listener to add a listener */
++struct pw_data_loop_events {
++#define PW_VERSION_DATA_LOOP_EVENTS		0
++	uint32_t version;
++	/** The loop is destroyed */
++	void (*destroy) (void *data);
++};
++
++/** Make a new loop. */
++struct pw_data_loop *
++pw_data_loop_new(const struct spa_dict *props);
++
++/** Add an event listener to loop */
++void pw_data_loop_add_listener(struct pw_data_loop *loop,
++			       struct spa_hook *listener,
++			       const struct pw_data_loop_events *events,
++			       void *data);
++
++/** wait for activity on the loop up to \a timeout milliseconds.
++ * Should be called from the loop function */
++int pw_data_loop_wait(struct pw_data_loop *loop, int timeout);
++
++/** make sure the thread will exit. Can be called from a loop callback */
++void pw_data_loop_exit(struct pw_data_loop *loop);
++
++/** Get the loop implementation of this data loop */
++struct pw_loop *
++pw_data_loop_get_loop(struct pw_data_loop *loop);
++
++/** Destroy the loop */
++void pw_data_loop_destroy(struct pw_data_loop *loop);
++
++/** Start the processing thread */
++int pw_data_loop_start(struct pw_data_loop *loop);
++
++/** Stop the processing thread */
++int pw_data_loop_stop(struct pw_data_loop *loop);
++
++/** Check if the current thread is the processing thread */
++bool pw_data_loop_in_thread(struct pw_data_loop *loop);
++
++/** invoke func in the context of the thread or in the caller thread when
++ * the loop is not running. Since 0.3.3 */
++int pw_data_loop_invoke(struct pw_data_loop *loop,
++		spa_invoke_func_t func, uint32_t seq, const void *data, size_t size,
++		bool block, void *user_data);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_DATA_LOOP_H */
+diff --git a/third_party/pipewire/pipewire/device.h b/third_party/pipewire/pipewire/device.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/device.h
+@@ -0,0 +1,162 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_DEVICE_H
++#define PIPEWIRE_DEVICE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++#include <pipewire/proxy.h>
++
++#define PW_TYPE_INTERFACE_Device	PW_TYPE_INFO_INTERFACE_BASE "Device"
++
++#define PW_VERSION_DEVICE		3
++struct pw_device;
++
++/** The device information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_device_info {
++	uint32_t id;			/**< id of the global */
++#define PW_DEVICE_CHANGE_MASK_PROPS	(1 << 0)
++#define PW_DEVICE_CHANGE_MASK_PARAMS	(1 << 1)
++#define PW_DEVICE_CHANGE_MASK_ALL	((1 << 2)-1)
++	uint64_t change_mask;		/**< bitfield of changed fields since last call */
++	struct spa_dict *props;		/**< extra properties */
++	struct spa_param_info *params;	/**< parameters */
++	uint32_t n_params;		/**< number of items in \a params */
++};
++
++/** Update and existing \ref pw_device_info with \a update \memberof pw_introspect */
++struct pw_device_info *
++pw_device_info_update(struct pw_device_info *info,
++		      const struct pw_device_info *update);
++
++/** Free a \ref pw_device_info \memberof pw_introspect */
++void pw_device_info_free(struct pw_device_info *info);
++
++#define PW_DEVICE_EVENT_INFO	0
++#define PW_DEVICE_EVENT_PARAM	1
++#define PW_DEVICE_EVENT_NUM	2
++
++/** Device events */
++struct pw_device_events {
++#define PW_VERSION_DEVICE_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify device info
++	 *
++	 * \param info info about the device
++	 */
++	void (*info) (void *object, const struct pw_device_info *info);
++	/**
++	 * Notify a device param
++	 *
++	 * Event emitted as a result of the enum_params method.
++	 *
++	 * \param seq the sequence number of the request
++	 * \param id the param id
++	 * \param index the param index
++	 * \param next the param index of the next param
++	 * \param param the parameter
++	 */
++	void (*param) (void *object, int seq,
++		      uint32_t id, uint32_t index, uint32_t next,
++		      const struct spa_pod *param);
++};
++
++
++#define PW_DEVICE_METHOD_ADD_LISTENER		0
++#define PW_DEVICE_METHOD_SUBSCRIBE_PARAMS	1
++#define PW_DEVICE_METHOD_ENUM_PARAMS		2
++#define PW_DEVICE_METHOD_SET_PARAM		3
++#define PW_DEVICE_METHOD_NUM			4
++
++/** Device methods */
++struct pw_device_methods {
++#define PW_VERSION_DEVICE_METHODS	0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_device_events *events,
++			void *data);
++	/**
++	 * Subscribe to parameter changes
++	 *
++	 * Automatically emit param events for the given ids when
++	 * they are changed.
++	 *
++	 * \param ids an array of param ids
++	 * \param n_ids the number of ids in \a ids
++	 */
++	int (*subscribe_params) (void *object, uint32_t *ids, uint32_t n_ids);
++
++	/**
++	 * Enumerate device parameters
++	 *
++	 * Start enumeration of device parameters. For each param, a
++	 * param event will be emitted.
++	 *
++	 * \param seq a sequence number to place in the reply
++	 * \param id the parameter id to enum or PW_ID_ANY for all
++	 * \param start the start index or 0 for the first param
++	 * \param num the maximum number of params to retrieve
++	 * \param filter a param filter or NULL
++	 */
++	int (*enum_params) (void *object, int seq, uint32_t id, uint32_t start, uint32_t num,
++			    const struct spa_pod *filter);
++	/**
++	 * Set a parameter on the device
++	 *
++	 * \param id the parameter id to set
++	 * \param flags extra parameter flags
++	 * \param param the parameter to set
++	 */
++	int (*set_param) (void *object, uint32_t id, uint32_t flags,
++			  const struct spa_pod *param);
++};
++
++#define pw_device_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_device_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_device_add_listener(c,...)		pw_device_method(c,add_listener,0,__VA_ARGS__)
++#define pw_device_subscribe_params(c,...)	pw_device_method(c,subscribe_params,0,__VA_ARGS__)
++#define pw_device_enum_params(c,...)		pw_device_method(c,enum_params,0,__VA_ARGS__)
++#define pw_device_set_param(c,...)		pw_device_method(c,set_param,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_DEVICE_H */
+diff --git a/third_party/pipewire/pipewire/factory.h b/third_party/pipewire/pipewire/factory.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/factory.h
+@@ -0,0 +1,109 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_FACTORY_H
++#define PIPEWIRE_FACTORY_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++#include <errno.h>
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++#include <pipewire/proxy.h>
++
++#define PW_TYPE_INTERFACE_Factory	PW_TYPE_INFO_INTERFACE_BASE "Factory"
++
++#define PW_VERSION_FACTORY		3
++struct pw_factory;
++
++/** The factory information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_factory_info {
++	uint32_t id;			/**< id of the global */
++	const char *name;		/**< name the factory */
++	const char *type;		/**< type of the objects created by this factory */
++	uint32_t version;		/**< version of the objects */
++#define PW_FACTORY_CHANGE_MASK_PROPS	(1 << 0)
++#define PW_FACTORY_CHANGE_MASK_ALL	((1 << 1)-1)
++	uint64_t change_mask;		/**< bitfield of changed fields since last call */
++	struct spa_dict *props;		/**< the properties of the factory */
++};
++
++struct pw_factory_info *
++pw_factory_info_update(struct pw_factory_info *info,
++		       const struct pw_factory_info *update);
++
++void
++pw_factory_info_free(struct pw_factory_info *info);
++
++
++#define PW_FACTORY_EVENT_INFO		0
++#define PW_FACTORY_EVENT_NUM		1
++
++/** Factory events */
++struct pw_factory_events {
++#define PW_VERSION_FACTORY_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify factory info
++	 *
++	 * \param info info about the factory
++	 */
++	void (*info) (void *object, const struct pw_factory_info *info);
++};
++
++#define PW_FACTORY_METHOD_ADD_LISTENER	0
++#define PW_FACTORY_METHOD_NUM		1
++
++/** Factory methods */
++struct pw_factory_methods {
++#define PW_VERSION_FACTORY_METHODS	0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_factory_events *events,
++			void *data);
++};
++
++#define pw_factory_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_factory_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_factory_add_listener(c,...)	pw_factory_method(c,add_listener,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_FACTORY_H */
+diff --git a/third_party/pipewire/pipewire/filter.h b/third_party/pipewire/pipewire/filter.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/filter.h
+@@ -0,0 +1,240 @@
++/* PipeWire
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_FILTER_H
++#define PIPEWIRE_FILTER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_filter
++ *
++ * \brief PipeWire filter object class
++ *
++ * The filter object provides a convenient way to implement
++ * processing filters.
++ *
++ * See also \ref page_filters and \ref page_core_api
++ */
++struct pw_filter;
++
++#include <spa/buffer/buffer.h>
++#include <spa/node/io.h>
++#include <spa/param/param.h>
++
++#include <pipewire/core.h>
++#include <pipewire/stream.h>
++
++/** \enum pw_filter_state The state of a filter \memberof pw_filter */
++enum pw_filter_state {
++	PW_FILTER_STATE_ERROR = -1,		/**< the strean is in error */
++	PW_FILTER_STATE_UNCONNECTED = 0,	/**< unconnected */
++	PW_FILTER_STATE_CONNECTING = 1,		/**< connection is in progress */
++	PW_FILTER_STATE_PAUSED = 2,		/**< filter is connected and paused */
++	PW_FILTER_STATE_STREAMING = 3		/**< filter is streaming */
++};
++
++#if 0
++struct pw_buffer {
++	struct spa_buffer *buffer;	/**< the spa buffer */
++	void *user_data;		/**< user data attached to the buffer */
++	uint64_t size;			/**< For input ports, this field is set by pw_filter
++					  *  with the duration of the buffer in ticks.
++					  *  For output ports, this field is set by the user.
++					  *  This field is added for all queued buffers and
++					  *  returned in the time info. */
++};
++#endif
++
++/** Events for a filter. These events are always called from the mainloop
++ * unless explicitly documented otherwise. */
++struct pw_filter_events {
++#define PW_VERSION_FILTER_EVENTS	0
++	uint32_t version;
++
++	void (*destroy) (void *data);
++	/** when the filter state changes */
++	void (*state_changed) (void *data, enum pw_filter_state old,
++				enum pw_filter_state state, const char *error);
++
++	/** when io changed on a port of the filter (when port_data is NULL). */
++	void (*io_changed) (void *data, void *port_data,
++			uint32_t id, void *area, uint32_t size);
++	/** when a parameter changed on a port of the filter (when port_data is NULL). */
++	void (*param_changed) (void *data, void *port_data,
++			uint32_t id, const struct spa_pod *param);
++
++        /** when a new buffer was created for a port */
++        void (*add_buffer) (void *data, void *port_data, struct pw_buffer *buffer);
++        /** when a buffer was destroyed for a port */
++        void (*remove_buffer) (void *data, void *port_data, struct pw_buffer *buffer);
++
++        /** do processing. This is normally called from the
++	 *  mainloop but can also be called directly from the realtime data
++	 *  thread if the user is prepared to deal with this. */
++        void (*process) (void *data, struct spa_io_position *position);
++
++	/** The filter is drained */
++        void (*drained) (void *data);
++};
++
++/** Convert a filter state to a readable string \memberof pw_filter */
++const char * pw_filter_state_as_string(enum pw_filter_state state);
++
++/** \enum pw_filter_flags Extra flags that can be used in \ref pw_filter_connect() \memberof pw_filter */
++enum pw_filter_flags {
++	PW_FILTER_FLAG_NONE = 0,			/**< no flags */
++	PW_FILTER_FLAG_INACTIVE		= (1 << 0),	/**< start the filter inactive,
++							  *  pw_filter_set_active() needs to be
++							  *  called explicitly */
++	PW_FILTER_FLAG_DRIVER		= (1 << 1),	/**< be a driver */
++	PW_FILTER_FLAG_RT_PROCESS	= (1 << 2),	/**< call process from the realtime
++							  *  thread */
++};
++
++enum pw_filter_port_flags {
++	PW_FILTER_PORT_FLAG_NONE		= 0,		/**< no flags */
++	PW_FILTER_PORT_FLAG_MAP_BUFFERS		= (1 << 0),	/**< mmap the buffers */
++	PW_FILTER_PORT_FLAG_ALLOC_BUFFERS	= (1 << 1),	/**< the application will allocate buffer
++								  *  memory. In the add_buffer event, the
++								  *  data of the buffer should be set */
++};
++
++/** Create a new unconneced \ref pw_filter \memberof pw_filter
++ * \return a newly allocated \ref pw_filter */
++struct pw_filter *
++pw_filter_new(struct pw_core *core,		/**< a \ref pw_core */
++	      const char *name,			/**< a filter media name */
++	      struct pw_properties *props	/**< filter properties, ownership is taken */);
++
++struct pw_filter *
++pw_filter_new_simple(struct pw_loop *loop,		/**< a \ref pw_loop to use */
++		     const char *name,			/**< a filter media name */
++		     struct pw_properties *props,	/**< filter properties, ownership is taken */
++		     const struct pw_filter_events *events,	/**< filter events */
++		     void *data					/**< data passed to events */);
++
++/** Destroy a filter \memberof pw_filter */
++void pw_filter_destroy(struct pw_filter *filter);
++
++void pw_filter_add_listener(struct pw_filter *filter,
++			    struct spa_hook *listener,
++			    const struct pw_filter_events *events,
++			    void *data);
++
++enum pw_filter_state pw_filter_get_state(struct pw_filter *filter, const char **error);
++
++const char *pw_filter_get_name(struct pw_filter *filter);
++
++struct pw_core *pw_filter_get_core(struct pw_filter *filter);
++
++/** Connect a filter for processing. \memberof pw_filter
++ * \return 0 on success < 0 on error.
++ *
++ * You should connect to the process event and use pw_filter_dequeue_buffer()
++ * to get the latest metadata and data. */
++int
++pw_filter_connect(struct pw_filter *filter,		/**< a \ref pw_filter */
++		  enum pw_filter_flags flags,		/**< filter flags */
++		  const struct spa_pod **params,	/**< an array with params. */
++		  uint32_t n_params			/**< number of items in \a params */);
++
++/** Get the node ID of the filter. \memberof pw_filter
++ * \return node ID. */
++uint32_t
++pw_filter_get_node_id(struct pw_filter *filter);
++
++/** Disconnect \a filter \memberof pw_filter */
++int pw_filter_disconnect(struct pw_filter *filter);
++
++/** add a port to the filter, returns user data of port_data_size. */
++void *pw_filter_add_port(struct pw_filter *filter,
++		enum pw_direction direction,		/**< port direction */
++		enum pw_filter_port_flags flags,	/**< port flags */
++		size_t port_data_size,			/**< allocated and given to the user as port_data */
++		struct pw_properties *props,		/**< port properties, ownership is taken */
++		const struct spa_pod **params,		/**< an array of params. The params should
++							  *  ideally contain the supported formats */
++		uint32_t n_params			/**< number of elements in \a params */);
++
++/** remove a port from the filter */
++int pw_filter_remove_port(void *port_data		/**< data associated with port */);
++
++/** get properties, port_data of NULL will give global properties */
++const struct pw_properties *pw_filter_get_properties(struct pw_filter *filter,
++		void *port_data);
++
++/** Update properties, use NULL port_data for global filter properties */
++int pw_filter_update_properties(struct pw_filter *filter,
++		void *port_data, const struct spa_dict *dict);
++
++/** Set the filter in error state */
++int pw_filter_set_error(struct pw_filter *filter,	/**< a \ref pw_filter */
++			int res,			/**< a result code */
++			const char *error, ...		/**< an error message */) SPA_PRINTF_FUNC(3, 4);
++
++/** Update params, use NULL port_data for global filter params */
++int
++pw_filter_update_params(struct pw_filter *filter,	/**< a \ref pw_filter */
++			void *port_data,		/**< data associated with port */
++			const struct spa_pod **params,	/**< an array of params. */
++			uint32_t n_params		/**< number of elements in \a params */);
++
++
++#if 0
++/** A time structure \memberof pw_filter */
++struct pw_time {
++	int64_t now;			/**< the monotonic time */
++	struct spa_fraction rate;	/**< the rate of \a ticks and delay */
++	uint64_t ticks;			/**< the ticks at \a now. This is the current time that
++					  *  the remote end is reading/writing. */
++};
++#endif
++
++/** Query the time on the filter \memberof pw_filter */
++int pw_filter_get_time(struct pw_filter *filter, struct pw_time *time);
++
++/** Get a buffer that can be filled for output ports or consumed
++ * for input ports.  */
++struct pw_buffer *pw_filter_dequeue_buffer(void *port_data);
++
++/** Submit a buffer for playback or recycle a buffer for capture. */
++int pw_filter_queue_buffer(void *port_data, struct pw_buffer *buffer);
++
++/** Get a data pointer to the buffer data */
++void *pw_filter_get_dsp_buffer(void *port_data, uint32_t n_samples);
++
++/** Activate or deactivate the filter \memberof pw_filter */
++int pw_filter_set_active(struct pw_filter *filter, bool active);
++
++/** Flush a filter. When \a drain is true, the drained callback will
++ * be called when all data is played or recorded */
++int pw_filter_flush(struct pw_filter *filter, bool drain);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_FILTER_H */
+diff --git a/third_party/pipewire/pipewire/global.h b/third_party/pipewire/pipewire/global.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/global.h
+@@ -0,0 +1,155 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_GLOBAL_H
++#define PIPEWIRE_GLOBAL_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \page page_global Global
++ *
++ * Global objects represent resources that are available on the PipeWire
++ * context and are accessible to remote clients.
++ * Globals come and go when devices or other resources become available for
++ * clients.
++ *
++ * Remote clients receives a list of globals when it binds to the registry
++ * object. See \ref page_registry.
++ *
++ * A client can bind to a global to send methods or receive events from
++ * the global.
++ */
++/** \class pw_global
++ *
++ * \brief A global object visible to remote clients
++ *
++ * A global object is visible to remote clients and represents a resource
++ * that can be used or inspected.
++ *
++ * See \ref page_remote_api
++ */
++struct pw_global;
++
++#include <pipewire/impl.h>
++
++typedef int (*pw_global_bind_func_t) (void *object,
++		      struct pw_impl_client *client,	/**< client that binds */
++		      uint32_t permissions,	/**< permissions for the bind */
++		      uint32_t version,		/**< client interface version */
++		      uint32_t id		/**< client proxy id */);
++
++/** Global events, use \ref pw_global_add_listener */
++struct pw_global_events {
++#define PW_VERSION_GLOBAL_EVENTS 0
++	uint32_t version;
++
++	/** The global is destroyed */
++	void (*destroy) (void *data);
++	/** The global is freed */
++	void (*free) (void *data);
++	/** The permissions changed for a client */
++	void (*permissions_changed) (void *data,
++			struct pw_impl_client *client,
++			uint32_t old_permissions,
++			uint32_t new_permissions);
++};
++
++/** Create a new global object */
++struct pw_global *
++pw_global_new(struct pw_context *context,	/**< the context */
++	      const char *type,			/**< the interface type of the global */
++	      uint32_t version,			/**< the interface version of the global */
++	      struct pw_properties *properties,	/**< extra properties */
++	      pw_global_bind_func_t func,	/**< function to bind */
++	      void *object			/**< global object */);
++
++/** Register a global object to the context registry */
++int pw_global_register(struct pw_global *global);
++
++/** Add an event listener on the global */
++void pw_global_add_listener(struct pw_global *global,
++			    struct spa_hook *listener,
++			    const struct pw_global_events *events,
++			    void *data);
++
++/** Get the permissions of the global for a given client */
++uint32_t pw_global_get_permissions(struct pw_global *global, struct pw_impl_client *client);
++
++/** Get the context object of this global */
++struct pw_context *pw_global_get_context(struct pw_global *global);
++
++/** Get the global type */
++const char *pw_global_get_type(struct pw_global *global);
++
++/** Check a global type */
++bool pw_global_is_type(struct pw_global *global, const char *type);
++
++/** Get the global version */
++uint32_t pw_global_get_version(struct pw_global *global);
++
++/** Get the global properties */
++const struct pw_properties *pw_global_get_properties(struct pw_global *global);
++
++/** Update the global properties, must be done when unregistered */
++int pw_global_update_keys(struct pw_global *global,
++		     const struct spa_dict *dict, const char *keys[]);
++
++/** Get the object associated with the global. This depends on the type of the
++  * global */
++void *pw_global_get_object(struct pw_global *global);
++
++/** Get the unique id of the global */
++uint32_t pw_global_get_id(struct pw_global *global);
++
++/** Add a resource to a global */
++int pw_global_add_resource(struct pw_global *global, struct pw_resource *resource);
++
++/** Iterate all resources added to the global The callback should return
++ * 0 to fetch the next item, any other value stops the iteration and returns
++ * the value. When all callbacks return 0, this function returns 0 when all
++ * items are iterated. */
++int pw_global_for_each_resource(struct pw_global *global,
++			   int (*callback) (void *data, struct pw_resource *resource),
++			   void *data);
++
++/** Let a client bind to a global */
++int pw_global_bind(struct pw_global *global,
++		   struct pw_impl_client *client,
++		   uint32_t permissions,
++		   uint32_t version,
++		   uint32_t id);
++
++int pw_global_update_permissions(struct pw_global *global, struct pw_impl_client *client,
++		uint32_t old_permissions, uint32_t new_permissions);
++
++/** Destroy a global */
++void pw_global_destroy(struct pw_global *global);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_GLOBAL_H */
+diff --git a/third_party/pipewire/pipewire/impl-client.h b/third_party/pipewire/pipewire/impl-client.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-client.h
+@@ -0,0 +1,174 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_CLIENT_H
++#define PIPEWIRE_IMPL_CLIENT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++/** \class pw_impl_client
++ *
++ * \brief PipeWire client object class.
++ *
++ * The client object represents a client connection with the PipeWire
++ * server.
++ *
++ * Each client has its own list of resources it is bound to along with
++ * a mapping between the client types and server types.
++ */
++struct pw_impl_client;
++
++#include <pipewire/context.h>
++#include <pipewire/global.h>
++#include <pipewire/properties.h>
++#include <pipewire/resource.h>
++#include <pipewire/permission.h>
++
++/** \page page_client Client
++ *
++ * \section sec_page_client_overview Overview
++ *
++ * The \ref pw_impl_client object is created by a protocol implementation when
++ * a new client connects.
++ *
++ * The client is used to keep track of all resources belonging to one
++ * connection with the PipeWire server.
++ *
++ * \section sec_page_client_credentials Credentials
++ *
++ * The client object will have its credentials filled in by the protocol.
++ * This information is used to check if a resource or action is available
++ * for this client. See also \ref page_access
++ *
++ * \section sec_page_client_types Types
++ *
++ * The client and server maintain a mapping between the client and server
++ * types. All type ids that are in messages exchanged between the client
++ * and server will automatically be remapped. See also \ref page_types.
++ *
++ * \section sec_page_client_resources Resources
++ *
++ * When a client binds to context global object, a resource is made for this
++ * binding and a unique id is assigned to the resources. The client and
++ * server will use this id as the destination when exchanging messages.
++ * See also \ref page_resource
++ */
++
++/** The events that a client can emit */
++struct pw_impl_client_events {
++#define PW_VERSION_IMPL_CLIENT_EVENTS	0
++        uint32_t version;
++
++	/** emitted when the client is destroyed */
++	void (*destroy) (void *data);
++
++	/** emitted right before the client is freed */
++	void (*free) (void *data);
++
++	/** the client is initialized */
++	void (*initialized) (void *data);
++
++	/** emitted when the client info changed */
++	void (*info_changed) (void *data, const struct pw_client_info *info);
++
++	/** emitted when a new resource is added for client */
++	void (*resource_added) (void *data, struct pw_resource *resource);
++
++	/** emitted when a resource is removed */
++	void (*resource_removed) (void *data, struct pw_resource *resource);
++
++	/** emitted when the client becomes busy processing an asynchronous
++	 * message. In the busy state no messages should be processed.
++	 * Processing should resume when the client becomes not busy */
++	void (*busy_changed) (void *data, bool busy);
++};
++
++/** Create a new client. This is mainly used by protocols. */
++struct pw_impl_client *
++pw_context_create_client(struct pw_impl_core *core,		/**< the core object */
++			struct pw_protocol *prototol,		/**< the client protocol */
++			struct pw_properties *properties,	/**< client properties */
++			size_t user_data_size			/**< extra user data size */);
++
++/** Destroy a previously created client */
++void pw_impl_client_destroy(struct pw_impl_client *client);
++
++/** Finish configuration and register a client */
++int pw_impl_client_register(struct pw_impl_client *client,	/**< the client to register */
++		       struct pw_properties *properties/**< extra properties */);
++
++/** Get the client user data */
++void *pw_impl_client_get_user_data(struct pw_impl_client *client);
++
++/** Get the client information */
++const struct pw_client_info *pw_impl_client_get_info(struct pw_impl_client *client);
++
++/** Update the client properties */
++int pw_impl_client_update_properties(struct pw_impl_client *client, const struct spa_dict *dict);
++
++/** Update the client permissions */
++int pw_impl_client_update_permissions(struct pw_impl_client *client, uint32_t n_permissions,
++		const struct pw_permission *permissions);
++
++/** check if a client has permissions for global_id, Since 0.3.9 */
++int pw_impl_client_check_permissions(struct pw_impl_client *client,
++		uint32_t global_id, uint32_t permissions);
++
++/** Get the client properties */
++const struct pw_properties *pw_impl_client_get_properties(struct pw_impl_client *client);
++
++/** Get the context used to create this client */
++struct pw_context *pw_impl_client_get_context(struct pw_impl_client *client);
++/** Get the protocol used to create this client */
++struct pw_protocol *pw_impl_client_get_protocol(struct pw_impl_client *client);
++
++/** Get the client core resource */
++struct pw_resource *pw_impl_client_get_core_resource(struct pw_impl_client *client);
++
++/** Get a resource with the given id */
++struct pw_resource *pw_impl_client_find_resource(struct pw_impl_client *client, uint32_t id);
++
++/** Get the global associated with this client */
++struct pw_global *pw_impl_client_get_global(struct pw_impl_client *client);
++
++/** listen to events from this client */
++void pw_impl_client_add_listener(struct pw_impl_client *client,
++			    struct spa_hook *listener,
++			    const struct pw_impl_client_events *events,
++			    void *data);
++
++
++/** Mark the client busy. This can be used when an asynchronous operation is
++  * started and no further processing is allowed to happen for the client */
++void pw_impl_client_set_busy(struct pw_impl_client *client, bool busy);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_CLIENT_H */
+diff --git a/third_party/pipewire/pipewire/impl-core.h b/third_party/pipewire/pipewire/impl-core.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-core.h
+@@ -0,0 +1,94 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_CORE_H
++#define PIPEWIRE_IMPL_CORE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_impl_core
++ *
++ * \brief PipeWire core interface.
++ *
++ * The core is used to make objects on demand.
++ */
++struct pw_impl_core;
++
++#include <pipewire/context.h>
++#include <pipewire/global.h>
++#include <pipewire/properties.h>
++#include <pipewire/resource.h>
++
++/** Factory events, listen to them with \ref pw_impl_core_add_listener */
++struct pw_impl_core_events {
++#define PW_VERSION_IMPL_CORE_EVENTS	0
++	uint32_t version;
++
++	/** the core is destroyed */
++        void (*destroy) (void *data);
++	/** the core is freed */
++        void (*free) (void *data);
++	/** the core is initialized */
++        void (*initialized) (void *data);
++};
++
++struct pw_impl_core *pw_context_create_core(struct pw_context *context,
++				  struct pw_properties *properties,
++				  size_t user_data_size);
++
++/* get the default core in a context */
++struct pw_impl_core *pw_context_get_default_core(struct pw_context *context);
++
++/** Get the core properties */
++const struct pw_properties *pw_impl_core_get_properties(struct pw_impl_core *core);
++
++/** Get the core information */
++const struct pw_core_info *pw_impl_core_get_info(struct pw_impl_core *core);
++
++/** Update the core properties */
++int pw_impl_core_update_properties(struct pw_impl_core *core, const struct spa_dict *dict);
++
++int pw_impl_core_register(struct pw_impl_core *core,
++			struct pw_properties *properties);
++
++void pw_impl_core_destroy(struct pw_impl_core *core);
++
++void *pw_impl_core_get_user_data(struct pw_impl_core *core);
++
++/** Get the global of this core */
++struct pw_global *pw_impl_core_get_global(struct pw_impl_core *core);
++
++/** Add an event listener */
++void pw_impl_core_add_listener(struct pw_impl_core *core,
++			     struct spa_hook *listener,
++			     const struct pw_impl_core_events *events,
++			     void *data);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_CORE_H */
+diff --git a/third_party/pipewire/pipewire/impl-device.h b/third_party/pipewire/pipewire/impl-device.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-device.h
+@@ -0,0 +1,109 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_DEVICE_H
++#define PIPEWIRE_IMPL_DEVICE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_impl_device
++ *
++ * \brief PipeWire device interface.
++ *
++ * The device is an object that manages nodes. It typically
++ * corresponds to a physical hardware device but it does not
++ * have to be.
++ *
++ * The purpose of the device is to provide an interface to
++ * dynamically create/remove/configure the nodes it manages.
++ */
++struct pw_impl_device;
++
++#include <spa/monitor/device.h>
++
++#include <pipewire/context.h>
++#include <pipewire/global.h>
++#include <pipewire/properties.h>
++#include <pipewire/resource.h>
++
++/** Device events, listen to them with \ref pw_impl_device_add_listener */
++struct pw_impl_device_events {
++#define PW_VERSION_IMPL_DEVICE_EVENTS	0
++	uint32_t version;
++
++	/** the device is destroyed */
++        void (*destroy) (void *data);
++	/** the device is freed */
++        void (*free) (void *data);
++	/** the device is initialized */
++        void (*initialized) (void *data);
++
++	/** the device info changed */
++	void (*info_changed) (void *data, const struct pw_device_info *info);
++};
++
++struct pw_impl_device *pw_context_create_device(struct pw_context *context,
++				struct pw_properties *properties,
++				size_t user_data_size);
++
++int pw_impl_device_register(struct pw_impl_device *device,
++		       struct pw_properties *properties);
++
++void pw_impl_device_destroy(struct pw_impl_device *device);
++
++void *pw_impl_device_get_user_data(struct pw_impl_device *device);
++
++/** Set the device implementation */
++int pw_impl_device_set_implementation(struct pw_impl_device *device, struct spa_device *spa_device);
++/** Get the device implementation */
++struct spa_device *pw_impl_device_get_implementation(struct pw_impl_device *device);
++
++/** Get the global of this device */
++struct pw_global *pw_impl_device_get_global(struct pw_impl_device *device);
++
++/** Add an event listener */
++void pw_impl_device_add_listener(struct pw_impl_device *device,
++			    struct spa_hook *listener,
++			    const struct pw_impl_device_events *events,
++			    void *data);
++
++int pw_impl_device_update_properties(struct pw_impl_device *device, const struct spa_dict *dict);
++
++const struct pw_properties *pw_impl_device_get_properties(struct pw_impl_device *device);
++
++int pw_impl_device_for_each_param(struct pw_impl_device *device,
++			     int seq, uint32_t param_id,
++			     uint32_t index, uint32_t max,
++			     const struct spa_pod *filter,
++			     int (*callback) (void *data, int seq,
++					      uint32_t id, uint32_t index, uint32_t next,
++					      struct spa_pod *param),
++			     void *data);
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_DEVICE_H */
+diff --git a/third_party/pipewire/pipewire/impl-factory.h b/third_party/pipewire/pipewire/impl-factory.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-factory.h
+@@ -0,0 +1,124 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_FACTORY_H
++#define PIPEWIRE_IMPL_FACTORY_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_impl_factory
++ *
++ * \brief PipeWire factory interface.
++ *
++ * The factory is used to make objects on demand.
++ */
++struct pw_impl_factory;
++
++#include <pipewire/context.h>
++#include <pipewire/impl-client.h>
++#include <pipewire/global.h>
++#include <pipewire/properties.h>
++#include <pipewire/resource.h>
++
++/** Factory events, listen to them with \ref pw_impl_factory_add_listener */
++struct pw_impl_factory_events {
++#define PW_VERSION_IMPL_FACTORY_EVENTS	0
++	uint32_t version;
++
++	/** the factory is destroyed */
++        void (*destroy) (void *data);
++	/** the factory is freed */
++        void (*free) (void *data);
++	/** the factory is initialized */
++        void (*initialized) (void *data);
++};
++
++struct pw_impl_factory_implementation {
++#define PW_VERSION_IMPL_FACTORY_IMPLEMENTATION	0
++	uint32_t version;
++
++	/** The function to create an object from this factory */
++	void *(*create_object) (void *data,
++				struct pw_resource *resource,
++				const char *type,
++				uint32_t version,
++				struct pw_properties *properties,
++				uint32_t new_id);
++};
++
++struct pw_impl_factory *pw_context_create_factory(struct pw_context *context,
++				  const char *name,
++				  const char *type,
++				  uint32_t version,
++				  struct pw_properties *properties,
++				  size_t user_data_size);
++
++/** Get the factory properties */
++const struct pw_properties *pw_impl_factory_get_properties(struct pw_impl_factory *factory);
++
++/** Get the factory info */
++const struct pw_factory_info *pw_impl_factory_get_info(struct pw_impl_factory *factory);
++
++/** Update the factory properties */
++int pw_impl_factory_update_properties(struct pw_impl_factory *factory, const struct spa_dict *dict);
++
++int pw_impl_factory_register(struct pw_impl_factory *factory,
++			struct pw_properties *properties);
++
++void pw_impl_factory_destroy(struct pw_impl_factory *factory);
++
++void *pw_impl_factory_get_user_data(struct pw_impl_factory *factory);
++
++/** Get the global of this factory */
++struct pw_global *pw_impl_factory_get_global(struct pw_impl_factory *factory);
++
++/** Add an event listener */
++void pw_impl_factory_add_listener(struct pw_impl_factory *factory,
++			     struct spa_hook *listener,
++			     const struct pw_impl_factory_events *events,
++			     void *data);
++
++void pw_impl_factory_set_implementation(struct pw_impl_factory *factory,
++				   const struct pw_impl_factory_implementation *implementation,
++				   void *data);
++
++void *pw_impl_factory_create_object(struct pw_impl_factory *factory,
++			       struct pw_resource *resource,
++			       const char *type,
++			       uint32_t version,
++			       struct pw_properties *properties,
++			       uint32_t new_id);
++
++/** Find a factory by name */
++struct pw_impl_factory *
++pw_context_find_factory(struct pw_context *context	/**< the context */,
++		     const char *name			/**< the factory name */);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_FACTORY_H */
+diff --git a/third_party/pipewire/pipewire/impl-link.h b/third_party/pipewire/pipewire/impl-link.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-link.h
+@@ -0,0 +1,128 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_LINK_H
++#define PIPEWIRE_IMPL_LINK_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_impl_link
++ *
++ * PipeWire link object.
++ */
++struct pw_impl_link;
++struct pw_impl_port;
++
++#include <pipewire/impl.h>
++
++/** \page page_link Link
++ *
++ * \section page_link_overview Overview
++ *
++ * A link is the connection between 2 nodes (\ref page_node). Nodes are
++ * linked together on ports.
++ *
++ * The link is responsible for negotiating the format and buffers for
++ * the nodes.
++ */
++
++/** link events added with \ref pw_impl_link_add_listener */
++struct pw_impl_link_events {
++#define PW_VERSION_IMPL_LINK_EVENTS	0
++	uint32_t version;
++
++	/** A link is destroyed */
++	void (*destroy) (void *data);
++
++	/** A link is freed */
++	void (*free) (void *data);
++
++	/** a Link is initialized */
++	void (*initialized) (void *data);
++
++	/** The info changed on a link */
++	void (*info_changed) (void *data, const struct pw_link_info *info);
++
++	/** The link state changed, \a error is only valid when the state is
++	  * in error. */
++	void (*state_changed) (void *data, enum pw_link_state old,
++					   enum pw_link_state state, const char *error);
++
++	/** A port is unlinked */
++	void (*port_unlinked) (void *data, struct pw_impl_port *port);
++};
++
++
++/** Make a new link between two ports \memberof pw_impl_link
++ * \return a newly allocated link */
++struct pw_impl_link *
++pw_context_create_link(struct pw_context *context,		/**< the context object */
++	    struct pw_impl_port *output,		/**< an output port */
++	    struct pw_impl_port *input,		/**< an input port */
++	    struct spa_pod *format_filter,	/**< an optional format filter */
++	    struct pw_properties *properties	/**< extra properties */,
++	    size_t user_data_size		/**< extra user data size */);
++
++/** Destroy a link \memberof pw_impl_link */
++void pw_impl_link_destroy(struct pw_impl_link *link);
++
++/** Add an event listener to \a link */
++void pw_impl_link_add_listener(struct pw_impl_link *link,
++			  struct spa_hook *listener,
++			  const struct pw_impl_link_events *events,
++			  void *data);
++
++/** Finish link configuration and register */
++int pw_impl_link_register(struct pw_impl_link *link,		/**< the link to register */
++		     struct pw_properties *properties	/**< extra properties */);
++
++/** Get the context of a link */
++struct pw_context *pw_impl_link_get_context(struct pw_impl_link *link);
++
++/** Get the user_data of a link, the size of the memory is given when
++  * constructing the link */
++void *pw_impl_link_get_user_data(struct pw_impl_link *link);
++
++/** Get the link info */
++const struct pw_link_info *pw_impl_link_get_info(struct pw_impl_link *link);
++
++/** Get the global of the link */
++struct pw_global *pw_impl_link_get_global(struct pw_impl_link *link);
++
++/** Get the output port of the link */
++struct pw_impl_port *pw_impl_link_get_output(struct pw_impl_link *link);
++
++/** Get the input port of the link */
++struct pw_impl_port *pw_impl_link_get_input(struct pw_impl_link *link);
++
++/** Find the link between 2 ports \memberof pw_impl_link */
++struct pw_impl_link *pw_impl_link_find(struct pw_impl_port *output, struct pw_impl_port *input);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_LINK_H */
+diff --git a/third_party/pipewire/pipewire/impl-module.h b/third_party/pipewire/pipewire/impl-module.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-module.h
+@@ -0,0 +1,110 @@
++/* PipeWire
++ * Copyright © 2016 Axis Communications <dev-gstreamer@axis.com>
++ *	@author Linus Svensson <linus.svensson@axis.com>
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_MODULE_H
++#define PIPEWIRE_IMPL_MODULE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++#include <pipewire/context.h>
++
++#define PIPEWIRE_SYMBOL_MODULE_INIT "pipewire__module_init"
++#define PIPEWIRE_MODULE_PREFIX "libpipewire-"
++
++/** \class pw_impl_module
++ *
++ * A dynamically loadable module
++ */
++struct pw_impl_module;
++
++/** Module init function signature
++ *
++ * \param module A \ref pw_impl_module
++ * \param args Arguments to the module
++ * \return 0 on success, < 0 otherwise with an errno style error
++ *
++ * A module should provide an init function with this signature. This function
++ * will be called when a module is loaded.
++ *
++ * \memberof pw_impl_module
++ */
++typedef int (*pw_impl_module_init_func_t) (struct pw_impl_module *module, const char *args);
++
++/** Module events added with \ref pw_impl_module_add_listener */
++struct pw_impl_module_events {
++#define PW_VERSION_IMPL_MODULE_EVENTS	0
++	uint32_t version;
++
++	/** The module is destroyed */
++	void (*destroy) (void *data);
++	/** The module is freed */
++	void (*free) (void *data);
++	/** The module is initialized */
++	void (*initialized) (void *data);
++
++	/** The module is registered. This is a good time to register
++	 * objectes created from the module. */
++	void (*registered) (void *data);
++};
++
++struct pw_impl_module *
++pw_context_load_module(struct pw_context *context,
++	       const char *name,		/**< name of the module */
++	       const char *args			/**< arguments of the module */,
++	       struct pw_properties *properties	/**< extra global properties */);
++
++/** Get the context of a module */
++struct pw_context * pw_impl_module_get_context(struct pw_impl_module *module);
++
++/** Get the global of a module */
++struct pw_global * pw_impl_module_get_global(struct pw_impl_module *module);
++
++/** Get the node properties */
++const struct pw_properties *pw_impl_module_get_properties(struct pw_impl_module *module);
++
++/** Update the module properties */
++int pw_impl_module_update_properties(struct pw_impl_module *module, const struct spa_dict *dict);
++
++/** Get the module info */
++const struct pw_module_info *pw_impl_module_get_info(struct pw_impl_module *module);
++
++/** Add an event listener to a module */
++void pw_impl_module_add_listener(struct pw_impl_module *module,
++			    struct spa_hook *listener,
++			    const struct pw_impl_module_events *events,
++			    void *data);
++
++/** Destroy a module */
++void pw_impl_module_destroy(struct pw_impl_module *module);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_MODULE_H */
+diff --git a/third_party/pipewire/pipewire/impl-node.h b/third_party/pipewire/pipewire/impl-node.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-node.h
+@@ -0,0 +1,182 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_NODE_H
++#define PIPEWIRE_IMPL_NODE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \page page_node Node
++ *
++ * \section page_node_overview Overview
++ *
++ * The node object processes data. The node has a list of
++ * input and output ports (\ref page_port) on which it
++ * will receive and send out buffers respectively.
++ */
++/** \class pw_impl_node
++ *
++ * PipeWire node class.
++ */
++struct pw_impl_node;
++struct pw_impl_port;
++
++#include <spa/node/node.h>
++#include <spa/node/event.h>
++
++#include <pipewire/impl.h>
++
++/** Node events, listen to them with \ref pw_impl_node_add_listener */
++struct pw_impl_node_events {
++#define PW_VERSION_IMPL_NODE_EVENTS	0
++	uint32_t version;
++
++	/** the node is destroyed */
++        void (*destroy) (void *data);
++	/** the node is about to be freed */
++        void (*free) (void *data);
++	/** the node is initialized */
++        void (*initialized) (void *data);
++
++	/** a port is being initialized on the node */
++        void (*port_init) (void *data, struct pw_impl_port *port);
++	/** a port was added */
++        void (*port_added) (void *data, struct pw_impl_port *port);
++	/** a port was removed */
++        void (*port_removed) (void *data, struct pw_impl_port *port);
++
++	/** the node info changed */
++	void (*info_changed) (void *data, const struct pw_node_info *info);
++	/** a port on the node changed info */
++	void (*port_info_changed) (void *data, struct pw_impl_port *port,
++			const struct pw_port_info *info);
++	/** the node active state changed */
++	void (*active_changed) (void *data, bool active);
++
++	/** a new state is requested on the node */
++	void (*state_request) (void *data, enum pw_node_state state);
++	/** the state of the node changed */
++	void (*state_changed) (void *data, enum pw_node_state old,
++			       enum pw_node_state state, const char *error);
++
++        /** a result was received */
++	void (*result) (void *data, int seq, int res, uint32_t type, const void *result);
++
++        /** an event is emitted */
++	void (*event) (void *data, const struct spa_event *event);
++
++	/** the driver of the node changed */
++	void (*driver_changed) (void *data, struct pw_impl_node *old, struct pw_impl_node *driver);
++
++	/** a peer was added */
++	void (*peer_added) (void *data, struct pw_impl_node *peer);
++	/** a peer was removed */
++	void (*peer_removed) (void *data, struct pw_impl_node *peer);
++};
++
++/** Create a new node \memberof pw_impl_node */
++struct pw_impl_node *
++pw_context_create_node(struct pw_context *context,	/**< the context */
++	    struct pw_properties *properties,	/**< extra properties */
++	    size_t user_data_size		/**< user data size */);
++
++/** Complete initialization of the node and register */
++int pw_impl_node_register(struct pw_impl_node *node,		/**< node to register */
++		     struct pw_properties *properties	/**< extra properties */);
++
++/** Destroy a node */
++void pw_impl_node_destroy(struct pw_impl_node *node);
++
++/** Get the node info */
++const struct pw_node_info *pw_impl_node_get_info(struct pw_impl_node *node);
++
++/** Get node user_data. The size of the memory was given in \ref pw_context_create_node */
++void * pw_impl_node_get_user_data(struct pw_impl_node *node);
++
++/** Get the context of this node */
++struct pw_context *pw_impl_node_get_context(struct pw_impl_node *node);
++
++/** Get the global of this node */
++struct pw_global *pw_impl_node_get_global(struct pw_impl_node *node);
++
++/** Get the node properties */
++const struct pw_properties *pw_impl_node_get_properties(struct pw_impl_node *node);
++
++/** Update the node properties */
++int pw_impl_node_update_properties(struct pw_impl_node *node, const struct spa_dict *dict);
++
++/** Set the node implementation */
++int pw_impl_node_set_implementation(struct pw_impl_node *node, struct spa_node *spa_node);
++
++/** Get the node implementation */
++struct spa_node *pw_impl_node_get_implementation(struct pw_impl_node *node);
++
++/** Add an event listener */
++void pw_impl_node_add_listener(struct pw_impl_node *node,
++			  struct spa_hook *listener,
++			  const struct pw_impl_node_events *events,
++			  void *data);
++
++/** Iterate the ports in the given direction. The callback should return
++ * 0 to fetch the next item, any other value stops the iteration and returns
++ * the value. When all callbacks return 0, this function returns 0 when all
++ * items are iterated. */
++int pw_impl_node_for_each_port(struct pw_impl_node *node,
++			  enum pw_direction direction,
++			  int (*callback) (void *data, struct pw_impl_port *port),
++			  void *data);
++
++int pw_impl_node_for_each_param(struct pw_impl_node *node,
++			   int seq, uint32_t param_id,
++			   uint32_t index, uint32_t max,
++			   const struct spa_pod *filter,
++			   int (*callback) (void *data, int seq,
++					    uint32_t id, uint32_t index, uint32_t next,
++					    struct spa_pod *param),
++			   void *data);
++
++/** Find the port with direction and port_id or NULL when not found. Passing
++ * PW_ID_ANY for port_id will return any port, preferably an unlinked one. */
++struct pw_impl_port *
++pw_impl_node_find_port(struct pw_impl_node *node, enum pw_direction direction, uint32_t port_id);
++
++/** Get a free unused port_id from the node */
++uint32_t pw_impl_node_get_free_port_id(struct pw_impl_node *node, enum pw_direction direction);
++
++int pw_impl_node_initialized(struct pw_impl_node *node);
++
++/** Set a node active. This will start negotiation with all linked active
++  * nodes and start data transport */
++int pw_impl_node_set_active(struct pw_impl_node *node, bool active);
++
++/** Check if a node is active */
++bool pw_impl_node_is_active(struct pw_impl_node *node);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_NODE_H */
+diff --git a/third_party/pipewire/pipewire/impl-port.h b/third_party/pipewire/pipewire/impl-port.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl-port.h
+@@ -0,0 +1,138 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_PORT_H
++#define PIPEWIRE_IMPL_PORT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++/** \page page_port Port
++ *
++ * \section page_node_overview Overview
++ *
++ * A port can be used to link two nodes.
++ */
++/** \class pw_impl_port
++ *
++ * The port object
++ */
++struct pw_impl_port;
++struct pw_impl_link;
++struct pw_control;
++
++#include <pipewire/impl.h>
++
++enum pw_impl_port_state {
++	PW_IMPL_PORT_STATE_ERROR = -1,	/**< the port is in error */
++	PW_IMPL_PORT_STATE_INIT = 0,		/**< the port is being created */
++	PW_IMPL_PORT_STATE_CONFIGURE = 1,	/**< the port is ready for format negotiation */
++	PW_IMPL_PORT_STATE_READY = 2,	/**< the port is ready for buffer allocation */
++	PW_IMPL_PORT_STATE_PAUSED = 3,	/**< the port is paused */
++};
++
++/** Port events, use \ref pw_impl_port_add_listener */
++struct pw_impl_port_events {
++#define PW_VERSION_IMPL_PORT_EVENTS 1
++	uint32_t version;
++
++	/** The port is destroyed */
++	void (*destroy) (void *data);
++
++	/** The port is freed */
++	void (*free) (void *data);
++
++	/** The port is initialized */
++	void (*initialized) (void *data);
++
++	/** the port info changed */
++	void (*info_changed) (void *data, const struct pw_port_info *info);
++
++	/** a new link is added on this port */
++	void (*link_added) (void *data, struct pw_impl_link *link);
++
++	/** a link is removed from this port */
++	void (*link_removed) (void *data, struct pw_impl_link *link);
++
++	/** the state of the port changed */
++	void (*state_changed) (void *data, enum pw_impl_port_state old,
++			enum pw_impl_port_state state, const char *error);
++
++	/** a control was added to the port */
++	void (*control_added) (void *data, struct pw_control *control);
++
++	/** a control was removed from the port */
++	void (*control_removed) (void *data, struct pw_control *control);
++
++	/** a parameter changed, since version 1 */
++	void (*param_changed) (void *data, uint32_t id);
++};
++
++/** Create a new port \memberof pw_impl_port
++ * \return a newly allocated port */
++struct pw_impl_port *
++pw_context_create_port(struct pw_context *context,
++	enum pw_direction direction,
++	uint32_t port_id,
++	const struct spa_port_info *info,
++	size_t user_data_size);
++
++/** Get the port direction */
++enum pw_direction pw_impl_port_get_direction(struct pw_impl_port *port);
++
++/** Get the port properties */
++const struct pw_properties *pw_impl_port_get_properties(struct pw_impl_port *port);
++
++/** Update the port properties */
++int pw_impl_port_update_properties(struct pw_impl_port *port, const struct spa_dict *dict);
++
++/** Get the port info */
++const struct pw_port_info *pw_impl_port_get_info(struct pw_impl_port *port);
++
++/** Get the port id */
++uint32_t pw_impl_port_get_id(struct pw_impl_port *port);
++
++/** Get the port parent node or NULL when not yet set */
++struct pw_impl_node *pw_impl_port_get_node(struct pw_impl_port *port);
++
++/** check is a port has links, return 0 if not, 1 if it is linked */
++int pw_impl_port_is_linked(struct pw_impl_port *port);
++
++/** Add a port to a node \memberof pw_impl_port */
++int pw_impl_port_add(struct pw_impl_port *port, struct pw_impl_node *node);
++
++/** Add an event listener on the port */
++void pw_impl_port_add_listener(struct pw_impl_port *port,
++			  struct spa_hook *listener,
++			  const struct pw_impl_port_events *events,
++			  void *data);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_PORT_H */
+diff --git a/third_party/pipewire/pipewire/impl.h b/third_party/pipewire/pipewire/impl.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/impl.h
+@@ -0,0 +1,57 @@
++/* PipeWire
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_IMPL_H
++#define PIPEWIRE_IMPL_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++struct pw_impl_client;
++struct pw_impl_module;
++struct pw_global;
++struct pw_node;
++struct pw_impl_port;
++struct pw_resource;
++
++#include <pipewire/pipewire.h>
++#include <pipewire/control.h>
++#include <pipewire/impl-core.h>
++#include <pipewire/impl-client.h>
++#include <pipewire/impl-device.h>
++#include <pipewire/impl-factory.h>
++#include <pipewire/global.h>
++#include <pipewire/impl-link.h>
++#include <pipewire/impl-module.h>
++#include <pipewire/impl-node.h>
++#include <pipewire/impl-port.h>
++#include <pipewire/resource.h>
++#include <pipewire/work-queue.h>
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_IMPL_H */
+diff --git a/third_party/pipewire/pipewire/keys.h b/third_party/pipewire/pipewire/keys.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/keys.h
+@@ -0,0 +1,278 @@
++/* PipeWire
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_KEYS_H
++#define PIPEWIRE_KEYS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/**
++ * A collection of keys that are used to add extra information on objects.
++ *
++ * Keys that start with "pipewire." are in general set-once and then
++ * read-only. They are usually used for security sensitive information that
++ * needs to be fixed.
++ *
++ * Properties from other objects can also appear. This usually suggests some
++ * sort of parent/child or owner/owned relationship.
++ */
++#define PW_KEY_PROTOCOL			"pipewire.protocol"	/**< protocol used for connection */
++#define PW_KEY_ACCESS			"pipewire.access"	/**< how the client access is controlled */
++
++/** Various keys related to the identity of a client process and its security.
++ * Must be obtained from trusted sources by the protocol and placed as
++ * read-only properties. */
++#define PW_KEY_SEC_PID			"pipewire.sec.pid"	/**< Client pid, set by protocol */
++#define PW_KEY_SEC_UID			"pipewire.sec.uid"	/**< Client uid, set by protocol*/
++#define PW_KEY_SEC_GID			"pipewire.sec.gid"	/**< client gid, set by protocol*/
++#define PW_KEY_SEC_LABEL		"pipewire.sec.label"	/**< client security label, set by protocol*/
++
++#define PW_KEY_LIBRARY_NAME_SYSTEM	"library.name.system"	/**< name of the system library to use */
++#define PW_KEY_LIBRARY_NAME_LOOP	"library.name.loop"	/**< name of the loop library to use */
++#define PW_KEY_LIBRARY_NAME_DBUS	"library.name.dbus"	/**< name of the dbus library to use */
++
++#define PW_KEY_OBJECT_PATH		"object.path"		/**< unique path to construct the object */
++#define PW_KEY_OBJECT_ID		"object.id"		/**< a global object id */
++
++/* context */
++#define PW_KEY_CONTEXT_PROFILE_MODULES	"context.profile.modules"	/**< a context profile for modules */
++#define PW_KEY_USER_NAME		"context.user-name"	/**< The user name that runs pipewire */
++#define PW_KEY_HOST_NAME		"context.host-name"	/**< The host name of the machine */
++
++/* core */
++#define PW_KEY_CORE_NAME		"core.name"		/**< The name of the core. Default is
++								  *  pipewire-<user-name>-<pid>, overwritten
++								  *  by env(PIPEWIRE_CORE) */
++#define PW_KEY_CORE_VERSION		"core.version"		/**< The version of the core. */
++#define PW_KEY_CORE_DAEMON		"core.daemon"		/**< If the core is listening for connections. */
++
++#define PW_KEY_CORE_ID			"core.id"		/**< the core id */
++#define PW_KEY_CORE_MONITORS		"core.monitors"		/**< the apis monitored by core. */
++
++/* cpu */
++#define PW_KEY_CPU_MAX_ALIGN		"cpu.max-align"		/**< maximum alignment needed to support
++								  *  all CPU optimizations */
++#define PW_KEY_CPU_CORES		"cpu.cores"		/**< number of cores */
++
++/* priorities */
++#define PW_KEY_PRIORITY_SESSION		"priority.session"	/**< priority in session manager */
++#define PW_KEY_PRIORITY_DRIVER		"priority.driver"	/**< priority to be a driver */
++
++/* remote keys */
++#define PW_KEY_REMOTE_NAME		"remote.name"		/**< The name of the remote to connect to,
++								  *  default pipewire-0, overwritten by
++								  *  env(PIPEWIRE_REMOTE) */
++#define PW_KEY_REMOTE_INTENTION		"remote.intention"	/**< The intention of the remote connection,
++								  *  "generic", "screencast" */
++
++/** application keys */
++#define PW_KEY_APP_NAME			"application.name"	/**< application name. Ex: "Totem Music Player" */
++#define PW_KEY_APP_ID			"application.id"	/**< a textual id for identifying an
++								  *  application logically. Ex: "org.gnome.Totem" */
++#define PW_KEY_APP_VERSION		"application.version"
++#define PW_KEY_APP_ICON			"application.icon"	/**< aa base64 blob with PNG image data */
++#define PW_KEY_APP_ICON_NAME		"application.icon-name"	/**< an XDG icon name for the application.
++								  *  Ex: "totem" */
++#define PW_KEY_APP_LANGUAGE		"application.language"	/**< application language if applicable, in
++								  *  standard POSIX format. Ex: "en_GB" */
++
++#define PW_KEY_APP_PROCESS_ID		"application.process.id"	/**< process id  (pid)*/
++#define PW_KEY_APP_PROCESS_BINARY	"application.process.binary"	/**< binary name */
++#define PW_KEY_APP_PROCESS_USER		"application.process.user"	/**< user name */
++#define PW_KEY_APP_PROCESS_HOST		"application.process.host"	/**< host name */
++#define PW_KEY_APP_PROCESS_MACHINE_ID	"application.process.machine-id" /**< the D-Bus host id the
++									   *  application runs on */
++#define PW_KEY_APP_PROCESS_SESSION_ID	"application.process.session-id" /**< login session of the
++									   *  application, on Unix the
++									   *  value of $XDG_SESSION_ID. */
++/** window system */
++#define PW_KEY_WINDOW_X11_DISPLAY	"window.x11.display"	/**< the X11 display string. Ex. ":0.0" */
++
++/** Client properties */
++#define PW_KEY_CLIENT_ID		"client.id"		/**< a client id */
++#define PW_KEY_CLIENT_NAME		"client.name"		/**< the client name */
++#define PW_KEY_CLIENT_API		"client.api"		/**< the client api used to access
++								  *  PipeWire */
++
++/** Node keys */
++#define PW_KEY_NODE_ID			"node.id"		/**< node id */
++#define PW_KEY_NODE_NAME		"node.name"		/**< node name */
++#define PW_KEY_NODE_NICK		"node.nick"		/**< short node name */
++#define PW_KEY_NODE_DESCRIPTION		"node.description"	/**< localized human readable node one-line
++								  *  description. Ex. "Foobar USB Headset" */
++#define PW_KEY_NODE_PLUGGED		"node.plugged"		/**< when the node was created. As a uint64 in
++								  *  nanoseconds. */
++
++#define PW_KEY_NODE_SESSION		"node.session"		/**< the session id this node is part of */
++#define PW_KEY_NODE_GROUP		"node.group"		/**< the group id this node is part of. Nodes
++								  *  in the same group are always scheduled
++								  *  with the same driver. */
++#define PW_KEY_NODE_EXCLUSIVE		"node.exclusive"	/**< node wants exclusive access to resources */
++#define PW_KEY_NODE_AUTOCONNECT		"node.autoconnect"	/**< node wants to be automatically connected
++								  *  to a compatible node */
++#define PW_KEY_NODE_TARGET		"node.target"		/**< node wants to be connected to the target
++								  *  node/session */
++#define PW_KEY_NODE_LATENCY		"node.latency"		/**< the requested latency of the node as
++								  *  a fraction. Ex: 128/48000 */
++#define PW_KEY_NODE_DONT_RECONNECT	"node.dont-reconnect"	/**< don't reconnect this node */
++#define PW_KEY_NODE_ALWAYS_PROCESS	"node.always-process"	/**< process even when unlinked */
++#define PW_KEY_NODE_PAUSE_ON_IDLE	"node.pause-on-idle"	/**< pause the node when idle */
++#define PW_KEY_NODE_DRIVER		"node.driver"		/**< node can drive the graph */
++#define PW_KEY_NODE_STREAM		"node.stream"		/**< node is a stream, the server side should
++								  *  add a converter */
++/** Port keys */
++#define PW_KEY_PORT_ID			"port.id"		/**< port id */
++#define PW_KEY_PORT_NAME		"port.name"		/**< port name */
++#define PW_KEY_PORT_DIRECTION		"port.direction"	/**< the port direction, one of "in" or "out"
++								  *  or "control" and "notify" for control ports */
++#define PW_KEY_PORT_ALIAS		"port.alias"		/**< port alias */
++#define PW_KEY_PORT_PHYSICAL		"port.physical"		/**< if this is a physical port */
++#define PW_KEY_PORT_TERMINAL		"port.terminal"		/**< if this port consumes the data */
++#define PW_KEY_PORT_CONTROL		"port.control"		/**< if this port is a control port */
++#define PW_KEY_PORT_MONITOR		"port.monitor"		/**< if this port is a monitor port */
++
++/** link properties */
++#define PW_KEY_LINK_ID			"link.id"		/**< a link id */
++#define PW_KEY_LINK_INPUT_NODE		"link.input.node"	/**< input node id of a link */
++#define PW_KEY_LINK_INPUT_PORT		"link.input.port"	/**< input port id of a link */
++#define PW_KEY_LINK_OUTPUT_NODE		"link.output.node"	/**< output node id of a link */
++#define PW_KEY_LINK_OUTPUT_PORT		"link.output.port"	/**< output port id of a link */
++#define PW_KEY_LINK_PASSIVE		"link.passive"		/**< indicate that a link is passive and
++								  *  does not cause the graph to be
++								  *  runnable. */
++/** device properties */
++#define PW_KEY_DEVICE_ID		"device.id"		/**< device id */
++#define PW_KEY_DEVICE_NAME		"device.name"		/**< device name */
++#define PW_KEY_DEVICE_PLUGGED		"device.plugged"	/**< when the device was created. As a uint64 in
++								  *  nanoseconds. */
++#define PW_KEY_DEVICE_NICK		"device.nick"		/**< a short device nickname */
++#define PW_KEY_DEVICE_STRING		"device.string"		/**< device string in the underlying layer's
++								  *  format. Ex. "surround51:0" */
++#define PW_KEY_DEVICE_API		"device.api"		/**< API this device is accessed with.
++								  *  Ex. "alsa", "v4l2" */
++#define PW_KEY_DEVICE_DESCRIPTION	"device.description"	/**< localized human readable device one-line
++								  *  description. Ex. "Foobar USB Headset" */
++#define PW_KEY_DEVICE_BUS_PATH		"device.bus-path"	/**< bus path to the device in the OS'
++								  *  format. Ex. "pci-0000:00:14.0-usb-0:3.2:1.0" */
++#define PW_KEY_DEVICE_SERIAL		"device.serial"		/**< Serial number if applicable */
++#define PW_KEY_DEVICE_VENDOR_ID		"device.vendor.id"	/**< vendor ID if applicable */
++#define PW_KEY_DEVICE_VENDOR_NAME	"device.vendor.name"	/**< vendor name if applicable */
++#define PW_KEY_DEVICE_PRODUCT_ID	"device.product.id"	/**< product ID if applicable */
++#define PW_KEY_DEVICE_PRODUCT_NAME	"device.product.name"	/**< product name if applicable */
++#define PW_KEY_DEVICE_CLASS		"device.class"		/**< device class */
++#define PW_KEY_DEVICE_FORM_FACTOR	"device.form-factor"	/**< form factor if applicable. One of
++								  *  "internal", "speaker", "handset", "tv",
++								  *  "webcam", "microphone", "headset",
++								  *  "headphone", "hands-free", "car", "hifi",
++								  *  "computer", "portable" */
++#define PW_KEY_DEVICE_BUS		"device.bus"		/**< bus of the device if applicable. One of
++								  *  "isa", "pci", "usb", "firewire",
++								  *  "bluetooth" */
++#define PW_KEY_DEVICE_SUBSYSTEM		"device.subsystem"	/**< device subsystem */
++#define PW_KEY_DEVICE_ICON		"device.icon"		/**< icon for the device. A base64 blob
++								  *  containing PNG image data */
++#define PW_KEY_DEVICE_ICON_NAME		"device.icon-name"	/**< an XDG icon name for the device.
++								  *  Ex. "sound-card-speakers-usb" */
++#define PW_KEY_DEVICE_INTENDED_ROLES	"device.intended-roles"	/**< intended use. A space separated list of
++								  *  roles (see PW_KEY_MEDIA_ROLE) this device
++								  *  is particularly well suited for, due to
++								  *  latency, quality or form factor. */
++
++/** module properties */
++#define PW_KEY_MODULE_ID		"module.id"		/**< the module id */
++#define PW_KEY_MODULE_NAME		"module.name"		/**< the name of the module */
++#define PW_KEY_MODULE_AUTHOR		"module.author"		/**< the author's name */
++#define PW_KEY_MODULE_DESCRIPTION	"module.description"	/**< a human readable one-line description
++								  *  of the module's purpose.*/
++#define PW_KEY_MODULE_USAGE		"module.usage"		/**< a human readable usage description of
++								  *  the module's arguments. */
++#define PW_KEY_MODULE_VERSION		"module.version"	/**< a version string for the module. */
++
++/** Factory properties */
++#define PW_KEY_FACTORY_ID		"factory.id"		/**< the factory id */
++#define PW_KEY_FACTORY_NAME		"factory.name"		/**< the name of the factory */
++#define PW_KEY_FACTORY_USAGE		"factory.usage"		/**< the usage of the factory */
++#define PW_KEY_FACTORY_TYPE_NAME	"factory.type.name"	/**< the name of the type created by a factory */
++#define PW_KEY_FACTORY_TYPE_VERSION	"factory.type.version"	/**< the version of the type created by a factory */
++
++/** Stream properties */
++#define PW_KEY_STREAM_IS_LIVE		"stream.is-live"	/**< Indicates that the stream is live. */
++#define PW_KEY_STREAM_LATENCY_MIN	"stream.latency.min"	/**< The minimum latency of the stream. */
++#define PW_KEY_STREAM_LATENCY_MAX	"stream.latency.max"	/**< The maximum latency of the stream */
++#define PW_KEY_STREAM_MONITOR		"stream.monitor"	/**< Indicates that the stream is monitoring
++								  *  and might select a less accurate but faster
++								  *  conversion algorithm. */
++#define PW_KEY_STREAM_DONT_REMIX	"stream.dont-remix"	/**< don't remix channels */
++
++/** object properties */
++#define PW_KEY_OBJECT_LINGER		"object.linger"		/**< the object lives on even after the client
++								  *  that created it has been destroyed */
++
++/** Media */
++#define PW_KEY_MEDIA_TYPE		"media.type"		/**< Media type, one of
++								  *  Audio, Video, Midi */
++#define PW_KEY_MEDIA_CATEGORY		"media.category"	/**< Media Category:
++								  *  Playback, Capture, Duplex, Monitor */
++#define PW_KEY_MEDIA_ROLE		"media.role"		/**< Role: Movie, Music, Camera,
++								  *  Screen, Communication, Game,
++								  *  Notification, DSP, Production,
++								  *  Accessibility, Test */
++#define PW_KEY_MEDIA_CLASS		"media.class"		/**< class Ex: "Video/Source" */
++#define PW_KEY_MEDIA_NAME		"media.name"		/**< media name. Ex: "Pink Floyd: Time" */
++#define PW_KEY_MEDIA_TITLE		"media.title"		/**< title. Ex: "Time" */
++#define PW_KEY_MEDIA_ARTIST		"media.artist"		/**< artist. Ex: "Pink Floyd" */
++#define PW_KEY_MEDIA_COPYRIGHT		"media.copyright"	/**< copyright string */
++#define PW_KEY_MEDIA_SOFTWARE		"media.software"	/**< generator software */
++#define PW_KEY_MEDIA_LANGUAGE		"media.language"	/**< language in POSIX format. Ex: en_GB */
++#define PW_KEY_MEDIA_FILENAME		"media.filename"	/**< filename */
++#define PW_KEY_MEDIA_ICON		"media.icon"		/**< icon for the media, a base64 blob with
++								  *  PNG image data */
++#define PW_KEY_MEDIA_ICON_NAME		"media.icon-name"	/**< an XDG icon name for the media.
++								  *  Ex: "audio-x-mp3" */
++
++/** format related properties */
++#define PW_KEY_FORMAT_DSP		"format.dsp"		/**< a dsp format.
++								  *  Ex: "32 bit float mono audio" */
++/** audio related properties */
++#define PW_KEY_AUDIO_CHANNEL		"audio.channel"		/**< an audio channel. Ex: "FL" */
++#define PW_KEY_AUDIO_RATE		"audio.samplerate"	/**< an audio samplerate */
++#define PW_KEY_AUDIO_CHANNELS		"audio.channels"	/**< number of audio channels */
++#define PW_KEY_AUDIO_FORMAT		"audio.format"		/**< an audio format. Ex: "S16LE" */
++
++/** video related properties */
++#define PW_KEY_VIDEO_RATE		"video.framerate"	/**< a video framerate */
++#define PW_KEY_VIDEO_FORMAT		"video.format"		/**< a video format */
++#define PW_KEY_VIDEO_SIZE		"video.size"		/**< a video size as "<width>x<height" */
++
++#ifdef PW_ENABLE_DEPRECATED
++#define PW_KEY_PRIORITY_MASTER		"priority.master"	/**< deprecated */
++#endif /* PW_ENABLE_DEPRECATED */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_KEYS_H */
+diff --git a/third_party/pipewire/pipewire/link.h b/third_party/pipewire/pipewire/link.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/link.h
+@@ -0,0 +1,124 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_LINK_H
++#define PIPEWIRE_LINK_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++#include <pipewire/proxy.h>
++
++#define PW_TYPE_INTERFACE_Link	PW_TYPE_INFO_INTERFACE_BASE "Link"
++
++#define PW_VERSION_LINK		3
++struct pw_link;
++
++/** \enum pw_link_state The different link states \memberof pw_link */
++enum pw_link_state {
++	PW_LINK_STATE_ERROR = -2,	/**< the link is in error */
++	PW_LINK_STATE_UNLINKED = -1,	/**< the link is unlinked */
++	PW_LINK_STATE_INIT = 0,		/**< the link is initialized */
++	PW_LINK_STATE_NEGOTIATING = 1,	/**< the link is negotiating formats */
++	PW_LINK_STATE_ALLOCATING = 2,	/**< the link is allocating buffers */
++	PW_LINK_STATE_PAUSED = 3,	/**< the link is paused */
++};
++
++/** Convert a \ref pw_link_state to a readable string \memberof pw_link */
++const char * pw_link_state_as_string(enum pw_link_state state);
++/** The link information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_link_info {
++	uint32_t id;			/**< id of the global */
++	uint32_t output_node_id;	/**< server side output node id */
++	uint32_t output_port_id;	/**< output port id */
++	uint32_t input_node_id;		/**< server side input node id */
++	uint32_t input_port_id;		/**< input port id */
++#define PW_LINK_CHANGE_MASK_STATE	(1 << 0)
++#define PW_LINK_CHANGE_MASK_FORMAT	(1 << 1)
++#define PW_LINK_CHANGE_MASK_PROPS	(1 << 2)
++#define PW_LINK_CHANGE_MASK_ALL		((1 << 3)-1)
++	uint64_t change_mask;		/**< bitfield of changed fields since last call */
++	enum pw_link_state state;	/**< the current state of the link */
++	const char *error;		/**< an error reason if \a state is error */
++	struct spa_pod *format;		/**< format over link */
++	struct spa_dict *props;		/**< the properties of the link */
++};
++
++struct pw_link_info *
++pw_link_info_update(struct pw_link_info *info,
++		    const struct pw_link_info *update);
++
++void
++pw_link_info_free(struct pw_link_info *info);
++
++
++#define PW_LINK_EVENT_INFO	0
++#define PW_LINK_EVENT_NUM	1
++
++/** Link events */
++struct pw_link_events {
++#define PW_VERSION_LINK_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify link info
++	 *
++	 * \param info info about the link
++	 */
++	void (*info) (void *object, const struct pw_link_info *info);
++};
++
++#define PW_LINK_METHOD_ADD_LISTENER	0
++#define PW_LINK_METHOD_NUM		1
++
++/** Link methods */
++struct pw_link_methods {
++#define PW_VERSION_LINK_METHODS		0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_link_events *events,
++			void *data);
++};
++
++#define pw_link_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_link_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_link_add_listener(c,...)		pw_link_method(c,add_listener,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_LINK_H */
+diff --git a/third_party/pipewire/pipewire/log.h b/third_party/pipewire/pipewire/log.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/log.h
+@@ -0,0 +1,97 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_LOG_H
++#define PIPEWIRE_LOG_H
++
++#include <spa/support/log.h>
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_log
++ *
++ * Logging functions of PipeWire
++ *
++ * Logging is performed to stdout and stderr. Trace logging is performed
++ * in a lockfree ringbuffer and written out from the main thread as to not
++ * block the realtime threads.
++ */
++
++/** The global log level */
++extern enum spa_log_level pw_log_level;
++
++/** Configure a logging module. This is usually done automatically
++ * in pw_init() but you can install a custom logger before calling
++ * pw_init(). */
++void pw_log_set(struct spa_log *log);
++
++/** Get the log interface */
++struct spa_log *pw_log_get(void);
++
++/** Configure the logging level */
++void pw_log_set_level(enum spa_log_level level);
++
++
++/** Log a message */
++void
++pw_log_log(enum spa_log_level level,
++	   const char *file,
++	   int line, const char *func,
++	   const char *fmt, ...) SPA_PRINTF_FUNC(5, 6);
++
++/** Log a message */
++void
++pw_log_logv(enum spa_log_level level,
++	    const char *file,
++	    int line, const char *func,
++	    const char *fmt, va_list args) SPA_PRINTF_FUNC(5, 0);
++
++
++/** Check if a loglevel is enabled \memberof pw_log */
++#define pw_log_level_enabled(lev) (pw_log_level >= (lev))
++
++#define pw_log(lev,...)							\
++({									\
++	if (SPA_UNLIKELY(pw_log_level_enabled (lev)))			\
++		pw_log_log(lev,__FILE__,__LINE__,__func__,__VA_ARGS__);	\
++})
++
++#define pw_log_error(...)   pw_log(SPA_LOG_LEVEL_ERROR,__VA_ARGS__)
++#define pw_log_warn(...)    pw_log(SPA_LOG_LEVEL_WARN,__VA_ARGS__)
++#define pw_log_info(...)    pw_log(SPA_LOG_LEVEL_INFO,__VA_ARGS__)
++#define pw_log_debug(...)   pw_log(SPA_LOG_LEVEL_DEBUG,__VA_ARGS__)
++#define pw_log_trace(...)   pw_log(SPA_LOG_LEVEL_TRACE,__VA_ARGS__)
++
++#ifndef FASTPATH
++#define pw_log_trace_fp(...)   pw_log(SPA_LOG_LEVEL_TRACE,__VA_ARGS__)
++#else
++#define pw_log_trace_fp(...)
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++#endif /* PIPEWIRE_LOG_H */
+diff --git a/third_party/pipewire/pipewire/loop.h b/third_party/pipewire/pipewire/loop.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/loop.h
+@@ -0,0 +1,80 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_LOOP_H
++#define PIPEWIRE_LOOP_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/support/loop.h>
++#include <spa/utils/dict.h>
++
++/** \class pw_loop
++ *
++ * PipeWire loop object provides an implementation of
++ * the spa loop interfaces. It can be used to implement various
++ * event loops.
++ */
++struct pw_loop {
++	struct spa_system *system;		/**< system utils */
++	struct spa_loop *loop;			/**< wrapped loop */
++	struct spa_loop_control *control;	/**< loop control */
++	struct spa_loop_utils *utils;		/**< loop utils */
++};
++
++struct pw_loop *
++pw_loop_new(const struct spa_dict *props);
++
++void
++pw_loop_destroy(struct pw_loop *loop);
++
++#define pw_loop_add_source(l,...)	spa_loop_add_source((l)->loop,__VA_ARGS__)
++#define pw_loop_update_source(l,...)	spa_loop_update_source(__VA_ARGS__)
++#define pw_loop_remove_source(l,...)	spa_loop_remove_source(__VA_ARGS__)
++#define pw_loop_invoke(l,...)		spa_loop_invoke((l)->loop,__VA_ARGS__)
++
++#define pw_loop_get_fd(l)		spa_loop_control_get_fd((l)->control)
++#define pw_loop_add_hook(l,...)		spa_loop_control_add_hook((l)->control,__VA_ARGS__)
++#define pw_loop_enter(l)		spa_loop_control_enter((l)->control)
++#define pw_loop_iterate(l,...)		spa_loop_control_iterate((l)->control,__VA_ARGS__)
++#define pw_loop_leave(l)		spa_loop_control_leave((l)->control)
++
++#define pw_loop_add_io(l,...)		spa_loop_utils_add_io((l)->utils,__VA_ARGS__)
++#define pw_loop_update_io(l,...)	spa_loop_utils_update_io((l)->utils,__VA_ARGS__)
++#define pw_loop_add_idle(l,...)		spa_loop_utils_add_idle((l)->utils,__VA_ARGS__)
++#define pw_loop_enable_idle(l,...)	spa_loop_utils_enable_idle((l)->utils,__VA_ARGS__)
++#define pw_loop_add_event(l,...)	spa_loop_utils_add_event((l)->utils,__VA_ARGS__)
++#define pw_loop_signal_event(l,...)	spa_loop_utils_signal_event((l)->utils,__VA_ARGS__)
++#define pw_loop_add_timer(l,...)	spa_loop_utils_add_timer((l)->utils,__VA_ARGS__)
++#define pw_loop_update_timer(l,...)	spa_loop_utils_update_timer((l)->utils,__VA_ARGS__)
++#define pw_loop_add_signal(l,...)	spa_loop_utils_add_signal((l)->utils,__VA_ARGS__)
++#define pw_loop_destroy_source(l,...)	spa_loop_utils_destroy_source((l)->utils,__VA_ARGS__)
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_LOOP_H */
+diff --git a/third_party/pipewire/pipewire/main-loop.h b/third_party/pipewire/pipewire/main-loop.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/main-loop.h
+@@ -0,0 +1,78 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_MAIN_LOOP_H
++#define PIPEWIRE_MAIN_LOOP_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_main_loop
++ *
++ * \brief PipeWire main-loop interface.
++ *
++ * A main loop object
++ */
++/** A main loop object \memberof pw_main_loop */
++struct pw_main_loop;
++
++#include <pipewire/loop.h>
++
++/** Events of the main loop */
++struct pw_main_loop_events {
++#define PW_VERSION_MAIN_LOOP_EVENTS	0
++	uint32_t version;
++
++	/** Emitted when the main loop is destroyed */
++	void (*destroy) (void *data);
++};
++
++/** Create a new main loop. */
++struct pw_main_loop *
++pw_main_loop_new(const struct spa_dict *props);
++
++/** Add an event listener */
++void pw_main_loop_add_listener(struct pw_main_loop *loop,
++			       struct spa_hook *listener,
++			       const struct pw_main_loop_events *events,
++			       void *data);
++
++/** Get the loop implementation */
++struct pw_loop * pw_main_loop_get_loop(struct pw_main_loop *loop);
++
++/** Destroy a loop */
++void pw_main_loop_destroy(struct pw_main_loop *loop);
++
++/** Run a main loop. This blocks until \ref pw_main_loop_quit is called */
++int pw_main_loop_run(struct pw_main_loop *loop);
++
++/** Quit a main loop */
++int pw_main_loop_quit(struct pw_main_loop *loop);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_MAIN_LOOP_H */
+diff --git a/third_party/pipewire/pipewire/map.h b/third_party/pipewire/pipewire/map.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/map.h
+@@ -0,0 +1,206 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_MAP_H
++#define PIPEWIRE_MAP_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <string.h>
++#include <errno.h>
++
++#include <spa/utils/defs.h>
++#include <pipewire/array.h>
++
++/** \class pw_map
++ *
++ * A map that holds objects indexed by id
++ */
++
++/** An entry in the map \memberof pw_map */
++union pw_map_item {
++	uint32_t next;	/**< next free index */
++	void *data;	/**< data of this item, must be an even address */
++};
++
++/** A map \memberof pw_map */
++struct pw_map {
++	struct pw_array items;	/**< an array with the map items */
++	uint32_t free_list;	/**< the free items */
++};
++
++#define PW_MAP_INIT(extend) (struct pw_map) { PW_ARRAY_INIT(extend), 0 }
++
++#define pw_map_get_size(m)            pw_array_get_len(&(m)->items, union pw_map_item)
++#define pw_map_get_item(m,id)         pw_array_get_unchecked(&(m)->items,id,union pw_map_item)
++#define pw_map_item_is_free(item)     ((item)->next & 0x1)
++#define pw_map_id_is_free(m,id)       (pw_map_item_is_free(pw_map_get_item(m,id)))
++#define pw_map_check_id(m,id)         ((id) < pw_map_get_size(m))
++#define pw_map_has_item(m,id)         (pw_map_check_id(m,id) && !pw_map_id_is_free(m, id))
++#define pw_map_lookup_unchecked(m,id) pw_map_get_item(m,id)->data
++
++/** Convert an id to a pointer that can be inserted into the map \memberof pw_map */
++#define PW_MAP_ID_TO_PTR(id)          (SPA_UINT32_TO_PTR((id)<<1))
++/** Convert a pointer to an id that can be retrieved from the map \memberof pw_map */
++#define PW_MAP_PTR_TO_ID(p)           (SPA_PTR_TO_UINT32(p)>>1)
++
++/** Initialize a map
++ * \param map the map to initialize
++ * \param size the initial size of the map
++ * \param extend the amount to bytes to grow the map with when needed
++ * \memberof pw_map
++ */
++static inline void pw_map_init(struct pw_map *map, size_t size, size_t extend)
++{
++	pw_array_init(&map->items, extend);
++	pw_array_ensure_size(&map->items, size * sizeof(union pw_map_item));
++	map->free_list = SPA_ID_INVALID;
++}
++
++/** Clear a map
++ * \param map the map to clear
++ * \memberof pw_map
++ */
++static inline void pw_map_clear(struct pw_map *map)
++{
++	pw_array_clear(&map->items);
++}
++
++static inline void pw_map_reset(struct pw_map *map)
++{
++	pw_array_reset(&map->items);
++	map->free_list = SPA_ID_INVALID;
++}
++
++/** Insert data in the map
++ * \param map the map to insert into
++ * \param data the item to add
++ * \return the id where the item was inserted or SPA_ID_INVALID when the
++ *	item can not be inserted.
++ * \memberof pw_map
++ */
++static inline uint32_t pw_map_insert_new(struct pw_map *map, void *data)
++{
++	union pw_map_item *start, *item;
++	uint32_t id;
++
++	if (map->free_list != SPA_ID_INVALID) {
++		start = (union pw_map_item *) map->items.data;
++		item = &start[map->free_list >> 1];
++		map->free_list = item->next;
++	} else {
++		item = (union pw_map_item *) pw_array_add(&map->items, sizeof(union pw_map_item));
++		if (item == NULL)
++			return SPA_ID_INVALID;
++		start = (union pw_map_item *) map->items.data;
++	}
++	item->data = data;
++	id = (item - start);
++	return id;
++}
++
++/** Insert data in the map at an index
++ * \param map the map to inser into
++ * \param id the index to insert at
++ * \param data the data to insert
++ * \return 0 on success, -ENOSPC value when the index is invalid or a < 0
++ *	errno value.
++ * \memberof pw_map
++ */
++static inline int pw_map_insert_at(struct pw_map *map, uint32_t id, void *data)
++{
++	size_t size = pw_map_get_size(map);
++	union pw_map_item *item;
++
++	if (id > size)
++		return -ENOSPC;
++	else if (id == size) {
++		item = (union pw_map_item *) pw_array_add(&map->items, sizeof(union pw_map_item));
++		if (item == NULL)
++			return -errno;
++	}
++	else {
++		item = pw_map_get_item(map, id);
++	}
++	item->data = data;
++	return 0;
++}
++
++/** Remove an item at index
++ * \param map the map to remove from
++ * \param id the index to remove
++ * \memberof pw_map
++ */
++static inline void pw_map_remove(struct pw_map *map, uint32_t id)
++{
++	pw_map_get_item(map, id)->next = map->free_list;
++	map->free_list = (id << 1) | 1;
++}
++
++/** Find an item in the map
++ * \param map the map to use
++ * \param id the index to look at
++ * \return the item at \a id or NULL when no such item exists
++ * \memberof pw_map
++ */
++static inline void *pw_map_lookup(struct pw_map *map, uint32_t id)
++{
++	if (SPA_LIKELY(pw_map_check_id(map, id))) {
++		union pw_map_item *item = pw_map_get_item(map, id);
++		if (!pw_map_item_is_free(item))
++			return item->data;
++	}
++	return NULL;
++}
++
++/** Iterate all map items
++ * \param map the map to iterate
++ * \param func the function to call for each item, the item data and \a data is
++ *		passed to the function. When \a func returns a non-zero result,
++ *		iteration ends and the result is returned.
++ * \param data data to pass to \a func
++ * \return the result of the last call to \a func or 0 when all callbacks returned 0.
++ * \memberof pw_map
++ */
++static inline int pw_map_for_each(struct pw_map *map,
++				   int (*func) (void *item_data, void *data), void *data)
++{
++	union pw_map_item *item;
++	int res = 0;
++
++	pw_array_for_each(item, &map->items) {
++		if (!pw_map_item_is_free(item))
++			if ((res = func(item->data, data)) != 0)
++				break;
++	}
++	return res;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_MAP_H */
+diff --git a/third_party/pipewire/pipewire/mem.h b/third_party/pipewire/pipewire/mem.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/mem.h
+@@ -0,0 +1,199 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_MEM_H
++#define PIPEWIRE_MEM_H
++
++#include <pipewire/properties.h>
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** Flags passed to \ref pw_mempool_alloc() \memberof pw_memblock */
++enum pw_memblock_flags {
++	PW_MEMBLOCK_FLAG_NONE =		0,
++	PW_MEMBLOCK_FLAG_READABLE =	(1 << 0),	/**< memory is readable */
++	PW_MEMBLOCK_FLAG_WRITABLE =	(1 << 1),	/**< memory is writable */
++	PW_MEMBLOCK_FLAG_SEAL =		(1 << 2),	/**< seal the fd */
++	PW_MEMBLOCK_FLAG_MAP =		(1 << 3),	/**< mmap the fd */
++	PW_MEMBLOCK_FLAG_DONT_CLOSE =	(1 << 4),	/**< don't close fd */
++	PW_MEMBLOCK_FLAG_DONT_NOTIFY =	(1 << 5),	/**< don't notify events */
++
++	PW_MEMBLOCK_FLAG_READWRITE = PW_MEMBLOCK_FLAG_READABLE | PW_MEMBLOCK_FLAG_WRITABLE,
++};
++
++enum pw_memmap_flags {
++	PW_MEMMAP_FLAG_NONE =		0,
++	PW_MEMMAP_FLAG_READ =		(1 << 0),	/**< map in read mode */
++	PW_MEMMAP_FLAG_WRITE =		(1 << 1),	/**< map in write mode */
++	PW_MEMMAP_FLAG_TWICE =		(1 << 2),	/**< map the same area twice after each other,
++							  *  creating a circular ringbuffer */
++	PW_MEMMAP_FLAG_PRIVATE =	(1 << 3),	/**< writes will be private */
++	PW_MEMMAP_FLAG_READWRITE = PW_MEMMAP_FLAG_READ | PW_MEMMAP_FLAG_WRITE,
++};
++
++struct pw_memchunk;
++
++/** \class pw_memblock
++ *
++ * A memory pool is a collection of pw_memblocks */
++struct pw_mempool {
++	struct pw_properties *props;
++};
++
++/** \class pw_memblock
++ * Memory block structure */
++struct pw_memblock {
++	struct pw_mempool *pool;	/**< owner pool */
++	uint32_t id;			/**< unique id */
++	int ref;			/**< refcount */
++	uint32_t flags;			/**< flags for the memory block on of enum pw_memblock_flags */
++	uint32_t type;			/**< type of the fd, one of enum spa_data_type */
++	int fd;				/**< fd */
++	uint32_t size;			/**< size of memory */
++	struct pw_memmap *map;		/**< optional map when PW_MEMBLOCK_FLAG_MAP was given */
++};
++
++/** a mapped region of a pw_memblock */
++struct pw_memmap {
++	struct pw_memblock *block;	/**< owner memblock */
++	void *ptr;			/**< mapped pointer */
++	uint32_t flags;			/**< flags for the mapping on of enum pw_memmap_flags */
++	uint32_t offset;		/**< offset in memblock */
++	uint32_t size;			/**< size in memblock */
++	uint32_t tag[5];		/**< user tag */
++};
++
++struct pw_mempool_events {
++#define PW_VERSION_MEMPOOL_EVENTS	0
++	uint32_t version;
++
++	/** the pool is destroyed */
++	void (*destroy) (void *data);
++
++	/** a new memory block is added to the pool */
++	void (*added) (void *data, struct pw_memblock *block);
++
++	/** a memory block is removed from the pool */
++	void (*removed) (void *data, struct pw_memblock *block);
++};
++
++/** Create a new memory pool */
++struct pw_mempool *pw_mempool_new(struct pw_properties *props);
++
++/** Listen for events */
++void pw_mempool_add_listener(struct pw_mempool *pool,
++                            struct spa_hook *listener,
++                            const struct pw_mempool_events *events,
++                            void *data);
++
++/** Clear a pool */
++void pw_mempool_clear(struct pw_mempool *pool);
++
++/** Clear and destroy a pool */
++void pw_mempool_destroy(struct pw_mempool *pool);
++
++
++/** Allocate a memory block from the pool */
++struct pw_memblock * pw_mempool_alloc(struct pw_mempool *pool,
++		enum pw_memblock_flags flags, uint32_t type, size_t size);
++
++/** Import a block from another pool */
++struct pw_memblock * pw_mempool_import_block(struct pw_mempool *pool,
++		struct pw_memblock *mem);
++
++/** Import an fd into the pool */
++struct pw_memblock * pw_mempool_import(struct pw_mempool *pool,
++		enum pw_memblock_flags flags, uint32_t type, int fd);
++
++/** Free a memblock regardless of the refcount and destroy all mappings */
++void pw_memblock_free(struct pw_memblock *mem);
++
++/** Unref a memblock */
++static inline void pw_memblock_unref(struct pw_memblock *mem)
++{
++	if (--mem->ref == 0)
++		pw_memblock_free(mem);
++}
++
++/** Remove a memblock for given \a id */
++int pw_mempool_remove_id(struct pw_mempool *pool, uint32_t id);
++
++/** Find memblock for given \a ptr */
++struct pw_memblock * pw_mempool_find_ptr(struct pw_mempool *pool, const void *ptr);
++
++/** Find memblock for given \a id */
++struct pw_memblock * pw_mempool_find_id(struct pw_mempool *pool, uint32_t id);
++
++/** Find memblock for given \a fd */
++struct pw_memblock * pw_mempool_find_fd(struct pw_mempool *pool, int fd);
++
++
++/** Map a region of a memory block */
++struct pw_memmap * pw_memblock_map(struct pw_memblock *block,
++		enum pw_memmap_flags flags, uint32_t offset, uint32_t size,
++		uint32_t tag[5]);
++
++/** Map a region of a memory block with \a id */
++struct pw_memmap * pw_mempool_map_id(struct pw_mempool *pool, uint32_t id,
++		enum pw_memmap_flags flags, uint32_t offset, uint32_t size,
++		uint32_t tag[5]);
++
++struct pw_memmap * pw_mempool_import_map(struct pw_mempool *pool,
++		struct pw_mempool *other, void *data, uint32_t size, uint32_t tag[5]);
++
++/** find a map with the given tag */
++struct pw_memmap * pw_mempool_find_tag(struct pw_mempool *pool, uint32_t tag[5], size_t size);
++
++/** Unmap a region */
++int pw_memmap_free(struct pw_memmap *map);
++
++
++/** parameters to map a memory range */
++struct pw_map_range {
++	uint32_t start;		/** offset in first page with start of data */
++	uint32_t offset;	/** page aligned offset to map */
++	uint32_t size;		/** size to map */
++};
++
++#define PW_MAP_RANGE_INIT (struct pw_map_range){ 0, }
++
++/** Calculate parameters to mmap() memory into \a range so that
++ * \a size bytes at \a offset can be mapped with mmap().  */
++static inline void pw_map_range_init(struct pw_map_range *range,
++				     uint32_t offset, uint32_t size,
++				     uint32_t page_size)
++{
++	range->offset = SPA_ROUND_DOWN_N(offset, page_size);
++	range->start = offset - range->offset;
++	range->size = SPA_ROUND_UP_N(range->start + size, page_size);
++}
++
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_MEM_H */
+diff --git a/third_party/pipewire/pipewire/module.h b/third_party/pipewire/pipewire/module.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/module.h
+@@ -0,0 +1,106 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_MODULE_H
++#define PIPEWIRE_MODULE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++#include <pipewire/proxy.h>
++
++#define PW_TYPE_INTERFACE_Module	PW_TYPE_INFO_INTERFACE_BASE "Module"
++
++#define PW_VERSION_MODULE		3
++struct pw_module;
++
++/** The module information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_module_info {
++	uint32_t id;		/**< id of the global */
++	const char *name;	/**< name of the module */
++	const char *filename;	/**< filename of the module */
++	const char *args;	/**< arguments passed to the module */
++#define PW_MODULE_CHANGE_MASK_PROPS	(1 << 0)
++#define PW_MODULE_CHANGE_MASK_ALL	((1 << 1)-1)
++	uint64_t change_mask;	/**< bitfield of changed fields since last call */
++	struct spa_dict *props;	/**< extra properties */
++};
++
++/** Update and existing \ref pw_module_info with \a update \memberof pw_introspect */
++struct pw_module_info *
++pw_module_info_update(struct pw_module_info *info,
++		      const struct pw_module_info *update);
++
++/** Free a \ref pw_module_info \memberof pw_introspect */
++void pw_module_info_free(struct pw_module_info *info);
++
++#define PW_MODULE_EVENT_INFO		0
++#define PW_MODULE_EVENT_NUM		1
++
++/** Module events */
++struct pw_module_events {
++#define PW_VERSION_MODULE_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify module info
++	 *
++	 * \param info info about the module
++	 */
++	void (*info) (void *object, const struct pw_module_info *info);
++};
++
++#define PW_MODULE_METHOD_ADD_LISTENER	0
++#define PW_MODULE_METHOD_NUM		1
++
++/** Module methods */
++struct pw_module_methods {
++#define PW_VERSION_MODULE_METHODS	0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_module_events *events,
++			void *data);
++};
++
++#define pw_module_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_module_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_module_add_listener(c,...)	pw_module_method(c,add_listener,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_MODULE_H */
+diff --git a/third_party/pipewire/pipewire/node.h b/third_party/pipewire/pipewire/node.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/node.h
+@@ -0,0 +1,200 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_NODE_H
++#define PIPEWIRE_NODE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++#include <errno.h>
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++#include <spa/node/command.h>
++#include <spa/param/param.h>
++
++#include <pipewire/proxy.h>
++
++#define PW_TYPE_INTERFACE_Node	PW_TYPE_INFO_INTERFACE_BASE "Node"
++
++#define PW_VERSION_NODE		3
++struct pw_node;
++
++/** \enum pw_node_state The different node states \memberof pw_node */
++enum pw_node_state {
++	PW_NODE_STATE_ERROR = -1,	/**< error state */
++	PW_NODE_STATE_CREATING = 0,	/**< the node is being created */
++	PW_NODE_STATE_SUSPENDED = 1,	/**< the node is suspended, the device might
++					 *   be closed */
++	PW_NODE_STATE_IDLE = 2,		/**< the node is running but there is no active
++					 *   port */
++	PW_NODE_STATE_RUNNING = 3,	/**< the node is running */
++};
++
++/** Convert a \ref pw_node_state to a readable string \memberof pw_node */
++const char * pw_node_state_as_string(enum pw_node_state state);
++
++/** The node information. Extra information can be added in later versions \memberof pw_introspect */
++struct pw_node_info {
++	uint32_t id;				/**< id of the global */
++	uint32_t max_input_ports;		/**< maximum number of inputs */
++	uint32_t max_output_ports;		/**< maximum number of outputs */
++#define PW_NODE_CHANGE_MASK_INPUT_PORTS		(1 << 0)
++#define PW_NODE_CHANGE_MASK_OUTPUT_PORTS	(1 << 1)
++#define PW_NODE_CHANGE_MASK_STATE		(1 << 2)
++#define PW_NODE_CHANGE_MASK_PROPS		(1 << 3)
++#define PW_NODE_CHANGE_MASK_PARAMS		(1 << 4)
++#define PW_NODE_CHANGE_MASK_ALL			((1 << 5)-1)
++	uint64_t change_mask;			/**< bitfield of changed fields since last call */
++	uint32_t n_input_ports;			/**< number of inputs */
++	uint32_t n_output_ports;		/**< number of outputs */
++	enum pw_node_state state;		/**< the current state of the node */
++	const char *error;			/**< an error reason if \a state is error */
++	struct spa_dict *props;			/**< the properties of the node */
++	struct spa_param_info *params;		/**< parameters */
++	uint32_t n_params;			/**< number of items in \a params */
++};
++
++struct pw_node_info *
++pw_node_info_update(struct pw_node_info *info,
++		    const struct pw_node_info *update);
++
++void
++pw_node_info_free(struct pw_node_info *info);
++
++#define PW_NODE_EVENT_INFO	0
++#define PW_NODE_EVENT_PARAM	1
++#define PW_NODE_EVENT_NUM	2
++
++/** Node events */
++struct pw_node_events {
++#define PW_VERSION_NODE_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify node info
++	 *
++	 * \param info info about the node
++	 */
++	void (*info) (void *object, const struct pw_node_info *info);
++	/**
++	 * Notify a node param
++	 *
++	 * Event emitted as a result of the enum_params method.
++	 *
++	 * \param seq the sequence number of the request
++	 * \param id the param id
++	 * \param index the param index
++	 * \param next the param index of the next param
++	 * \param param the parameter
++	 */
++	void (*param) (void *object, int seq,
++		      uint32_t id, uint32_t index, uint32_t next,
++		      const struct spa_pod *param);
++};
++
++#define PW_NODE_METHOD_ADD_LISTENER	0
++#define PW_NODE_METHOD_SUBSCRIBE_PARAMS	1
++#define PW_NODE_METHOD_ENUM_PARAMS	2
++#define PW_NODE_METHOD_SET_PARAM	3
++#define PW_NODE_METHOD_SEND_COMMAND	4
++#define PW_NODE_METHOD_NUM		5
++
++/** Node methods */
++struct pw_node_methods {
++#define PW_VERSION_NODE_METHODS		0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_node_events *events,
++			void *data);
++	/**
++	 * Subscribe to parameter changes
++	 *
++	 * Automatically emit param events for the given ids when
++	 * they are changed.
++	 *
++	 * \param ids an array of param ids
++	 * \param n_ids the number of ids in \a ids
++	 */
++	int (*subscribe_params) (void *object, uint32_t *ids, uint32_t n_ids);
++
++	/**
++	 * Enumerate node parameters
++	 *
++	 * Start enumeration of node parameters. For each param, a
++	 * param event will be emitted.
++	 *
++	 * \param seq a sequence number to place in the reply
++	 * \param id the parameter id to enum or PW_ID_ANY for all
++	 * \param start the start index or 0 for the first param
++	 * \param num the maximum number of params to retrieve
++	 * \param filter a param filter or NULL
++	 */
++	int (*enum_params) (void *object, int seq, uint32_t id,
++			uint32_t start, uint32_t num,
++			const struct spa_pod *filter);
++
++	/**
++	 * Set a parameter on the node
++	 *
++	 * \param id the parameter id to set
++	 * \param flags extra parameter flags
++	 * \param param the parameter to set
++	 */
++	int (*set_param) (void *object, uint32_t id, uint32_t flags,
++			const struct spa_pod *param);
++
++	/**
++	 * Send a command to the node
++	 *
++	 * \param command the command to send
++	 */
++	int (*send_command) (void *object, const struct spa_command *command);
++};
++
++#define pw_node_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_node_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++/** Node */
++#define pw_node_add_listener(c,...)	pw_node_method(c,add_listener,0,__VA_ARGS__)
++#define pw_node_subscribe_params(c,...)	pw_node_method(c,subscribe_params,0,__VA_ARGS__)
++#define pw_node_enum_params(c,...)	pw_node_method(c,enum_params,0,__VA_ARGS__)
++#define pw_node_set_param(c,...)	pw_node_method(c,set_param,0,__VA_ARGS__)
++#define pw_node_send_command(c,...)	pw_node_method(c,send_command,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_NODE_H */
+diff --git a/third_party/pipewire/pipewire/permission.h b/third_party/pipewire/pipewire/permission.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/permission.h
+@@ -0,0 +1,79 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_PERMISSION_H
++#define PIPEWIRE_PERMISSION_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++
++/** \class pw_permission
++ *
++ * \brief a PipeWire permission
++ *
++ * Permissions are kept for a client and describe what the client is
++ * allowed to do with an object.
++ *
++ * See \ref page_core_api
++ */
++
++#define PW_PERM_R	0400	/**< object can be seen and events can be received */
++#define PW_PERM_W	0200	/**< methods can be called that modify the object */
++#define PW_PERM_X	0100	/**< methods can be called on the object. The W flag must be
++				  *  present in order to call methods that modify the object. */
++#define PW_PERM_M	0010	/**< metadata can be set on object, Since 0.3.9 */
++
++#define PW_PERM_RWX	(PW_PERM_R|PW_PERM_W|PW_PERM_X)
++#define PW_PERM_RWXM	(PW_PERM_RWX|PW_PERM_M)
++
++#define PW_PERM_IS_R(p) (((p)&PW_PERM_R) == PW_PERM_R)
++#define PW_PERM_IS_W(p) (((p)&PW_PERM_W) == PW_PERM_W)
++#define PW_PERM_IS_X(p) (((p)&PW_PERM_X) == PW_PERM_X)
++#define PW_PERM_IS_M(p) (((p)&PW_PERM_M) == PW_PERM_M)
++
++#define PW_PERM_ALL	PW_PERM_RWXM
++#define PW_PERM_INVALID	(uint32_t)(0xffffffff)
++
++struct pw_permission {
++	uint32_t id;		/**< id of object, PW_ID_ANY for default permission */
++	uint32_t permissions;	/**< bitmask of above permissions */
++};
++
++#define PW_PERMISSION_INIT(id,p) (struct pw_permission){ (id), (p) }
++
++#define PW_PERMISSION_FORMAT "%c%c%c%c"
++#define PW_PERMISSION_ARGS(permission)		\
++	(permission) & PW_PERM_R ? 'r' : '-',	\
++	(permission) & PW_PERM_W ? 'w' : '-',	\
++	(permission) & PW_PERM_X ? 'x' : '-',	\
++	(permission) & PW_PERM_M ? 'm' : '-'
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_PERMISSION_H */
+diff --git a/third_party/pipewire/pipewire/pipewire.h b/third_party/pipewire/pipewire/pipewire.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/pipewire.h
+@@ -0,0 +1,158 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_H
++#define PIPEWIRE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/support/plugin.h>
++
++#include <pipewire/array.h>
++#include <pipewire/client.h>
++#include <pipewire/context.h>
++#include <pipewire/device.h>
++#include <pipewire/buffers.h>
++#include <pipewire/core.h>
++#include <pipewire/factory.h>
++#include <pipewire/keys.h>
++#include <pipewire/log.h>
++#include <pipewire/loop.h>
++#include <pipewire/link.h>
++#include <pipewire/main-loop.h>
++#include <pipewire/map.h>
++#include <pipewire/mem.h>
++#include <pipewire/module.h>
++#include <pipewire/node.h>
++#include <pipewire/properties.h>
++#include <pipewire/proxy.h>
++#include <pipewire/permission.h>
++#include <pipewire/protocol.h>
++#include <pipewire/port.h>
++#include <pipewire/stream.h>
++#include <pipewire/filter.h>
++#include <pipewire/thread-loop.h>
++#include <pipewire/data-loop.h>
++#include <pipewire/type.h>
++#include <pipewire/utils.h>
++#include <pipewire/version.h>
++
++/** \mainpage
++ *
++ * \section sec_intro Introduction
++ *
++ * This document describes the API for the PipeWire multimedia framework.
++ * The API consists of two parts:
++ *
++ * \li The core API to access a PipeWire instance.
++ * (See \subpage page_core_api)
++ * \li The implementation API and tools to build new objects and
++ * modules (See \subpage page_implementation_api)
++ *
++ * \section sec_errors Error reporting
++ *
++ * Functions return either NULL with errno set or a negative int error
++ * code when an error occurs. Error codes are used from the SPA plugin
++ * library on which PipeWire is built.
++ *
++ * Some functions might return asynchronously. The error code for such
++ * functions is positive and SPA_RESULT_IS_ASYNC() will return true.
++ * SPA_RESULT_ASYNC_SEQ() can be used to get the unique sequence number
++ * associated with the async operation.
++ *
++ * The object returning the async result code will have some way to
++ * signal the completion of the async operation (with, for example, a
++ * callback). The sequence number can be used to see which operation
++ * completed.
++ *
++ * \section sec_logging Logging
++ *
++ * The 'PIPEWIRE_DEBUG' environment variable can be used to enable
++ * more debugging. The format is:
++ *
++ *    &lt;level&gt;[:&lt;category&gt;,...]
++ *
++ * - &lt;level&gt;: specifies the log level:
++ *   + `0`: no logging is enabled
++ *   + `1`: Error logging is enabled
++ *   + `2`: Warnings are enabled
++ *   + `3`: Informational messages are enabled
++ *   + `4`: Debug messages are enabled
++ *   + `5`: Trace messages are enabled. These messages can be logged
++ *		from the realtime threads.
++ *
++ * - &lt;category&gt;:  Specifies a string category to enable. Many categories
++ *		  can be separated by commas. Current categories are:
++ *   + `connection`: to log connection messages
++ */
++
++/** \class pw_pipewire
++ *
++ * \brief PipeWire initialization and infrastructure functions
++ */
++void
++pw_init(int *argc, char **argv[]);
++
++void pw_deinit(void);
++
++bool
++pw_debug_is_category_enabled(const char *name);
++
++const char *
++pw_get_application_name(void);
++
++const char *
++pw_get_prgname(void);
++
++const char *
++pw_get_user_name(void);
++
++const char *
++pw_get_host_name(void);
++
++const char *
++pw_get_client_name(void);
++
++bool pw_in_valgrind(void);
++
++enum pw_direction
++pw_direction_reverse(enum pw_direction direction);
++
++uint32_t pw_get_support(struct spa_support *support, uint32_t max_support);
++
++struct spa_handle *pw_load_spa_handle(const char *lib,
++		const char *factory_name,
++		const struct spa_dict *info,
++		uint32_t n_support,
++		const struct spa_support support[]);
++
++int pw_unload_spa_handle(struct spa_handle *handle);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_H */
+diff --git a/third_party/pipewire/pipewire/port.h b/third_party/pipewire/pipewire/port.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/port.h
+@@ -0,0 +1,169 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_PORT_H
++#define PIPEWIRE_PORT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++#include <errno.h>
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++#include <spa/param/param.h>
++
++#include <pipewire/proxy.h>
++
++#define PW_TYPE_INTERFACE_Port	PW_TYPE_INFO_INTERFACE_BASE "Port"
++
++#define PW_VERSION_PORT		3
++struct pw_port;
++
++/** \enum pw_direction The direction of a port \memberof pw_introspect */
++#define pw_direction spa_direction
++#define PW_DIRECTION_INPUT SPA_DIRECTION_INPUT
++#define PW_DIRECTION_OUTPUT SPA_DIRECTION_OUTPUT
++
++/** Convert a \ref pw_direction to a readable string \memberof pw_introspect */
++const char * pw_direction_as_string(enum pw_direction direction);
++
++
++/** \class pw_introspect
++ *
++ * The introspection methods and structures are used to get information
++ * about the object in the PipeWire server
++ */
++
++struct pw_port_info {
++	uint32_t id;				/**< id of the global */
++	enum pw_direction direction;		/**< port direction */
++#define PW_PORT_CHANGE_MASK_PROPS		(1 << 0)
++#define PW_PORT_CHANGE_MASK_PARAMS		(1 << 1)
++#define PW_PORT_CHANGE_MASK_ALL			((1 << 2)-1)
++	uint64_t change_mask;			/**< bitfield of changed fields since last call */
++	struct spa_dict *props;			/**< the properties of the port */
++	struct spa_param_info *params;		/**< parameters */
++	uint32_t n_params;			/**< number of items in \a params */
++};
++
++struct pw_port_info *
++pw_port_info_update(struct pw_port_info *info,
++		    const struct pw_port_info *update);
++
++void
++pw_port_info_free(struct pw_port_info *info);
++
++#define PW_PORT_EVENT_INFO	0
++#define PW_PORT_EVENT_PARAM	1
++#define PW_PORT_EVENT_NUM	2
++
++/** Port events */
++struct pw_port_events {
++#define PW_VERSION_PORT_EVENTS	0
++	uint32_t version;
++	/**
++	 * Notify port info
++	 *
++	 * \param info info about the port
++	 */
++	void (*info) (void *object, const struct pw_port_info *info);
++	/**
++	 * Notify a port param
++	 *
++	 * Event emitted as a result of the enum_params method.
++	 *
++	 * \param seq the sequence number of the request
++	 * \param id the param id
++	 * \param index the param index
++	 * \param next the param index of the next param
++	 * \param param the parameter
++	 */
++	void (*param) (void *object, int seq,
++		       uint32_t id, uint32_t index, uint32_t next,
++		       const struct spa_pod *param);
++};
++
++#define PW_PORT_METHOD_ADD_LISTENER	0
++#define PW_PORT_METHOD_SUBSCRIBE_PARAMS	1
++#define PW_PORT_METHOD_ENUM_PARAMS	2
++#define PW_PORT_METHOD_NUM		3
++
++/** Port methods */
++struct pw_port_methods {
++#define PW_VERSION_PORT_METHODS		0
++	uint32_t version;
++
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct pw_port_events *events,
++			void *data);
++	/**
++	 * Subscribe to parameter changes
++	 *
++	 * Automatically emit param events for the given ids when
++	 * they are changed.
++	 *
++	 * \param ids an array of param ids
++	 * \param n_ids the number of ids in \a ids
++	 */
++	int (*subscribe_params) (void *object, uint32_t *ids, uint32_t n_ids);
++
++	/**
++	 * Enumerate port parameters
++	 *
++	 * Start enumeration of port parameters. For each param, a
++	 * param event will be emitted.
++	 *
++	 * \param seq a sequence number returned in the reply
++	 * \param id the parameter id to enumerate
++	 * \param start the start index or 0 for the first param
++	 * \param num the maximum number of params to retrieve
++	 * \param filter a param filter or NULL
++	 */
++	int (*enum_params) (void *object, int seq,
++			uint32_t id, uint32_t start, uint32_t num,
++			const struct spa_pod *filter);
++};
++
++#define pw_port_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)o,		\
++			struct pw_port_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define pw_port_add_listener(c,...)	pw_port_method(c,add_listener,0,__VA_ARGS__)
++#define pw_port_subscribe_params(c,...)	pw_port_method(c,subscribe_params,0,__VA_ARGS__)
++#define pw_port_enum_params(c,...)	pw_port_method(c,enum_params,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_PORT_H */
+diff --git a/third_party/pipewire/pipewire/properties.h b/third_party/pipewire/pipewire/properties.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/properties.h
+@@ -0,0 +1,121 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_PROPERTIES_H
++#define PIPEWIRE_PROPERTIES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++	
++#include <spa/utils/dict.h>
++
++/** \class pw_properties
++ *
++ * \brief A collection of key/value pairs
++ *
++ * Properties are used to pass around arbitrary key/value pairs.
++ * Both keys and values are strings which keeps things simple.
++ * Encoding of arbitrary values should be done by using a string
++ * serialization such as base64 for binary blobs.
++ */
++struct pw_properties {
++	struct spa_dict dict;	/**< dictionary of key/values */
++	uint32_t flags;		/**< extra flags */
++};
++
++struct pw_properties *
++pw_properties_new(const char *key, ...) SPA_SENTINEL;
++
++struct pw_properties *
++pw_properties_new_dict(const struct spa_dict *dict);
++
++struct pw_properties *
++pw_properties_new_string(const char *args);
++
++struct pw_properties *
++pw_properties_copy(const struct pw_properties *properties);
++
++int pw_properties_update_keys(struct pw_properties *props,
++		     const struct spa_dict *dict, const char *keys[]);
++
++int pw_properties_update(struct pw_properties *oldprops,
++		     const struct spa_dict *dict);
++
++int pw_properties_add(struct pw_properties *oldprops,
++		     const struct spa_dict *dict);
++int pw_properties_add_keys(struct pw_properties *oldprops,
++		     const struct spa_dict *dict, const char *keys[]);
++
++void pw_properties_clear(struct pw_properties *properties);
++
++void
++pw_properties_free(struct pw_properties *properties);
++
++int
++pw_properties_set(struct pw_properties *properties, const char *key, const char *value);
++
++int
++pw_properties_setf(struct pw_properties *properties,
++		   const char *key, const char *format, ...) SPA_PRINTF_FUNC(3, 4);
++int
++pw_properties_setva(struct pw_properties *properties,
++		   const char *key, const char *format, va_list args) SPA_PRINTF_FUNC(3,0);
++const char *
++pw_properties_get(const struct pw_properties *properties, const char *key);
++
++const char *
++pw_properties_iterate(const struct pw_properties *properties, void **state);
++
++static inline bool pw_properties_parse_bool(const char *value) {
++	return (strcmp(value, "true") == 0 || atoi(value) == 1);
++}
++
++static inline int pw_properties_parse_int(const char *value) {
++	return strtol(value, NULL, 0);
++}
++
++static inline int64_t pw_properties_parse_int64(const char *value) {
++	return strtoll(value, NULL, 0);
++}
++
++static inline uint64_t pw_properties_parse_uint64(const char *value) {
++	return strtoull(value, NULL, 0);
++}
++
++static inline float pw_properties_parse_float(const char *value) {
++	return strtof(value, NULL);
++}
++
++static inline double pw_properties_parse_double(const char *value) {
++	return strtod(value, NULL);
++}
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_PROPERTIES_H */
+diff --git a/third_party/pipewire/pipewire/protocol.h b/third_party/pipewire/pipewire/protocol.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/protocol.h
+@@ -0,0 +1,152 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_PROTOCOL_H
++#define PIPEWIRE_PROTOCOL_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/list.h>
++
++struct pw_protocol;
++
++#include <pipewire/context.h>
++#include <pipewire/properties.h>
++#include <pipewire/utils.h>
++
++#define PW_TYPE_INFO_Protocol		"PipeWire:Protocol"
++#define PW_TYPE_INFO_PROTOCOL_BASE	PW_TYPE_INFO_Protocol ":"
++
++struct pw_protocol_client {
++	struct spa_list link;		/**< link in protocol client_list */
++	struct pw_protocol *protocol;	/**< the owner protocol */
++
++	struct pw_core *core;
++
++	int (*connect) (struct pw_protocol_client *client,
++			const struct spa_dict *props,
++			void (*done_callback) (void *data, int result),
++			void *data);
++	int (*connect_fd) (struct pw_protocol_client *client, int fd, bool close);
++	int (*steal_fd) (struct pw_protocol_client *client);
++	void (*disconnect) (struct pw_protocol_client *client);
++	void (*destroy) (struct pw_protocol_client *client);
++	int (*set_paused) (struct pw_protocol_client *client, bool paused);
++};
++
++#define pw_protocol_client_connect(c,p,cb,d)	((c)->connect(c,p,cb,d))
++#define pw_protocol_client_connect_fd(c,fd,cl)	((c)->connect_fd(c,fd,cl))
++#define pw_protocol_client_steal_fd(c)		((c)->steal_fd(c))
++#define pw_protocol_client_disconnect(c)	((c)->disconnect(c))
++#define pw_protocol_client_destroy(c)		((c)->destroy(c))
++#define pw_protocol_client_set_paused(c,p)	((c)->set_paused(c,p))
++
++struct pw_protocol_server {
++	struct spa_list link;		/**< link in protocol server_list */
++	struct pw_protocol *protocol;	/**< the owner protocol */
++
++	struct pw_impl_core *core;
++
++	struct spa_list client_list;	/**< list of clients of this protocol */
++
++	void (*destroy) (struct pw_protocol_server *listen);
++};
++
++#define pw_protocol_server_destroy(l)	((l)->destroy(l))
++
++struct pw_protocol_marshal {
++	const char *type;		/**< interface type */
++	uint32_t version;		/**< version */
++#define PW_PROTOCOL_MARSHAL_FLAG_IMPL	(1 << 0)	/**< marshal for implementations */
++	uint32_t flags;			/**< version */
++	uint32_t n_client_methods;	/**< number of client methods */
++	uint32_t n_server_methods;	/**< number of server methods */
++	const void *client_marshal;
++	const void *server_demarshal;
++	const void *server_marshal;
++	const void *client_demarshal;
++};
++
++struct pw_protocol_implementaton {
++#define PW_VERSION_PROTOCOL_IMPLEMENTATION	0
++	uint32_t version;
++
++	struct pw_protocol_client * (*new_client) (struct pw_protocol *protocol,
++						   struct pw_core *core,
++						   const struct spa_dict *props);
++	struct pw_protocol_server * (*add_server) (struct pw_protocol *protocol,
++						   struct pw_impl_core *core,
++						   const struct spa_dict *props);
++};
++
++struct pw_protocol_events {
++#define PW_VERSION_PROTOCOL_EVENTS		0
++	uint32_t version;
++
++	void (*destroy) (void *data);
++};
++
++#define pw_protocol_new_client(p,...)	(pw_protocol_get_implementation(p)->new_client(p,__VA_ARGS__))
++#define pw_protocol_add_server(p,...)	(pw_protocol_get_implementation(p)->add_server(p,__VA_ARGS__))
++#define pw_protocol_ext(p,type,method,...)	(((type*)pw_protocol_get_extension(p))->method( __VA_ARGS__))
++
++struct pw_protocol *pw_protocol_new(struct pw_context *context, const char *name, size_t user_data_size);
++
++void pw_protocol_destroy(struct pw_protocol *protocol);
++
++struct pw_context *pw_protocol_get_context(struct pw_protocol *protocol);
++
++void *pw_protocol_get_user_data(struct pw_protocol *protocol);
++
++const struct pw_protocol_implementaton *
++pw_protocol_get_implementation(struct pw_protocol *protocol);
++
++const void *
++pw_protocol_get_extension(struct pw_protocol *protocol);
++
++
++void pw_protocol_add_listener(struct pw_protocol *protocol,
++                              struct spa_hook *listener,
++                              const struct pw_protocol_events *events,
++                              void *data);
++
++/** \class pw_protocol
++ *
++ * \brief Manages protocols and their implementation
++ */
++int pw_protocol_add_marshal(struct pw_protocol *protocol,
++			    const struct pw_protocol_marshal *marshal);
++
++const struct pw_protocol_marshal *
++pw_protocol_get_marshal(struct pw_protocol *protocol, const char *type, uint32_t version, uint32_t flags);
++
++struct pw_protocol * pw_context_find_protocol(struct pw_context *context, const char *name);
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_PROTOCOL_H */
+diff --git a/third_party/pipewire/pipewire/proxy.h b/third_party/pipewire/pipewire/proxy.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/proxy.h
+@@ -0,0 +1,207 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_PROXY_H
++#define PIPEWIRE_PROXY_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++/** \page page_proxy Proxy
++ *
++ * \section sec_page_proxy_overview Overview
++ *
++ * The proxy object is a client side representation of a resource
++ * that lives on a remote PipeWire instance.
++ *
++ * It is used to communicate with the remote object.
++ *
++ * \section sec_page_proxy_core Core proxy
++ *
++ * A proxy for a remote core object can be obtained by making
++ * a remote connection with \ref pw_core_connect.
++ * See \ref pw_page_remote_api
++ *
++ * Some methods on proxy object allow creation of more proxy objects or
++ * create a binding between a local proxy and global resource.
++ *
++ * \section sec_page_proxy_create Create
++ *
++ * A client first creates a new proxy object with pw_proxy_new(). A
++ * type must be provided for this object.
++ *
++ * The protocol of the context will usually install an interface to
++ * translate method calls and events to the wire format.
++ *
++ * The creator of the proxy will usually also install an event
++ * implementation of the particular object type.
++ *
++ * \section sec_page_proxy_bind Bind
++ *
++ * To actually use the proxy object, one needs to create a server
++ * side resource for it. This can be done by, for example, binding
++ * to a global object or by calling a method that creates and binds
++ * to a new remote object. In all cases, the local id is passed to
++ * the server and is used to create a resource with the same id.
++ *
++ * \section sec_page_proxy_methods Methods
++ *
++ * To call a method on the proxy use the interface methods. Calling
++ * any interface method will result in a request to the server to
++ * perform the requested action on the corresponding resource.
++ *
++ * \section sec_page_proxy_events Events
++ *
++ * Events send from the server to the proxy will be demarshalled by
++ * the protocol and will then result in a call to the installed
++ * implementation of the proxy.
++ *
++ * \section sec_page_proxy_destroy Destroy
++ *
++ * Use pw_proxy_destroy() to destroy the client side object. This
++ * is usually done automatically when the server removes the resource
++ * associated to the proxy.
++ */
++
++/** \class pw_proxy
++ *
++ * \brief Represents an object on the client side.
++ *
++ * A pw_proxy acts as a client side proxy to an object existing in a remote
++ * pipewire instance. The proxy is responsible for converting interface functions
++ * invoked by the client to PipeWire messages. Events will call the handlers
++ * set in listener.
++ *
++ * See \ref page_proxy
++ */
++struct pw_proxy;
++
++#include <pipewire/protocol.h>
++
++/** Proxy events, use \ref pw_proxy_add_listener */
++struct pw_proxy_events {
++#define PW_VERSION_PROXY_EVENTS		0
++        uint32_t version;
++
++	/** The proxy is destroyed */
++        void (*destroy) (void *data);
++
++	/** a proxy is bound to a global id */
++        void (*bound) (void *data, uint32_t global_id);
++
++	/** a proxy is removed from the server. Use pw_proxy_destroy to
++	 * free the proxy. */
++        void (*removed) (void *data);
++
++	/** a reply to a sync method completed */
++        void (*done) (void *data, int seq);
++
++	/** an error occurred on the proxy */
++        void (*error) (void *data, int seq, int res, const char *message);
++};
++
++/** Make a new proxy object. The id can be used to bind to a remote object and
++  * can be retrieved with \ref pw_proxy_get_id . */
++struct pw_proxy *
++pw_proxy_new(struct pw_proxy *factory,	/**< factory */
++	     const char *type,		/**< interface type */
++	     uint32_t version,		/**< interface version */
++	     size_t user_data_size	/**< size of user data */);
++
++/** Add an event listener to proxy */
++void pw_proxy_add_listener(struct pw_proxy *proxy,
++			   struct spa_hook *listener,
++			   const struct pw_proxy_events *events,
++			   void *data);
++
++/** Add a listener for the events received from the remote object. The
++  * events depend on the type of the remote object type. */
++void pw_proxy_add_object_listener(struct pw_proxy *proxy,	/**< the proxy */
++				 struct spa_hook *listener,	/**< listener */
++				 const void *funcs,		/**< proxied functions */
++				 void *data			/**< data passed to events */);
++
++/** destroy a proxy */
++void pw_proxy_destroy(struct pw_proxy *proxy);
++
++/** Get the user_data. The size was given in \ref pw_proxy_new */
++void *pw_proxy_get_user_data(struct pw_proxy *proxy);
++
++/** Get the local id of the proxy */
++uint32_t pw_proxy_get_id(struct pw_proxy *proxy);
++
++/** Get the type and version of the proxy */
++const char *pw_proxy_get_type(struct pw_proxy *proxy, uint32_t *version);
++
++/** Get the protocol used for the proxy */
++struct pw_protocol *pw_proxy_get_protocol(struct pw_proxy *proxy);
++
++/** Generate an sync method for a proxy. This will generate a done event
++ * with the same seq number of the reply. */
++int pw_proxy_sync(struct pw_proxy *proxy, int seq);
++
++/** Set the global id this proxy is bound to. This is usually used internally
++ * and will also emit the bound event */
++int pw_proxy_set_bound_id(struct pw_proxy *proxy, uint32_t global_id);
++/** Get the global id bound to this proxy of SPA_ID_INVALID when not bound
++ * to a global */
++uint32_t pw_proxy_get_bound_id(struct pw_proxy *proxy);
++
++/** Generate an error for a proxy */
++int pw_proxy_error(struct pw_proxy *proxy, int res, const char *error);
++int pw_proxy_errorf(struct pw_proxy *proxy, int res, const char *error, ...) SPA_PRINTF_FUNC(3, 4);
++
++/** Get the listener of proxy */
++struct spa_hook_list *pw_proxy_get_object_listeners(struct pw_proxy *proxy);
++
++/** Get the marshal functions for the proxy */
++const struct pw_protocol_marshal *pw_proxy_get_marshal(struct pw_proxy *proxy);
++
++/** Install a marshal function on a proxy */
++int pw_proxy_install_marshal(struct pw_proxy *proxy, bool implementor);
++
++#define pw_proxy_notify(p,type,event,version,...)			\
++	spa_hook_list_call(pw_proxy_get_object_listeners(p),		\
++			type, event, version, ## __VA_ARGS__)
++
++#define pw_proxy_call(p,type,method,version,...)			\
++	spa_interface_call((struct spa_interface*)p,			\
++			type, method, version, ##__VA_ARGS__)
++
++#define pw_proxy_call_res(p,type,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)p,		\
++			type, _res, method, version, ##__VA_ARGS__);	\
++	_res;								\
++})
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_PROXY_H */
+diff --git a/third_party/pipewire/pipewire/resource.h b/third_party/pipewire/pipewire/resource.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/resource.h
+@@ -0,0 +1,168 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_RESOURCE_H
++#define PIPEWIRE_RESOURCE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/hook.h>
++
++/** \page page_resource Resource
++ *
++ * \section sec_page_resource Overview
++ *
++ * Resources represent objects owned by a \ref pw_impl_client. They are
++ * the result of binding to a global resource or by calling API that
++ * creates client owned objects.
++ *
++ * The client usually has a proxy object associated with the resource
++ * that it can use to communicate with the resource. See \ref page_proxy.
++ *
++ * Resources are destroyed when the client or the bound object is
++ * destroyed.
++ *
++ */
++
++/** \class pw_resource
++ *
++ * \brief Client owned objects
++ *
++ * Resources are objects owned by a client and are destroyed when the
++ * client disappears.
++ *
++ * See also \ref page_resource
++ */
++struct pw_resource;
++
++#include <pipewire/impl-client.h>
++
++/** Resource events */
++struct pw_resource_events {
++#define PW_VERSION_RESOURCE_EVENTS	0
++	uint32_t version;
++
++	/** The resource is destroyed */
++	void (*destroy) (void *data);
++
++	/** a reply to a ping event completed */
++        void (*pong) (void *data, int seq);
++
++	/** an error occurred on the resource */
++        void (*error) (void *data, int seq, int res, const char *message);
++};
++
++/** Make a new resource for client */
++struct pw_resource *
++pw_resource_new(struct pw_impl_client *client,	/**< the client owning the resource */
++		uint32_t id,			/**< the remote per client id */
++		uint32_t permissions,		/**< permissions on this resource */
++		const char *type,		/**< interface of the resource */
++		uint32_t version,		/**< requested interface version */
++		size_t user_data_size		/**< extra user data size */);
++
++/** Destroy a resource */
++void pw_resource_destroy(struct pw_resource *resource);
++
++/** Remove a resource, like pw_resource_destroy but without sending a
++ * remove_id message to the client */
++void pw_resource_remove(struct pw_resource *resource);
++
++/** Get the client owning this resource */
++struct pw_impl_client *pw_resource_get_client(struct pw_resource *resource);
++
++/** Get the unique id of this resource */
++uint32_t pw_resource_get_id(struct pw_resource *resource);
++
++/** Get the permissions of this resource */
++uint32_t pw_resource_get_permissions(struct pw_resource *resource);
++
++/** Get the type and optionally the version of this resource */
++const char *pw_resource_get_type(struct pw_resource *resource, uint32_t *version);
++
++/** Get the protocol used for this resource */
++struct pw_protocol *pw_resource_get_protocol(struct pw_resource *resource);
++
++/** Get the user data for the resource, the size was given in \ref pw_resource_new */
++void *pw_resource_get_user_data(struct pw_resource *resource);
++
++/** Add an event listener */
++void pw_resource_add_listener(struct pw_resource *resource,
++			      struct spa_hook *listener,
++			      const struct pw_resource_events *events,
++			      void *data);
++
++/** Set the resource implementation. */
++void pw_resource_add_object_listener(struct pw_resource *resource,
++				struct spa_hook *listener,
++				const void *funcs,
++				void *data);
++
++/** Generate an ping event for a resource. This will generate a pong event
++ * with the same \a sequence number in the return value. */
++int pw_resource_ping(struct pw_resource *resource, int seq);
++
++/** Notify global id this resource is bound to */
++int pw_resource_set_bound_id(struct pw_resource *resource, uint32_t global_id);
++
++/** Get the global id this resource is bound to or SPA_ID_INVALID when not bound */
++uint32_t pw_resource_get_bound_id(struct pw_resource *resource);
++
++/** Generate an error for a resource */
++void pw_resource_error(struct pw_resource *resource, int res, const char *error);
++void pw_resource_errorf(struct pw_resource *resource, int res, const char *error, ...) SPA_PRINTF_FUNC(3, 4);
++void pw_resource_errorf_id(struct pw_resource *resource, uint32_t id, int res, const char *error, ...) SPA_PRINTF_FUNC(4, 5);
++
++/** Get the list of object listeners from a resource */
++struct spa_hook_list *pw_resource_get_object_listeners(struct pw_resource *resource);
++
++/** Get the marshal functions for the resource */
++const struct pw_protocol_marshal *pw_resource_get_marshal(struct pw_resource *resource);
++
++/** install a marshal function on a resource */
++int pw_resource_install_marshal(struct pw_resource *resource, bool implementor);
++
++#define pw_resource_notify(r,type,event,version,...)			\
++	spa_hook_list_call(pw_resource_get_object_listeners(r),		\
++			type, event, version, ## __VA_ARGS__)
++
++#define pw_resource_call(r,type,method,version,...)			\
++	spa_interface_call((struct spa_interface*)r,			\
++			type, method, version, ##__VA_ARGS__)
++
++#define pw_resource_call_res(r,type,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	spa_interface_call_res((struct spa_interface*)r,		\
++			type, _res, method, version, ##__VA_ARGS__);	\
++	_res;								\
++})
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_RESOURCE_H */
+diff --git a/third_party/pipewire/pipewire/stream.h b/third_party/pipewire/pipewire/stream.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/stream.h
+@@ -0,0 +1,358 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_STREAM_H
++#define PIPEWIRE_STREAM_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \page page_streams Media Streams
++ *
++ * \section sec_overview Overview
++ *
++ * Media streams are used to exchange data with the PipeWire server. A
++ * stream is a wrapper around a proxy for a \ref pw_client_node with
++ * an adapter. This means the stream will automatically do conversion
++ * to the type required by the server.
++ *
++ * Streams can be used to:
++ *
++ * \li Consume a stream from PipeWire. This is a PW_DIRECTION_INPUT stream.
++ * \li Produce a stream to PipeWire. This is a PW_DIRECTION_OUTPUT stream
++ *
++ * You can connect the stream port to a specific server port or let PipeWire
++ * choose a port for you.
++ *
++ * For more complicated nodes such as filters or ports with multiple
++ * inputs and/or outputs you will need to use the pw_filter or make
++ * a pw_node yourself and export it with \ref pw_core_export.
++ *
++ * \section sec_create Create
++ *
++ * Make a new stream with \ref pw_stream_new(). You will need to specify
++ * a name for the stream and extra properties. You can use \ref
++ * pw_fill_stream_properties() to get a basic set of properties for the
++ * stream.
++ *
++ * Once the stream is created, the state_changed event should be used to
++ * track the state of the stream.
++ *
++ * \section sec_connect Connect
++ *
++ * The stream is initially unconnected. To connect the stream, use
++ * \ref pw_stream_connect(). Pass the desired direction as an argument.
++ *
++ * \subsection ssec_stream_target Stream target
++ *
++ * To make the newly connected stream automatically connect to an existing
++ * PipeWire node, use the \ref PW_STREAM_FLAG_AUTOCONNECT and the port_path
++ * argument while connecting.
++ *
++ * \subsection ssec_stream_formats Stream formats
++ *
++ * An array of possible formats that this stream can consume or provide
++ * must be specified.
++ *
++ * \section sec_format Format negotiation
++ *
++ * After connecting the stream, the server will want to configure some
++ * parameters on the stream. You will be notified of these changes
++ * with the param_changed event.
++ *
++ * When a format param change is emitted, the client should now prepare
++ * itself to deal with the format and complete the negotiation procedure
++ * with a call to \ref pw_stream_update_params().
++ *
++ * As arguments to \ref pw_stream_update_params() an array of spa_param
++ * structures must be given. They contain parameters such as buffer size,
++ * number of buffers, required metadata and other parameters for the
++ * media buffers.
++ *
++ * \section sec_buffers Buffer negotiation
++ *
++ * After completing the format negotiation, PipeWire will allocate and
++ * notify the stream of the buffers that will be used to exchange data
++ * between client and server.
++ *
++ * With the add_buffer event, a stream will be notified of a new buffer
++ * that can be used for data transport. You can attach user_data to these
++ * buffers.
++ *
++ * After the buffers are negotiated, the stream will transition to the
++ * \ref PW_STREAM_STATE_PAUSED state.
++ *
++ * \section sec_streaming Streaming
++ *
++ * From the \ref PW_STREAM_STATE_PAUSED state, the stream can be set to
++ * the \ref PW_STREAM_STATE_STREAMING state by the PipeWire server when
++ * data transport is started.
++ *
++ * Depending on how the stream was connected it will need to Produce or
++ * Consume data for/from PipeWire as explained in the following
++ * subsections.
++ *
++ * \subsection ssec_consume Consume data
++ *
++ * The process event is emitted for each new buffer that can can be
++ * consumed.
++ *
++ * \ref pw_stream_dequeue_buffer() should be used to get the data and
++ * metadata of the buffer.
++ *
++ * When the buffer is no longer in use, call \ref pw_stream_queue_buffer()
++ * to let PipeWire reuse the buffer.
++ *
++ * \subsection ssec_produce Produce data
++ *
++ * \ref pw_stream_dequeue_buffer() gives an empty buffer that can be filled.
++ *
++ * Filled buffers should be queued with \ref pw_stream_queue_buffer().
++ *
++ * The process event is emitted when PipeWire has emptied a buffer that
++ * can now be refilled.
++ *
++ * \section sec_stream_disconnect Disconnect
++ *
++ * Use \ref pw_stream_disconnect() to disconnect a stream after use.
++ */
++/** \class pw_stream
++ *
++ * \brief PipeWire stream object class
++ *
++ * The stream object provides a convenient way to send and
++ * receive data streams from/to PipeWire.
++ *
++ * See also \ref page_streams and \ref page_context_api
++ */
++struct pw_stream;
++
++#include <spa/buffer/buffer.h>
++#include <spa/param/param.h>
++
++/** \enum pw_stream_state The state of a stream \memberof pw_stream */
++enum pw_stream_state {
++	PW_STREAM_STATE_ERROR = -1,		/**< the stream is in error */
++	PW_STREAM_STATE_UNCONNECTED = 0,	/**< unconnected */
++	PW_STREAM_STATE_CONNECTING = 1,		/**< connection is in progress */
++	PW_STREAM_STATE_PAUSED = 2,		/**< paused */
++	PW_STREAM_STATE_STREAMING = 3		/**< streaming */
++};
++
++struct pw_buffer {
++	struct spa_buffer *buffer;	/**< the spa buffer */
++	void *user_data;		/**< user data attached to the buffer */
++	uint64_t size;			/**< This field is set by the user and the sum of
++					  *  all queued buffer is returned in the time info */
++};
++
++struct pw_stream_control {
++	const char *name;		/**< name of the control */
++	uint32_t flags;			/**< extra flags (unused) */
++	float def;			/**< default value */
++	float min;			/**< min value */
++	float max;			/**< max value */
++	float *values;			/**< array of values */
++	uint32_t n_values;		/**< number of values in array */
++	uint32_t max_values;		/**< max values that can be set on this control */
++};
++
++/** A time structure \memberof pw_stream */
++struct pw_time {
++	int64_t now;			/**< the monotonic time */
++	struct spa_fraction rate;	/**< the rate of \a ticks and delay */
++	uint64_t ticks;			/**< the ticks at \a now. This is the current time that
++					  *  the remote end is reading/writing. */
++	int64_t delay;			/**< delay to device, add to ticks to get the time of the
++					  *  device. Positive for INPUT streams and
++					  *  negative for OUTPUT streams. */
++	uint64_t queued;		/**< data queued in the stream, this is the sum
++					  *  of the size fields in the pw_buffer that are
++					  *  currently queued */
++};
++
++#include <pipewire/pipewire.h>
++
++/** Events for a stream. These events are always called from the mainloop
++ * unless explicitly documented otherwise. */
++struct pw_stream_events {
++#define PW_VERSION_STREAM_EVENTS	0
++	uint32_t version;
++
++	void (*destroy) (void *data);
++	/** when the stream state changes */
++	void (*state_changed) (void *data, enum pw_stream_state old,
++				enum pw_stream_state state, const char *error);
++
++	/** Notify information about a control.  */
++	void (*control_info) (void *data, uint32_t id, const struct pw_stream_control *control);
++
++	/** when io changed on the stream. */
++	void (*io_changed) (void *data, uint32_t id, void *area, uint32_t size);
++	/** when a parameter changed */
++	void (*param_changed) (void *data, uint32_t id, const struct spa_pod *param);
++
++        /** when a new buffer was created for this stream */
++        void (*add_buffer) (void *data, struct pw_buffer *buffer);
++        /** when a buffer was destroyed for this stream */
++        void (*remove_buffer) (void *data, struct pw_buffer *buffer);
++
++        /** when a buffer can be queued (for playback streams) or
++         *  dequeued (for capture streams). This is normally called from the
++	 *  mainloop but can also be called directly from the realtime data
++	 *  thread if the user is prepared to deal with this. */
++        void (*process) (void *data);
++
++	/** The stream is drained */
++        void (*drained) (void *data);
++
++};
++
++/** Convert a stream state to a readable string \memberof pw_stream */
++const char * pw_stream_state_as_string(enum pw_stream_state state);
++
++/** \enum pw_stream_flags Extra flags that can be used in \ref pw_stream_connect() \memberof pw_stream */
++enum pw_stream_flags {
++	PW_STREAM_FLAG_NONE = 0,			/**< no flags */
++	PW_STREAM_FLAG_AUTOCONNECT	= (1 << 0),	/**< try to automatically connect
++							  *  this stream */
++	PW_STREAM_FLAG_INACTIVE		= (1 << 1),	/**< start the stream inactive,
++							  *  pw_stream_set_active() needs to be
++							  *  called explicitly */
++	PW_STREAM_FLAG_MAP_BUFFERS	= (1 << 2),	/**< mmap the buffers */
++	PW_STREAM_FLAG_DRIVER		= (1 << 3),	/**< be a driver */
++	PW_STREAM_FLAG_RT_PROCESS	= (1 << 4),	/**< call process from the realtime
++							  *  thread. You MUST use RT safe functions
++							  *  in the process callback. */
++	PW_STREAM_FLAG_NO_CONVERT	= (1 << 5),	/**< don't convert format */
++	PW_STREAM_FLAG_EXCLUSIVE	= (1 << 6),	/**< require exclusive access to the
++							  *  device */
++	PW_STREAM_FLAG_DONT_RECONNECT	= (1 << 7),	/**< don't try to reconnect this stream
++							  *  when the sink/source is removed */
++	PW_STREAM_FLAG_ALLOC_BUFFERS	= (1 << 8),	/**< the application will allocate buffer
++							  *  memory. In the add_buffer event, the
++							  *  data of the buffer should be set */
++};
++
++/** Create a new unconneced \ref pw_stream \memberof pw_stream
++ * \return a newly allocated \ref pw_stream */
++struct pw_stream *
++pw_stream_new(struct pw_core *core,		/**< a \ref pw_core */
++	      const char *name,			/**< a stream media name */
++	      struct pw_properties *props	/**< stream properties, ownership is taken */);
++
++struct pw_stream *
++pw_stream_new_simple(struct pw_loop *loop,	/**< a \ref pw_loop to use */
++		     const char *name,		/**< a stream media name */
++		     struct pw_properties *props,/**< stream properties, ownership is taken */
++		     const struct pw_stream_events *events,	/**< stream events */
++		     void *data					/**< data passed to events */);
++
++/** Destroy a stream \memberof pw_stream */
++void pw_stream_destroy(struct pw_stream *stream);
++
++void pw_stream_add_listener(struct pw_stream *stream,
++			    struct spa_hook *listener,
++			    const struct pw_stream_events *events,
++			    void *data);
++
++enum pw_stream_state pw_stream_get_state(struct pw_stream *stream, const char **error);
++
++const char *pw_stream_get_name(struct pw_stream *stream);
++
++struct pw_core *pw_stream_get_core(struct pw_stream *stream);
++
++const struct pw_properties *pw_stream_get_properties(struct pw_stream *stream);
++
++int pw_stream_update_properties(struct pw_stream *stream, const struct spa_dict *dict);
++
++/** Connect a stream for input or output on \a port_path. \memberof pw_stream
++ * \return 0 on success < 0 on error.
++ *
++ * You should connect to the process event and use pw_stream_dequeue_buffer()
++ * to get the latest metadata and data. */
++int
++pw_stream_connect(struct pw_stream *stream,		/**< a \ref pw_stream */
++		  enum pw_direction direction,		/**< the stream direction */
++		  uint32_t target_id,			/**< the target object id to connect to or
++							  *  PW_ID_ANY to let the manager
++							  *  select a target. */
++		  enum pw_stream_flags flags,		/**< stream flags */
++		  const struct spa_pod **params,	/**< an array with params. The params
++							  *  should ideally contain supported
++							  *  formats. */
++		  uint32_t n_params			/**< number of items in \a params */);
++
++/** Get the node ID of the stream. \memberof pw_stream
++ * \return node ID. */
++uint32_t
++pw_stream_get_node_id(struct pw_stream *stream);
++
++/** Disconnect \a stream \memberof pw_stream */
++int pw_stream_disconnect(struct pw_stream *stream);
++
++/** Set the stream in error state */
++int pw_stream_set_error(struct pw_stream *stream,	/**< a \ref pw_stream */
++			int res,			/**< a result code */
++			const char *error, ...		/**< an error message */) SPA_PRINTF_FUNC(3, 4);
++
++/** Complete the negotiation process with result code \a res \memberof pw_stream
++ *
++ * This function should be called after notification of the format.
++
++ * When \a res indicates success, \a params contain the parameters for the
++ * allocation state.  */
++int
++pw_stream_update_params(struct pw_stream *stream,	/**< a \ref pw_stream */
++			const struct spa_pod **params,	/**< an array of params. The params should
++							  *  ideally contain parameters for doing
++							  *  buffer allocation. */
++			uint32_t n_params		/**< number of elements in \a params */);
++
++/** Set control values */
++int pw_stream_set_control(struct pw_stream *stream, uint32_t id, uint32_t n_values, float *values, ...);
++
++/** Query the time on the stream \memberof pw_stream */
++int pw_stream_get_time(struct pw_stream *stream, struct pw_time *time);
++
++/** Get a buffer that can be filled for playback streams or consumed
++ * for capture streams.  */
++struct pw_buffer *pw_stream_dequeue_buffer(struct pw_stream *stream);
++
++/** Submit a buffer for playback or recycle a buffer for capture. */
++int pw_stream_queue_buffer(struct pw_stream *stream, struct pw_buffer *buffer);
++
++/** Activate or deactivate the stream \memberof pw_stream */
++int pw_stream_set_active(struct pw_stream *stream, bool active);
++
++/** Flush a stream. When \a drain is true, the drained callback will
++ * be called when all data is played or recorded */
++int pw_stream_flush(struct pw_stream *stream, bool drain);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_STREAM_H */
+diff --git a/third_party/pipewire/pipewire/thread-loop.h b/third_party/pipewire/pipewire/thread-loop.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/thread-loop.h
+@@ -0,0 +1,168 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_THREAD_LOOP_H
++#define PIPEWIRE_THREAD_LOOP_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <pipewire/loop.h>
++
++/** \page page_thread_loop Threaded Loop
++ *
++ * \section sec_thread_loop_overview Overview
++ *
++ * The threaded loop implementation is a special wrapper around the
++ * regular \ref pw_loop implementation.
++ *
++ * The added feature in the threaded loop is that it spawns a new thread
++ * that runs the wrapped loop. This allows a synchronous application to use
++ * the asynchronous API without risking to stall the PipeWire library.
++ *
++ * \section sec_thread_loop_create Creation
++ *
++ * A \ref pw_thread_loop object is created using pw_thread_loop_new().
++ * The \ref pw_loop to wrap must be given as an argument along with the name
++ * for the thread that will be spawned.
++ *
++ * After allocating the object, the thread must be started with
++ * pw_thread_loop_start()
++ *
++ * \section sec_thread_loop_destruction Destruction
++ *
++ * When the PipeWire connection has been terminated, the thread must be
++ * stopped and the resources freed. Stopping the thread is done using
++ * pw_thread_loop_stop(), which must be called without the lock (see
++ * below) held. When that function returns, the thread is stopped and the
++ * \ref pw_thread_loop object can be freed using pw_thread_loop_destroy().
++ *
++ * \section sec_thread_loop_locking Locking
++ *
++ * Since the PipeWire API doesn't allow concurrent accesses to objects,
++ * a locking scheme must be used to guarantee safe usage. The threaded
++ * loop API provides such a scheme through the functions
++ * pw_thread_loop_lock() and pw_thread_loop_unlock().
++ *
++ * The lock is recursive, so it's safe to use it multiple times from the same
++ * thread. Just make sure you call pw_thread_loop_unlock() the same
++ * number of times you called pw_thread_loop_lock().
++ *
++ * The lock needs to be held whenever you call any PipeWire function that
++ * uses an object associated with this loop. Make sure you do not hold
++ * on to the lock more than necessary though, as the threaded loop stops
++ * while the lock is held.
++ *
++ * \section sec_thread_loop_events Events and Callbacks
++ *
++ * All events and callbacks are called with the thread lock held.
++ *
++ */
++/** \class pw_thread_loop
++ *
++ * \brief PipeWire threaded loop object
++ *
++ * The threaded loop object runs a \ref pw_loop in a separate thread
++ * and ensures proper locking is done.
++ *
++ * All of the loop callbacks will be executed with the loop
++ * lock held.
++ *
++ * See also \ref page_thread_loop
++ */
++struct pw_thread_loop;
++
++/** Thread loop events */
++struct pw_thread_loop_events {
++#define PW_VERSION_THREAD_LOOP_EVENTS	0
++        uint32_t version;
++
++	/** the loop is destroyed */
++        void (*destroy) (void *data);
++};
++
++/** Make a new thread loop with the given name and optional properties. */
++struct pw_thread_loop *
++pw_thread_loop_new(const char *name, const struct spa_dict *props);
++
++/** Make a new thread loop with the given loop, name and optional properties.
++ * When \a loop is NULL, a new loop will be created. */
++struct pw_thread_loop *
++pw_thread_loop_new_full(struct pw_loop *loop, const char *name, const struct spa_dict *props);
++
++/** Destroy a thread loop */
++void pw_thread_loop_destroy(struct pw_thread_loop *loop);
++
++/** Add an event listener */
++void pw_thread_loop_add_listener(struct pw_thread_loop *loop,
++				 struct spa_hook *listener,
++				 const struct pw_thread_loop_events *events,
++				 void *data);
++
++/** Get the loop implementation of the thread loop */
++struct pw_loop * pw_thread_loop_get_loop(struct pw_thread_loop *loop);
++
++/** Start the thread loop */
++int pw_thread_loop_start(struct pw_thread_loop *loop);
++
++/** Stop the thread loop */
++void pw_thread_loop_stop(struct pw_thread_loop *loop);
++
++/** Lock the loop. This ensures exclusive ownership of the loop */
++void pw_thread_loop_lock(struct pw_thread_loop *loop);
++
++/** Unlock the loop */
++void pw_thread_loop_unlock(struct pw_thread_loop *loop);
++
++/** Release the lock and wait until some thread calls \ref pw_thread_loop_signal */
++void pw_thread_loop_wait(struct pw_thread_loop *loop);
++
++/** Release the lock and wait a maximum of 'wait_max_sec' seconds
++ *  until some thread calls \ref pw_thread_loop_signal or time out */
++int pw_thread_loop_timed_wait(struct pw_thread_loop *loop, int wait_max_sec);
++
++/** Get a struct timespec suitable for \ref pw_thread_loop_timed_wait_full.
++ * Since: 0.3.7 */
++int pw_thread_loop_get_time(struct pw_thread_loop *loop, struct timespec *abstime, int64_t timeout);
++
++/** Release the lock and wait up to \a abstime until some thread calls
++ * \ref pw_thread_loop_signal. Use \ref pw_thread_loop_get_time to make a timeout.
++ * Since: 0.3.7 */
++int pw_thread_loop_timed_wait_full(struct pw_thread_loop *loop, struct timespec *abstime);
++
++/** Signal all threads waiting with \ref pw_thread_loop_wait */
++void pw_thread_loop_signal(struct pw_thread_loop *loop, bool wait_for_accept);
++
++/** Signal all threads executing \ref pw_thread_loop_signal with wait_for_accept */
++void pw_thread_loop_accept(struct pw_thread_loop *loop);
++
++/** Check if inside the thread */
++bool pw_thread_loop_in_thread(struct pw_thread_loop *loop);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_THREAD_LOOP_H */
+diff --git a/third_party/pipewire/pipewire/type.h b/third_party/pipewire/pipewire/type.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/type.h
+@@ -0,0 +1,52 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_TYPE_H
++#define PIPEWIRE_TYPE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/type.h>
++
++enum {
++	PW_TYPE_FIRST = SPA_TYPE_VENDOR_PipeWire,
++};
++
++#define PW_TYPE_INFO_BASE		"PipeWire:"
++
++#define PW_TYPE_INFO_Object		PW_TYPE_INFO_BASE "Object"
++#define PW_TYPE_INFO_OBJECT_BASE	PW_TYPE_INFO_Object ":"
++
++#define PW_TYPE_INFO_Interface		PW_TYPE_INFO_BASE "Interface"
++#define PW_TYPE_INFO_INTERFACE_BASE	PW_TYPE_INFO_Interface ":"
++
++const struct spa_type_info * pw_type_info(void);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_TYPE_H */
+diff --git a/third_party/pipewire/pipewire/utils.h b/third_party/pipewire/pipewire/utils.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/utils.h
+@@ -0,0 +1,59 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_UTILS_H
++#define PIPEWIRE_UTILS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/pod/pod.h>
++
++/** \class pw_utils
++ *
++ * Various utility functions
++ */
++
++/** a function to destroy an item \memberof pw_utils */
++typedef void (*pw_destroy_t) (void *object);
++
++const char *
++pw_split_walk(const char *str, const char *delimiter, size_t *len, const char **state);
++
++char **
++pw_split_strv(const char *str, const char *delimiter, int max_tokens, int *n_tokens);
++
++void
++pw_free_strv(char **str);
++
++char *
++pw_strip(char *str, const char *whitespace);
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* PIPEWIRE_UTILS_H */
+diff --git a/third_party/pipewire/pipewire/version.h b/third_party/pipewire/pipewire/version.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/version.h
+@@ -0,0 +1,68 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_VERSION_H
++#define PIPEWIRE_VERSION_H
++
++/* WARNING: Make sure to edit the real source file version.h.in! */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** Return the version of the header files. Keep in mind that this is
++a macro and not a function, so it is impossible to get the pointer of
++it. */
++#define pw_get_headers_version() ("0.3.13")
++
++/** Return the version of the library the current application is
++ * linked to. */
++const char* pw_get_library_version(void);
++
++/** The current API version. Versions prior to 0.2.0 have
++ * PW_API_VERSION undefined. Please note that this is only ever
++ * increased on incompatible API changes!  */
++#define PW_API_VERSION "0.3"
++
++/** The major version of PipeWire. \since 0.2.0 */
++#define PW_MAJOR 0
++
++/** The minor version of PipeWire. \since 0.2.0 */
++#define PW_MINOR 3
++
++/** The micro version of PipeWire. \since 0.2.0 */
++#define PW_MICRO 13
++
++/** Evaluates to TRUE if the PipeWire library version is equal or
++ * newer than the specified. \since 0.2.0 */
++#define PW_CHECK_VERSION(major,minor,micro)                             \
++    ((PW_MAJOR > (major)) ||                                            \
++     (PW_MAJOR == (major) && PW_MINOR > (minor)) ||                     \
++     (PW_MAJOR == (major) && PW_MINOR == (minor) && PW_MICRO >= (micro)))
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_VERION_H */
+diff --git a/third_party/pipewire/pipewire/work-queue.h b/third_party/pipewire/pipewire/work-queue.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/pipewire/work-queue.h
+@@ -0,0 +1,63 @@
++/* PipeWire
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef PIPEWIRE_WORK_QUEUE_H
++#define PIPEWIRE_WORK_QUEUE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** \class pw_work_queue
++ *
++ * PipeWire work queue object
++ */
++struct pw_work_queue;
++
++#include <pipewire/loop.h>
++
++typedef void (*pw_work_func_t) (void *obj, void *data, int res, uint32_t id);
++
++struct pw_work_queue *
++pw_work_queue_new(struct pw_loop *loop);
++
++void
++pw_work_queue_destroy(struct pw_work_queue *queue);
++
++uint32_t
++pw_work_queue_add(struct pw_work_queue *queue,
++		  void *obj, int res,
++		  pw_work_func_t func, void *data);
++
++int
++pw_work_queue_cancel(struct pw_work_queue *queue, void *obj, uint32_t id);
++
++int
++pw_work_queue_complete(struct pw_work_queue *queue, void *obj, uint32_t seq, int res);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* PIPEWIRE_WORK_QUEUE_H */
+diff --git a/third_party/pipewire/spa/buffer/alloc.h b/third_party/pipewire/spa/buffer/alloc.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/buffer/alloc.h
+@@ -0,0 +1,338 @@
++/* Simple Plugin API
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++#ifndef SPA_BUFFER_ALLOC_H
++#define SPA_BUFFER_ALLOC_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/buffer/buffer.h>
++
++/** information about the buffer layout */
++struct spa_buffer_alloc_info {
++#define SPA_BUFFER_ALLOC_FLAG_INLINE_META	(1<<0)	/**< add metadata data in the skeleton */
++#define SPA_BUFFER_ALLOC_FLAG_INLINE_CHUNK	(1<<1)	/**< add chunk data in the skeleton */
++#define SPA_BUFFER_ALLOC_FLAG_INLINE_DATA	(1<<2)	/**< add buffer data to the skeleton */
++#define SPA_BUFFER_ALLOC_FLAG_INLINE_ALL	0b111
++#define SPA_BUFFER_ALLOC_FLAG_NO_DATA		(1<<3)	/**< don't set data pointers */
++	uint32_t flags;
++	uint32_t max_align;	/**< max of all alignments */
++	uint32_t n_metas;
++	uint32_t n_datas;
++	struct spa_meta *metas;
++	struct spa_data *datas;
++	uint32_t *data_aligns;
++	size_t skel_size;	/**< size of the struct spa_buffer and inlined meta/chunk/data */
++	size_t meta_size;	/**< size of the meta if not inlined */
++	size_t chunk_size;	/**< size of the chunk if not inlined */
++	size_t data_size;	/**< size of the data if not inlined */
++	size_t mem_size;	/**< size of the total memory if not inlined */
++};
++
++/**
++ * Fill buffer allocation information
++ *
++ * Fill \a info with allocation information needed to allocate buffers
++ * with the given number of metadata and data members.
++ *
++ * The required size of the skeleton (the struct spa_buffer) information
++ * and the memory (for the metadata, chunk and buffer memory) will be
++ * calculated.
++ *
++ * The flags member in \a info should be configured before calling this
++ * functions.
++ *
++ * \param info the information to fill
++ * \param n_metas the number of metadatas for the buffer
++ * \param metas an array of metadata items
++ * \param n_datas the number of datas for the buffer
++ * \param datas an array of \a n_datas items
++ * \param data_aligns \a n_datas alignments
++ * \return 0 on success.
++ * */
++static inline int spa_buffer_alloc_fill_info(struct spa_buffer_alloc_info *info,
++					     uint32_t n_metas, struct spa_meta metas[],
++					     uint32_t n_datas, struct spa_data datas[],
++					     uint32_t data_aligns[])
++{
++	size_t size, *target;
++	uint32_t i;
++
++	info->n_metas = n_metas;
++	info->metas = metas;
++	info->n_datas = n_datas;
++	info->datas = datas;
++	info->data_aligns = data_aligns;
++	info->max_align = 16;
++	info->mem_size = 0;
++	/*
++	 * The buffer skeleton is placed in memory like below and can
++	 * be accessed as a regular structure.
++	 *
++	 *      +==============================+
++	 *      | struct spa_buffer            |
++	 *      |   uint32_t n_metas           | number of metas
++	 *      |   uint32_t n_datas           | number of datas
++	 *    +-|   struct spa_meta *metas     | pointer to array of metas
++	 *   +|-|   struct spa_data *datas     | pointer to array of datas
++	 *   || +------------------------------+
++	 *   |+>| struct spa_meta              |
++	 *   |  |   uint32_t type              | metadata
++	 *   |  |   uint32_t size              | size of metadata
++	 *  +|--|   void *data                 | pointer to metadata
++	 *  ||  | ... <n_metas>                | more spa_meta follow
++	 *  ||  +------------------------------+
++	 *  |+->| struct spa_data              |
++	 *  |   |   uint32_t type              | memory type
++	 *  |   |   uint32_t flags             |
++	 *  |   |   int fd                     | fd of shared memory block
++	 *  |   |   uint32_t mapoffset         | offset in shared memory of data
++	 *  |   |   uint32_t maxsize           | size of data block
++	 *  | +-|   void *data                 | pointer to data
++	 *  |+|-|   struct spa_chunk *chunk    | pointer to chunk
++	 *  ||| | ... <n_datas>                | more spa_data follow
++	 *  ||| +==============================+
++	 *  VVV
++	 *
++	 * metadata, chunk and memory can either be placed right
++	 * after the skeleton (inlined) or in a separate piece of memory.
++	 *
++	 *  vvv
++	 *  ||| +==============================+
++	 *  +-->| meta data memory             | metadata memory, 8 byte aligned
++	 *   || | ... <n_metas>                |
++	 *   || +------------------------------+
++	 *   +->| struct spa_chunk             | memory for n_datas chunks
++	 *    | |   uint32_t offset            |
++	 *    | |   uint32_t size              |
++	 *    | |   int32_t stride             |
++	 *    | |   int32_t dummy              |
++	 *    | | ... <n_datas> chunks         |
++	 *    | +------------------------------+
++	 *    +>| data                         | memory for n_datas data, aligned
++	 *      | ... <n_datas> blocks         | according to alignments
++	 *      +==============================+
++	 */
++	info->skel_size = sizeof(struct spa_buffer);
++        info->skel_size += n_metas * sizeof(struct spa_meta);
++        info->skel_size += n_datas * sizeof(struct spa_data);
++
++	for (i = 0, size = 0; i < n_metas; i++)
++		size += SPA_ROUND_UP_N(metas[i].size, 8);
++	info->meta_size = size;
++
++	if (SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_INLINE_META))
++		target = &info->skel_size;
++	else
++		target = &info->mem_size;
++	*target += info->meta_size;
++
++	info->chunk_size = n_datas * sizeof(struct spa_chunk);
++	if (SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_INLINE_CHUNK))
++		target = &info->skel_size;
++	else
++	        target = &info->mem_size;
++	*target += info->chunk_size;
++
++	for (i = 0, size = 0; i < n_datas; i++) {
++		info->max_align = SPA_MAX(info->max_align, data_aligns[i]);
++		size = SPA_ROUND_UP_N(size, data_aligns[i]);
++		size += datas[i].maxsize;
++	}
++	info->data_size = size;
++
++	if (!SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_NO_DATA) &&
++	    SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_INLINE_DATA))
++		target = &info->skel_size;
++	else
++		target = &info->mem_size;
++
++	*target = SPA_ROUND_UP_N(*target, n_datas ? data_aligns[0] : 1);
++	*target += info->data_size;
++	*target = SPA_ROUND_UP_N(*target, info->max_align);
++
++	return 0;
++}
++
++/**
++ * Fill skeleton and data according to the allocation info
++ *
++ * Use the allocation info to create a \ref struct spa_buffer into
++ * \a skel_mem and \a data_mem.
++ *
++ * Depending on the flags given when calling \ref
++ * spa_buffer_alloc_fill_info(), the buffer meta, chunk and memory
++ * will be referenced in either skel_mem or data_mem.
++ *
++ * \param info an allocation info
++ * \param skel_mem memory to hold the \ref struct spa_buffer and the
++ *  pointers to meta, chunk and memory.
++ * \param data_mem memory to hold the meta, chunk and memory
++ * \return a \ref struct spa_buffer in \a skel_mem
++ */
++static inline struct spa_buffer *
++spa_buffer_alloc_layout(struct spa_buffer_alloc_info *info,
++			void *skel_mem, void *data_mem)
++{
++	struct spa_buffer *b = (struct spa_buffer*)skel_mem;
++	size_t size;
++	uint32_t i;
++	void **dp, *skel, *data;
++	struct spa_chunk *cp;
++
++	b->n_metas = info->n_metas;
++	b->metas = SPA_MEMBER(b, sizeof(struct spa_buffer), struct spa_meta);
++	b->n_datas = info->n_datas;
++	b->datas = SPA_MEMBER(b->metas, info->n_metas * sizeof(struct spa_meta), struct spa_data);
++
++	skel = SPA_MEMBER(b->datas, info->n_datas * sizeof(struct spa_data), void);
++	data = data_mem;
++
++	if (SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_INLINE_META))
++		dp = &skel;
++	else
++		dp = &data;
++
++	for (i = 0; i < info->n_metas; i++) {
++		struct spa_meta *m = &b->metas[i];
++		*m = info->metas[i];
++		m->data = *dp;
++		*dp = SPA_MEMBER(*dp, SPA_ROUND_UP_N(m->size, 8), void);
++	}
++
++	size = info->n_datas * sizeof(struct spa_chunk);
++	if (SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_INLINE_CHUNK)) {
++		cp = (struct spa_chunk*)skel;
++		skel = SPA_MEMBER(skel, size, void);
++	}
++	else {
++		cp = (struct spa_chunk*)data;
++		data = SPA_MEMBER(data, size, void);
++	}
++
++	if (SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_INLINE_DATA))
++		dp = &skel;
++	else
++		dp = &data;
++
++	for (i = 0; i < info->n_datas; i++) {
++		struct spa_data *d = &b->datas[i];
++
++		*d = info->datas[i];
++		d->chunk = &cp[i];
++		if (!SPA_FLAG_IS_SET(info->flags, SPA_BUFFER_ALLOC_FLAG_NO_DATA)) {
++			*dp = SPA_PTR_ALIGN(*dp, info->data_aligns[i], void);
++			d->data = *dp;
++			*dp = SPA_MEMBER(*dp, d->maxsize, void);
++		}
++	}
++	return b;
++}
++
++/**
++ * Layout an array of buffers
++ *
++ * Use the allocation info to layout the memory of an array of buffers.
++ *
++ * \a skel_mem should point to at least info->skel_size * \a n_buffers bytes
++ * of memory.
++ * \a data_mem should point to at least info->mem_size * \a n_buffers bytes
++ * of memory.
++ *
++ * \param info the allocation info for one buffer
++ * \param n_buffers the number of buffers to create
++ * \param buffer a array with space to hold \a n_buffers pointers to buffers
++ * \param skel_mem memory for the \ref struct spa_buffer
++ * \param data_mem memory for the meta, chunk, memory of the buffer if not
++ *		inlined in the skeleton.
++ * \return 0 on success.
++ *
++ */
++static inline int
++spa_buffer_alloc_layout_array(struct spa_buffer_alloc_info *info,
++			      uint32_t n_buffers, struct spa_buffer *buffers[],
++			      void *skel_mem, void *data_mem)
++{
++	uint32_t i;
++	for (i = 0; i < n_buffers; i++) {
++		buffers[i] = spa_buffer_alloc_layout(info, skel_mem, data_mem);
++		skel_mem = SPA_MEMBER(skel_mem, info->skel_size, void);
++		data_mem = SPA_MEMBER(data_mem, info->mem_size, void);
++        }
++	return 0;
++}
++
++/**
++ * Allocate an array of buffers
++ *
++ * Allocate \a n_buffers with the given metadata, memory and alignment
++ * information.
++ *
++ * The buffer array, structures, data and metadata will all be allocated
++ * in one block of memory with the proper requested alignment.
++ *
++ * \param n_buffers the number of buffers to create
++ * \param flags extra flags
++ * \param n_metas number of metadatas
++ * \param metas \a n_metas metadata specification
++ * \param n_datas number of datas
++ * \param datas \a n_datas memory specification
++ * \param data_aligns \a n_datas alignment specifications
++ * \returns an array of \a n_buffers pointers to \ref struct spa_buffer
++ *     with the given metadata, data and alignment or NULL when
++ *     allocation failed.
++ *
++ */
++static inline struct spa_buffer **
++spa_buffer_alloc_array(uint32_t n_buffers, uint32_t flags,
++		       uint32_t n_metas, struct spa_meta metas[],
++		       uint32_t n_datas, struct spa_data datas[],
++		       uint32_t data_aligns[])
++{
++
++	struct spa_buffer **buffers;
++	struct spa_buffer_alloc_info info = { flags | SPA_BUFFER_ALLOC_FLAG_INLINE_ALL, };
++	void *skel;
++
++	spa_buffer_alloc_fill_info(&info, n_metas, metas, n_datas, datas, data_aligns);
++
++	buffers = (struct spa_buffer **)calloc(1, info.max_align +
++			n_buffers * (sizeof(struct spa_buffer *) + info.skel_size));
++	if (buffers == NULL)
++		return NULL;
++
++	skel = SPA_MEMBER(buffers, sizeof(struct spa_buffer *) * n_buffers, void);
++	skel = SPA_PTR_ALIGN(skel, info.max_align, void);
++
++	spa_buffer_alloc_layout_array(&info, n_buffers, buffers, skel, NULL);
++
++	return buffers;
++}
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_BUFFER_ALLOC_H */
+diff --git a/third_party/pipewire/spa/buffer/buffer.h b/third_party/pipewire/spa/buffer/buffer.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/buffer/buffer.h
+@@ -0,0 +1,114 @@
++/* Simple Plugin API
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_BUFFER_H
++#define SPA_BUFFER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/buffer/meta.h>
++
++/** \page page_buffer Buffers
++ *
++ * Buffers describe the data and metadata that is exchanged between
++ * ports of a node.
++ */
++
++enum spa_data_type {
++	SPA_DATA_Invalid,
++	SPA_DATA_MemPtr,		/**< pointer to memory, the data field in
++					  *  struct spa_data is set. */
++	SPA_DATA_MemFd,			/**< generic fd, mmap to get to memory */
++	SPA_DATA_DmaBuf,		/**< fd to dmabuf memory */
++	SPA_DATA_MemId,			/**< memory is identified with an id */
++
++	SPA_DATA_LAST,			/**< not part of ABI */
++};
++
++/** Chunk of memory, can change for each buffer */
++struct spa_chunk {
++	uint32_t offset;		/**< offset of valid data. Should be taken
++					  *  modulo the data maxsize to get the offset
++					  *  in the data memory. */
++	uint32_t size;			/**< size of valid data. Should be clamped to
++					  *  maxsize. */
++	int32_t stride;			/**< stride of valid data */
++#define SPA_CHUNK_FLAG_NONE		0
++#define SPA_CHUNK_FLAG_CORRUPTED	(1u<<0)	/**< chunk data is corrupted in some way */
++	int32_t flags;			/**< chunk flags */
++};
++
++/** Data for a buffer this stays constant for a buffer */
++struct spa_data {
++	uint32_t type;			/**< memory type, one of enum spa_data_type, when
++					  *  allocating memory, the type contains a bitmask
++					  *  of allowed types */
++#define SPA_DATA_FLAG_NONE	 0
++#define SPA_DATA_FLAG_READABLE	(1u<<0)	/**< data is readable */
++#define SPA_DATA_FLAG_WRITABLE	(1u<<1)	/**< data is writable */
++#define SPA_DATA_FLAG_DYNAMIC	(1u<<2)	/**< data pointer can be changed */
++#define SPA_DATA_FLAG_READWRITE	(SPA_DATA_FLAG_READABLE|SPA_DATA_FLAG_WRITABLE)
++	uint32_t flags;			/**< data flags */
++	int64_t fd;			/**< optional fd for data */
++	uint32_t mapoffset;		/**< offset to map fd at */
++	uint32_t maxsize;		/**< max size of data */
++	void *data;			/**< optional data pointer */
++	struct spa_chunk *chunk;	/**< valid chunk of memory */
++};
++
++/** A Buffer */
++struct spa_buffer {
++	uint32_t n_metas;		/**< number of metadata */
++	uint32_t n_datas;		/**< number of data members */
++	struct spa_meta *metas;		/**< array of metadata */
++	struct spa_data *datas;		/**< array of data members */
++};
++
++/** Find metadata in a buffer */
++static inline struct spa_meta *spa_buffer_find_meta(const struct spa_buffer *b, uint32_t type)
++{
++	uint32_t i;
++
++	for (i = 0; i < b->n_metas; i++)
++		if (b->metas[i].type == type)
++			return &b->metas[i];
++
++	return NULL;
++}
++
++static inline void *spa_buffer_find_meta_data(const struct spa_buffer *b, uint32_t type, size_t size)
++{
++	struct spa_meta *m;
++	if ((m = spa_buffer_find_meta(b, type)) && m->size >= size)
++		return m->data;
++	return NULL;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_BUFFER_H */
+diff --git a/third_party/pipewire/spa/buffer/meta.h b/third_party/pipewire/spa/buffer/meta.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/buffer/meta.h
+@@ -0,0 +1,151 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_META_H
++#define SPA_META_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/pod/pod.h>
++
++/** \page page_meta Metadata
++ *
++ * Metadata contains extra information on a buffer.
++ */
++enum spa_meta_type {
++	SPA_META_Invalid,
++	SPA_META_Header,	/**< struct spa_meta_header */
++	SPA_META_VideoCrop,	/**< struct spa_meta_region with cropping data */
++	SPA_META_VideoDamage,	/**< array of struct spa_meta_region with damage */
++	SPA_META_Bitmap,	/**< struct spa_meta_bitmap */
++	SPA_META_Cursor,	/**< struct spa_meta_cursor */
++	SPA_META_Control,	/**< metadata contains a spa_meta_control
++				  *  associated with the data */
++
++	SPA_META_LAST,		/**< not part of ABI/API */
++};
++
++/**
++ * A metadata element.
++ *
++ * This structure is available on the buffer structure and contains
++ * the type of the metadata and a pointer/size to the actual metadata
++ * itself.
++ */
++struct spa_meta {
++	uint32_t type;		/**< metadata type, one of enum spa_meta_type */
++	uint32_t size;		/**< size of metadata */
++	void *data;		/**< pointer to metadata */
++};
++
++#define spa_meta_first(m)	((m)->data)
++#define spa_meta_end(m)		SPA_MEMBER((m)->data,(m)->size,void)
++#define spa_meta_check(p,m)	(SPA_MEMBER(p,sizeof(*p),void) <= spa_meta_end(m))
++
++/**
++ * Describes essential buffer header metadata such as flags and
++ * timestamps.
++ */
++struct spa_meta_header {
++#define SPA_META_HEADER_FLAG_DISCONT	(1 << 0)	/**< data is not continuous with previous buffer */
++#define SPA_META_HEADER_FLAG_CORRUPTED	(1 << 1)	/**< data might be corrupted */
++#define SPA_META_HEADER_FLAG_MARKER	(1 << 2)	/**< media specific marker */
++#define SPA_META_HEADER_FLAG_HEADER	(1 << 3)	/**< data contains a codec specific header */
++#define SPA_META_HEADER_FLAG_GAP	(1 << 4)	/**< data contains media neutral data */
++#define SPA_META_HEADER_FLAG_DELTA_UNIT	(1 << 5)	/**< cannot be decoded independently */
++	uint32_t flags;				/**< flags */
++	uint32_t offset;			/**< offset in current cycle */
++	int64_t pts;				/**< presentation timestamp */
++	int64_t dts_offset;			/**< decoding timestamp as a difference with pts */
++	uint64_t seq;				/**< sequence number, increments with a
++						  *  media specific frequency */
++};
++
++/** metadata structure for Region or an array of these for RegionArray */
++struct spa_meta_region {
++	struct spa_region region;
++};
++
++#define spa_meta_region_is_valid(m)	((m)->region.size.width != 0 && (m)->region.size.height != 0)
++
++/** iterate all the items in a metadata */
++#define spa_meta_for_each(pos,meta)					\
++	for (pos = (__typeof(pos))spa_meta_first(meta);			\
++	    spa_meta_check(pos, meta);					\
++            (pos)++)
++
++#define spa_meta_bitmap_is_valid(m)	((m)->format != 0)
++
++/**
++ * Bitmap information
++ *
++ * This metadata contains a bitmap image in the given format and size.
++ * It is typically used for cursor images or other small images that are
++ * better transferred inline.
++ */
++struct spa_meta_bitmap {
++	uint32_t format;		/**< bitmap video format, one of enum spa_video_format. 0 is
++					  *  and invalid format and should be handled as if there is
++					  *  no new bitmap information. */
++	struct spa_rectangle size;	/**< width and height of bitmap */
++	int32_t stride;			/**< stride of bitmap data */
++	uint32_t offset;		/**< offset of bitmap data in this structure. An offset of
++					  *  0 means no image data (invisible), an offset >=
++					  *  sizeof(struct spa_meta_bitmap) contains valid bitmap
++					  *  info. */
++};
++
++#define spa_meta_cursor_is_valid(m)	((m)->id != 0)
++
++/**
++ * Cursor information
++ *
++ * Metadata to describe the position and appearance of a pointing device.
++ */
++struct spa_meta_cursor {
++	uint32_t id;			/**< cursor id. an id of 0 is an invalid id and means that
++					  *  there is no new cursor data */
++	uint32_t flags;			/**< extra flags */
++	struct spa_point position;	/**< position on screen */
++	struct spa_point hotspot;	/**< offsets for hotspot in bitmap, this field has no meaning
++					  *  when there is no valid bitmap (see below) */
++	uint32_t bitmap_offset;		/**< offset of bitmap meta in this structure. When the offset
++					  *  is 0, there is no new bitmap information. When the offset is
++					  *  >= sizeof(struct spa_meta_cursor) there is a
++					  *  struct spa_meta_bitmap at the offset. */
++};
++
++/** a timed set of events associated with the buffer */
++struct spa_meta_control {
++	struct spa_pod_sequence sequence;
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_META_H */
+diff --git a/third_party/pipewire/spa/buffer/type-info.h b/third_party/pipewire/spa/buffer/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/buffer/type-info.h
+@@ -0,0 +1,83 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_BUFFER_TYPES_H
++#define SPA_BUFFER_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/buffer/buffer.h>
++#include <spa/buffer/meta.h>
++#include <spa/utils/type.h>
++
++#define SPA_TYPE_INFO_Buffer			SPA_TYPE_INFO_POINTER_BASE "Buffer"
++#define SPA_TYPE_INFO_BUFFER_BASE		SPA_TYPE_INFO_Buffer ":"
++
++/** Buffers contain data of a certain type */
++#define SPA_TYPE_INFO_Data			SPA_TYPE_INFO_ENUM_BASE "Data"
++#define SPA_TYPE_INFO_DATA_BASE			SPA_TYPE_INFO_Data ":"
++
++/** base type for fd based memory */
++#define SPA_TYPE_INFO_DATA_Fd			SPA_TYPE_INFO_DATA_BASE "Fd"
++#define SPA_TYPE_INFO_DATA_FD_BASE		SPA_TYPE_INFO_DATA_Fd ":"
++
++static const struct spa_type_info spa_type_data_type[] = {
++	{ SPA_DATA_Invalid, SPA_TYPE_Int, SPA_TYPE_INFO_DATA_BASE "Invalid", NULL },
++	{ SPA_DATA_MemPtr, SPA_TYPE_Int, SPA_TYPE_INFO_DATA_BASE "MemPtr", NULL },
++	{ SPA_DATA_MemFd, SPA_TYPE_Int, SPA_TYPE_INFO_DATA_FD_BASE "MemFd", NULL },
++	{ SPA_DATA_DmaBuf, SPA_TYPE_Int, SPA_TYPE_INFO_DATA_FD_BASE "DmaBuf", NULL },
++	{ SPA_DATA_MemId, SPA_TYPE_Int, SPA_TYPE_INFO_DATA_BASE "MemId", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_Meta			SPA_TYPE_INFO_POINTER_BASE "Meta"
++#define SPA_TYPE_INFO_META_BASE			SPA_TYPE_INFO_Meta ":"
++
++#define SPA_TYPE_INFO_META_Array		SPA_TYPE_INFO_META_BASE "Array"
++#define SPA_TYPE_INFO_META_ARRAY_BASE		SPA_TYPE_INFO_META_Array ":"
++
++#define SPA_TYPE_INFO_META_Region		SPA_TYPE_INFO_META_BASE "Region"
++#define SPA_TYPE_INFO_META_REGION_BASE		SPA_TYPE_INFO_META_Region ":"
++
++#define SPA_TYPE_INFO_META_ARRAY_Region		SPA_TYPE_INFO_META_ARRAY_BASE "Region"
++#define SPA_TYPE_INFO_META_ARRAY_REGION_BASE	SPA_TYPE_INFO_META_ARRAY_Region ":"
++
++static const struct spa_type_info spa_type_meta_type[] = {
++	{ SPA_META_Invalid, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_BASE "Invalid", NULL },
++	{ SPA_META_Header, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_BASE "Header", NULL },
++	{ SPA_META_VideoCrop, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_REGION_BASE "VideoCrop", NULL },
++	{ SPA_META_VideoDamage, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_ARRAY_REGION_BASE "VideoDamage", NULL },
++	{ SPA_META_Bitmap, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_BASE "Bitmap", NULL },
++	{ SPA_META_Cursor, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_BASE "Cursor", NULL },
++	{ SPA_META_Control, SPA_TYPE_Pointer, SPA_TYPE_INFO_META_BASE "Control", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_BUFFER_TYPES_H */
+diff --git a/third_party/pipewire/spa/control/control.h b/third_party/pipewire/spa/control/control.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/control/control.h
+@@ -0,0 +1,53 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_CONTROL_H
++#define SPA_CONTROL_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/pod/pod.h>
++
++/** Controls
++ *
++ */
++
++/** Different Control types */
++enum spa_control_type {
++	SPA_CONTROL_Invalid,
++	SPA_CONTROL_Properties,		/**< data contains a SPA_TYPE_OBJECT_Props */
++	SPA_CONTROL_Midi,		/**< data contains a spa_pod_bytes with raw midi data */
++	SPA_CONTROL_OSC,		/**< data contains a spa_pod_bytes with an OSC packet */
++
++	SPA_CONTROL_LAST,		/**< not part of ABI */
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_CONTROL_H */
+diff --git a/third_party/pipewire/spa/control/type-info.h b/third_party/pipewire/spa/control/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/control/type-info.h
+@@ -0,0 +1,52 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_CONTROL_TYPES_H
++#define SPA_CONTROL_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/type-info.h>
++#include <spa/control/control.h>
++
++/* base for parameter object enumerations */
++#define SPA_TYPE_INFO_Control		SPA_TYPE_INFO_ENUM_BASE "Control"
++#define SPA_TYPE_INFO_CONTROL_BASE		SPA_TYPE_INFO_Control ":"
++
++static const struct spa_type_info spa_type_control[] = {
++	{ SPA_CONTROL_Invalid, SPA_TYPE_Int, SPA_TYPE_INFO_CONTROL_BASE "Invalid", NULL },
++	{ SPA_CONTROL_Properties, SPA_TYPE_Int, SPA_TYPE_INFO_CONTROL_BASE "Properties", NULL },
++	{ SPA_CONTROL_Midi, SPA_TYPE_Int, SPA_TYPE_INFO_CONTROL_BASE "Midi", NULL },
++	{ SPA_CONTROL_OSC, SPA_TYPE_Int, SPA_TYPE_INFO_CONTROL_BASE "OSC", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_CONTROL_TYPES_H */
+diff --git a/third_party/pipewire/spa/debug/buffer.h b/third_party/pipewire/spa/debug/buffer.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/buffer.h
+@@ -0,0 +1,119 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_BUFFER_H
++#define SPA_DEBUG_BUFFER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/debug/mem.h>
++#include <spa/debug/types.h>
++#include <spa/buffer/type-info.h>
++
++#ifndef spa_debug
++#define spa_debug(...)	({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
++#endif
++
++static inline int spa_debug_buffer(int indent, const struct spa_buffer *buffer)
++{
++	uint32_t i;
++
++	spa_debug("%*s" "struct spa_buffer %p:", indent, "", buffer);
++	spa_debug("%*s" " n_metas: %u (at %p)", indent, "", buffer->n_metas, buffer->metas);
++	for (i = 0; i < buffer->n_metas; i++) {
++		struct spa_meta *m = &buffer->metas[i];
++		const char *type_name;
++
++		type_name = spa_debug_type_find_name(spa_type_meta_type, m->type);
++		spa_debug("%*s" "  meta %d: type %d (%s), data %p, size %d:", indent, "", i, m->type,
++			type_name, m->data, m->size);
++
++		switch (m->type) {
++		case SPA_META_Header:
++		{
++			struct spa_meta_header *h = (struct spa_meta_header*)m->data;
++			spa_debug("%*s" "    struct spa_meta_header:", indent, "");
++			spa_debug("%*s" "      flags:      %08x", indent, "", h->flags);
++			spa_debug("%*s" "      offset:     %u", indent, "", h->offset);
++			spa_debug("%*s" "      seq:        %" PRIu64, indent, "", h->seq);
++			spa_debug("%*s" "      pts:        %" PRIi64, indent, "", h->pts);
++			spa_debug("%*s" "      dts_offset: %" PRIi64, indent, "", h->dts_offset);
++			break;
++		}
++		case SPA_META_VideoCrop:
++		{
++			struct spa_meta_region *h = (struct spa_meta_region*)m->data;
++			spa_debug("%*s" "    struct spa_meta_region:", indent, "");
++			spa_debug("%*s" "      x:      %d", indent, "", h->region.position.x);
++			spa_debug("%*s" "      y:      %d", indent, "", h->region.position.y);
++			spa_debug("%*s" "      width:  %d", indent, "", h->region.size.width);
++			spa_debug("%*s" "      height: %d", indent, "", h->region.size.height);
++			break;
++		}
++		case SPA_META_VideoDamage:
++		{
++			struct spa_meta_region *h;
++			spa_meta_for_each(h, m) {
++				spa_debug("%*s" "    struct spa_meta_region:", indent, "");
++				spa_debug("%*s" "      x:      %d", indent, "", h->region.position.x);
++				spa_debug("%*s" "      y:      %d", indent, "", h->region.position.y);
++				spa_debug("%*s" "      width:  %d", indent, "", h->region.size.width);
++				spa_debug("%*s" "      height: %d", indent, "", h->region.size.height);
++			}
++			break;
++		}
++		case SPA_META_Bitmap:
++			break;
++		case SPA_META_Cursor:
++			break;
++		default:
++			spa_debug("%*s" "    Unknown:", indent, "");
++			spa_debug_mem(5, m->data, m->size);
++		}
++	}
++	spa_debug("%*s" " n_datas: \t%u (at %p)", indent, "", buffer->n_datas, buffer->datas);
++	for (i = 0; i < buffer->n_datas; i++) {
++		struct spa_data *d = &buffer->datas[i];
++		spa_debug("%*s" "   type:    %d (%s)", indent, "", d->type,
++			spa_debug_type_find_name(spa_type_data_type, d->type));
++		spa_debug("%*s" "   flags:   %d", indent, "", d->flags);
++		spa_debug("%*s" "   data:    %p", indent, "", d->data);
++		spa_debug("%*s" "   fd:      %" PRIi64, indent, "", d->fd);
++		spa_debug("%*s" "   offset:  %d", indent, "", d->mapoffset);
++		spa_debug("%*s" "   maxsize: %u", indent, "", d->maxsize);
++		spa_debug("%*s" "   chunk:   %p", indent, "", d->chunk);
++		spa_debug("%*s" "    offset: %d", indent, "", d->chunk->offset);
++		spa_debug("%*s" "    size:   %u", indent, "", d->chunk->size);
++		spa_debug("%*s" "    stride: %d", indent, "", d->chunk->stride);
++	}
++	return 0;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_BUFFER_H */
+diff --git a/third_party/pipewire/spa/debug/dict.h b/third_party/pipewire/spa/debug/dict.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/dict.h
+@@ -0,0 +1,52 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_DICT_H
++#define SPA_DEBUG_DICT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/dict.h>
++
++#ifndef spa_debug
++#define spa_debug(...)	({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
++#endif
++
++static inline int spa_debug_dict(int indent, const struct spa_dict *dict)
++{
++	const struct spa_dict_item *item;
++	spa_debug("%*sflags:%08x n_items:%d", indent, "", dict->flags, dict->n_items);
++	spa_dict_for_each(item, dict) {
++		spa_debug("%*s  %s = \"%s\"", indent, "", item->key, item->value);
++	}
++	return 0;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_DICT_H */
+diff --git a/third_party/pipewire/spa/debug/format.h b/third_party/pipewire/spa/debug/format.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/format.h
+@@ -0,0 +1,201 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_FORMAT_H
++#define SPA_DEBUG_FORMAT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/parser.h>
++#include <spa/debug/types.h>
++#include <spa/param/type-info.h>
++#include <spa/param/format-utils.h>
++
++static inline int
++spa_debug_format_value(const struct spa_type_info *info,
++		uint32_t type, void *body, uint32_t size)
++{
++	switch (type) {
++	case SPA_TYPE_Bool:
++		fprintf(stderr, "%s", *(int32_t *) body ? "true" : "false");
++		break;
++	case SPA_TYPE_Id:
++	{
++		const char *str = spa_debug_type_find_short_name(info, *(int32_t *) body);
++		char tmp[64];
++		if (str == NULL) {
++			snprintf(tmp, sizeof(tmp), "%d", *(int32_t*)body);
++			str = tmp;
++		}
++		fprintf(stderr, "%s", str);
++		break;
++	}
++	case SPA_TYPE_Int:
++		fprintf(stderr, "%d", *(int32_t *) body);
++		break;
++	case SPA_TYPE_Long:
++		fprintf(stderr, "%" PRIi64, *(int64_t *) body);
++		break;
++	case SPA_TYPE_Float:
++		fprintf(stderr, "%f", *(float *) body);
++		break;
++	case SPA_TYPE_Double:
++		fprintf(stderr, "%g", *(double *) body);
++		break;
++	case SPA_TYPE_String:
++		fprintf(stderr, "%s", (char *) body);
++		break;
++	case SPA_TYPE_Rectangle:
++	{
++		struct spa_rectangle *r = (struct spa_rectangle *)body;
++		fprintf(stderr, "%" PRIu32 "x%" PRIu32, r->width, r->height);
++		break;
++	}
++	case SPA_TYPE_Fraction:
++	{
++		struct spa_fraction *f = (struct spa_fraction *)body;
++		fprintf(stderr, "%" PRIu32 "/%" PRIu32, f->num, f->denom);
++		break;
++	}
++	case SPA_TYPE_Bitmap:
++		fprintf(stderr, "Bitmap");
++		break;
++	case SPA_TYPE_Bytes:
++		fprintf(stderr, "Bytes");
++		break;
++	case SPA_TYPE_Array:
++	{
++		void *p;
++		struct spa_pod_array_body *b = (struct spa_pod_array_body *)body;
++		int i = 0;
++		fprintf(stderr, "< ");
++		SPA_POD_ARRAY_BODY_FOREACH(b, size, p) {
++			if (i++ > 0)
++				fprintf(stderr, ", ");
++			spa_debug_format_value(info, b->child.type, p, b->child.size);
++		}
++		fprintf(stderr, " >");
++		break;
++	}
++	default:
++		fprintf(stderr, "INVALID type %d", type);
++		break;
++	}
++	return 0;
++}
++
++static inline int spa_debug_format(int indent,
++		const struct spa_type_info *info, const struct spa_pod *format)
++{
++	const char *media_type;
++	const char *media_subtype;
++	struct spa_pod_prop *prop;
++	uint32_t mtype, mstype;
++
++	if (info == NULL)
++		info = spa_type_format;
++
++	if (format == NULL || SPA_POD_TYPE(format) != SPA_TYPE_Object)
++		return -EINVAL;
++
++	if (spa_format_parse(format, &mtype, &mstype) < 0)
++		return -EINVAL;
++
++	media_type = spa_debug_type_find_name(spa_type_media_type, mtype);
++	media_subtype = spa_debug_type_find_name(spa_type_media_subtype, mstype);
++
++	fprintf(stderr, "%*s %s/%s\n", indent, "",
++		media_type ? spa_debug_type_short_name(media_type) : "unknown",
++		media_subtype ? spa_debug_type_short_name(media_subtype) : "unknown");
++
++	SPA_POD_OBJECT_FOREACH((struct spa_pod_object*)format, prop) {
++		const char *key;
++		const struct spa_type_info *ti;
++		uint32_t i, type, size, n_vals, choice;
++		const struct spa_pod *val;
++		void *vals;
++
++		if (prop->key == SPA_FORMAT_mediaType ||
++		    prop->key == SPA_FORMAT_mediaSubtype)
++			continue;
++
++		val = spa_pod_get_values(&prop->value, &n_vals, &choice);
++
++		type = val->type;
++		size = val->size;
++		vals = SPA_POD_BODY(val);
++
++		if (type < SPA_TYPE_None || type >= SPA_TYPE_LAST)
++			continue;
++
++		ti = spa_debug_type_find(info, prop->key);
++		key = ti ? ti->name : NULL;
++
++		fprintf(stderr, "%*s %16s : (%s) ", indent, "",
++			key ? spa_debug_type_short_name(key) : "unknown",
++			spa_debug_type_short_name(spa_types[type].name));
++
++		if (choice == SPA_CHOICE_None) {
++			spa_debug_format_value(ti ? ti->values : NULL, type, vals, size);
++		} else {
++			const char *ssep, *esep, *sep;
++
++			switch (choice) {
++			case SPA_CHOICE_Range:
++			case SPA_CHOICE_Step:
++				ssep = "[ ";
++				sep = ", ";
++				esep = " ]";
++				break;
++			default:
++			case SPA_CHOICE_Enum:
++			case SPA_CHOICE_Flags:
++				ssep = "{ ";
++				sep = ", ";
++				esep = " }";
++				break;
++			}
++
++			fprintf(stderr, "%s", ssep);
++
++			for (i = 1; i < n_vals; i++) {
++				vals = SPA_MEMBER(vals, size, void);
++				if (i > 1)
++					fprintf(stderr, "%s", sep);
++				spa_debug_format_value(ti ? ti->values : NULL, type, vals, size);
++			}
++			fprintf(stderr, "%s", esep);
++		}
++		fprintf(stderr, "\n");
++	}
++	return 0;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_FORMAT_H */
+diff --git a/third_party/pipewire/spa/debug/mem.h b/third_party/pipewire/spa/debug/mem.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/mem.h
+@@ -0,0 +1,60 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_MEM_H
++#define SPA_DEBUG_MEM_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/dict.h>
++
++#ifndef spa_debug
++#define spa_debug(...)	({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
++#endif
++
++static inline int spa_debug_mem(int indent, const void *data, size_t size)
++{
++	const uint8_t *t = (const uint8_t*)data;
++	char buffer[512];
++	size_t i;
++	int pos = 0;
++
++	for (i = 0; i < size; i++) {
++		if (i % 16 == 0)
++			pos = sprintf(buffer, "%p: ", &t[i]);
++		pos += sprintf(buffer + pos, "%02x ", t[i]);
++		if (i % 16 == 15 || i == size - 1) {
++			spa_debug("%*s" "%s", indent, "", buffer);
++		}
++	}
++	return 0;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_MEM_H */
+diff --git a/third_party/pipewire/spa/debug/node.h b/third_party/pipewire/spa/debug/node.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/node.h
+@@ -0,0 +1,57 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_NODE_H
++#define SPA_DEBUG_NODE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/node/node.h>
++#include <spa/debug/dict.h>
++
++#ifndef spa_debug
++#define spa_debug(...)	({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
++#endif
++
++static inline int spa_debug_port_info(int indent, const struct spa_port_info *info)
++{
++        spa_debug("%*s" "struct spa_port_info %p:", indent, "", info);
++        spa_debug("%*s" " flags: \t%08" PRIx64, indent, "", info->flags);
++        spa_debug("%*s" " rate: \t%d/%d", indent, "", info->rate.num, info->rate.denom);
++        spa_debug("%*s" " props:", indent, "");
++        if (info->props)
++                spa_debug_dict(indent + 2, info->props);
++        else
++                spa_debug("%*s" "  none", indent, "");
++        return 0;
++}
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_NODE_H */
+diff --git a/third_party/pipewire/spa/debug/pod.h b/third_party/pipewire/spa/debug/pod.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/pod.h
+@@ -0,0 +1,207 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_POD_H
++#define SPA_DEBUG_POD_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/debug/mem.h>
++#include <spa/debug/types.h>
++#include <spa/pod/pod.h>
++#include <spa/pod/iter.h>
++
++#ifndef spa_debug
++#define spa_debug(...)	({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
++#endif
++
++static inline int
++spa_debug_pod_value(int indent, const struct spa_type_info *info,
++		uint32_t type, void *body, uint32_t size)
++{
++	switch (type) {
++	case SPA_TYPE_Bool:
++		spa_debug("%*s" "Bool %s", indent, "", (*(int32_t *) body) ? "true" : "false");
++		break;
++	case SPA_TYPE_Id:
++		spa_debug("%*s" "Id %-8d (%s)", indent, "", *(int32_t *) body,
++		       spa_debug_type_find_name(info, *(int32_t *) body));
++		break;
++	case SPA_TYPE_Int:
++		spa_debug("%*s" "Int %d", indent, "", *(int32_t *) body);
++		break;
++	case SPA_TYPE_Long:
++		spa_debug("%*s" "Long %" PRIi64 "", indent, "", *(int64_t *) body);
++		break;
++	case SPA_TYPE_Float:
++		spa_debug("%*s" "Float %f", indent, "", *(float *) body);
++		break;
++	case SPA_TYPE_Double:
++		spa_debug("%*s" "Double %f", indent, "", *(double *) body);
++		break;
++	case SPA_TYPE_String:
++		spa_debug("%*s" "String \"%s\"", indent, "", (char *) body);
++		break;
++	case SPA_TYPE_Fd:
++		spa_debug("%*s" "Fd %d", indent, "", *(int *) body);
++		break;
++	case SPA_TYPE_Pointer:
++	{
++		struct spa_pod_pointer_body *b = (struct spa_pod_pointer_body *)body;
++		spa_debug("%*s" "Pointer %s %p", indent, "",
++		       spa_debug_type_find_name(SPA_TYPE_ROOT, b->type), b->value);
++		break;
++	}
++	case SPA_TYPE_Rectangle:
++	{
++		struct spa_rectangle *r = (struct spa_rectangle *)body;
++		spa_debug("%*s" "Rectangle %dx%d", indent, "", r->width, r->height);
++		break;
++	}
++	case SPA_TYPE_Fraction:
++	{
++		struct spa_fraction *f = (struct spa_fraction *)body;
++		spa_debug("%*s" "Fraction %d/%d", indent, "", f->num, f->denom);
++		break;
++	}
++	case SPA_TYPE_Bitmap:
++		spa_debug("%*s" "Bitmap", indent, "");
++		break;
++	case SPA_TYPE_Array:
++	{
++		struct spa_pod_array_body *b = (struct spa_pod_array_body *)body;
++		void *p;
++		const struct spa_type_info *ti = spa_debug_type_find(SPA_TYPE_ROOT, b->child.type);
++
++		spa_debug("%*s" "Array: child.size %d, child.type %s", indent, "",
++		       b->child.size, ti ? ti->name : "unknown");
++
++		SPA_POD_ARRAY_BODY_FOREACH(b, size, p)
++			spa_debug_pod_value(indent + 2, info, b->child.type, p, b->child.size);
++		break;
++	}
++	case SPA_TYPE_Choice:
++	{
++		struct spa_pod_choice_body *b = (struct spa_pod_choice_body *)body;
++		void *p;
++		const struct spa_type_info *ti = spa_debug_type_find(spa_type_choice, b->type);
++
++		spa_debug("%*s" "Choice: type %s, flags %08x %d %d", indent, "",
++		       ti ? ti->name : "unknown", b->flags, size, b->child.size);
++
++		SPA_POD_CHOICE_BODY_FOREACH(b, size, p)
++			spa_debug_pod_value(indent + 2, info, b->child.type, p, b->child.size);
++		break;
++	}
++	case SPA_TYPE_Struct:
++	{
++		struct spa_pod *b = (struct spa_pod *)body, *p;
++		spa_debug("%*s" "Struct: size %d", indent, "", size);
++		SPA_POD_FOREACH(b, size, p)
++			spa_debug_pod_value(indent + 2, info, p->type, SPA_POD_BODY(p), p->size);
++		break;
++	}
++	case SPA_TYPE_Object:
++	{
++		struct spa_pod_object_body *b = (struct spa_pod_object_body *)body;
++		struct spa_pod_prop *p;
++		const struct spa_type_info *ti, *ii;
++
++		ti = spa_debug_type_find(info, b->type);
++		ii = ti ? spa_debug_type_find(ti->values, 0) : NULL;
++		ii = ii ? spa_debug_type_find(ii->values, b->id) : NULL;
++
++		spa_debug("%*s" "Object: size %d, type %s (%d), id %s (%d)", indent, "", size,
++		       ti ? ti->name : "unknown", b->type, ii ? ii->name : "unknown", b->id);
++
++		info = ti ? ti->values : info;
++
++		SPA_POD_OBJECT_BODY_FOREACH(b, size, p) {
++			ii = spa_debug_type_find(info, p->key);
++
++			spa_debug("%*s" "Prop: key %s (%d), flags %08x", indent+2, "",
++					ii ? ii->name : "unknown", p->key, p->flags);
++
++			spa_debug_pod_value(indent + 4, ii ? ii->values : NULL,
++					p->value.type,
++					SPA_POD_CONTENTS(struct spa_pod_prop, p),
++					p->value.size);
++		}
++		break;
++	}
++	case SPA_TYPE_Sequence:
++	{
++		struct spa_pod_sequence_body *b = (struct spa_pod_sequence_body *)body;
++		const struct spa_type_info *ti, *ii;
++		struct spa_pod_control *c;
++
++		ti = spa_debug_type_find(info, b->unit);
++
++		spa_debug("%*s" "Sequence: size %d, unit %s", indent, "", size,
++		       ti ? ti->name : "unknown");
++
++		SPA_POD_SEQUENCE_BODY_FOREACH(b, size, c) {
++			ii = spa_debug_type_find(spa_type_control, c->type);
++
++			spa_debug("%*s" "Control: offset %d, type %s", indent+2, "",
++					c->offset, ii ? ii->name : "unknown");
++
++			spa_debug_pod_value(indent + 4, ii ? ii->values : NULL,
++					c->value.type,
++					SPA_POD_CONTENTS(struct spa_pod_control, c),
++					c->value.size);
++		}
++		break;
++	}
++	case SPA_TYPE_Bytes:
++		spa_debug("%*s" "Bytes", indent, "");
++		spa_debug_mem(indent + 2, body, size);
++		break;
++	case SPA_TYPE_None:
++		spa_debug("%*s" "None", indent, "");
++		spa_debug_mem(indent + 2, body, size);
++		break;
++	default:
++		spa_debug("%*s" "unhandled POD type %d", indent, "", type);
++		break;
++	}
++	return 0;
++}
++
++static inline int spa_debug_pod(int indent,
++		const struct spa_type_info *info, const struct spa_pod *pod)
++{
++	return spa_debug_pod_value(indent, info ? info : SPA_TYPE_ROOT,
++			SPA_POD_TYPE(pod),
++			SPA_POD_BODY(pod),
++			SPA_POD_BODY_SIZE(pod));
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_POD_H */
+diff --git a/third_party/pipewire/spa/debug/types.h b/third_party/pipewire/spa/debug/types.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/debug/types.h
+@@ -0,0 +1,98 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEBUG_TYPES_H
++#define SPA_DEBUG_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/type-info.h>
++
++#include <string.h>
++
++static inline const struct spa_type_info *spa_debug_type_find(const struct spa_type_info *info, uint32_t type)
++{
++	const struct spa_type_info *res;
++
++	if (info == NULL)
++		info = SPA_TYPE_ROOT;
++
++	while (info && info->name) {
++		if (info->type == SPA_ID_INVALID) {
++			if (info->values && (res = spa_debug_type_find(info->values, type)))
++				return res;
++		}
++		else if (info->type == type)
++			return info;
++		info++;
++	}
++	return NULL;
++}
++
++static inline const char *spa_debug_type_short_name(const char *name)
++{
++	const char *h;
++	if ((h = strrchr(name, ':')) != NULL)
++		name = h + 1;
++	return name;
++}
++
++static inline const char *spa_debug_type_find_name(const struct spa_type_info *info, uint32_t type)
++{
++	if ((info = spa_debug_type_find(info, type)) == NULL)
++		return NULL;
++	return info->name;
++}
++
++static inline const char *spa_debug_type_find_short_name(const struct spa_type_info *info, uint32_t type)
++{
++	const char *str;
++	if ((str = spa_debug_type_find_name(info, type)) == NULL)
++		return NULL;
++	return spa_debug_type_short_name(str);
++}
++
++static inline uint32_t spa_debug_type_find_type(const struct spa_type_info *info, const char *name)
++{
++	if (info == NULL)
++		info = SPA_TYPE_ROOT;
++
++	while (info && info->name) {
++		uint32_t res;
++		if (strcmp(info->name, name) == 0)
++			return info->type;
++		if (info->values && (res = spa_debug_type_find_type(info->values, name)) != SPA_ID_INVALID)
++			return res;
++		info++;
++	}
++	return SPA_ID_INVALID;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEBUG_NODE_H */
+diff --git a/third_party/pipewire/spa/graph/graph.h b/third_party/pipewire/spa/graph/graph.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/graph/graph.h
+@@ -0,0 +1,352 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_GRAPH_H
++#define SPA_GRAPH_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/list.h>
++#include <spa/utils/hook.h>
++#include <spa/node/node.h>
++#include <spa/node/io.h>
++
++#ifndef spa_debug
++#define spa_debug(...)
++#endif
++
++struct spa_graph;
++struct spa_graph_node;
++struct spa_graph_link;
++struct spa_graph_port;
++
++struct spa_graph_state {
++	int status;			/**< current status */
++	int32_t required;		/**< required number of signals */
++	int32_t pending;		/**< number of pending signals */
++};
++
++static inline void spa_graph_state_reset(struct spa_graph_state *state)
++{
++	state->pending = state->required;
++}
++
++struct spa_graph_link {
++	struct spa_list link;
++	struct spa_graph_state *state;
++	int (*signal) (void *data);
++	void *signal_data;
++};
++
++#define spa_graph_link_signal(l)	((l)->signal((l)->signal_data))
++
++#define spa_graph_state_dec(s,c) (__atomic_sub_fetch(&(s)->pending, c, __ATOMIC_SEQ_CST) == 0)
++
++static inline int spa_graph_link_trigger(struct spa_graph_link *link)
++{
++	struct spa_graph_state *state = link->state;
++
++	spa_debug("link %p: state %p: pending %d/%d", link, state,
++                        state->pending, state->required);
++
++	if (spa_graph_state_dec(state, 1))
++		spa_graph_link_signal(link);
++
++        return state->status;
++}
++struct spa_graph {
++	uint32_t flags;			/* flags */
++	struct spa_graph_node *parent;	/* parent node or NULL when driver */
++	struct spa_graph_state *state;	/* state of graph */
++	struct spa_list nodes;		/* list of nodes of this graph */
++};
++
++struct spa_graph_node_callbacks {
++#define SPA_VERSION_GRAPH_NODE_CALLBACKS	0
++	uint32_t version;
++
++	int (*process) (void *data, struct spa_graph_node *node);
++	int (*reuse_buffer) (void *data, struct spa_graph_node *node,
++			uint32_t port_id, uint32_t buffer_id);
++};
++
++struct spa_graph_node {
++	struct spa_list link;		/**< link in graph nodes list */
++	struct spa_graph *graph;	/**< owner graph */
++	struct spa_list ports[2];	/**< list of input and output ports */
++	struct spa_list links;		/**< list of links to next nodes */
++	uint32_t flags;			/**< node flags */
++	struct spa_graph_state *state;	/**< state of the node */
++	struct spa_graph_link graph_link;	/**< link in graph */
++	struct spa_graph *subgraph;	/**< subgraph or NULL */
++	struct spa_callbacks callbacks;
++	struct spa_list sched_link;	/**< link for scheduler */
++};
++
++#define spa_graph_node_call(n,method,version,...)			\
++({									\
++	int __res = 0;							\
++	spa_callbacks_call_res(&(n)->callbacks,				\
++			struct spa_graph_node_callbacks, __res,		\
++			method, version, ##__VA_ARGS__);		\
++	__res;								\
++})
++
++#define spa_graph_node_process(n)		spa_graph_node_call(n, process, 0, n)
++#define spa_graph_node_reuse_buffer(n,p,i)	spa_graph_node_call(n, reuse_buffer, 0, n, p, i)
++
++struct spa_graph_port {
++	struct spa_list link;		/**< link in node port list */
++	struct spa_graph_node *node;	/**< owner node */
++	enum spa_direction direction;	/**< port direction */
++	uint32_t port_id;		/**< port id */
++	uint32_t flags;			/**< port flags */
++	struct spa_graph_port *peer;	/**< peer */
++};
++
++static inline int spa_graph_node_trigger(struct spa_graph_node *node)
++{
++	struct spa_graph_link *l;
++	spa_debug("node %p trigger", node);
++	spa_list_for_each(l, &node->links, link)
++		spa_graph_link_trigger(l);
++	return 0;
++}
++
++static inline int spa_graph_run(struct spa_graph *graph)
++{
++	struct spa_graph_node *n, *t;
++	struct spa_list pending;
++
++	spa_graph_state_reset(graph->state);
++	spa_debug("graph %p run with state %p pending %d/%d", graph, graph->state,
++			graph->state->pending, graph->state->required);
++
++	spa_list_init(&pending);
++
++	spa_list_for_each(n, &graph->nodes, link) {
++		struct spa_graph_state *s = n->state;
++		spa_graph_state_reset(s);
++		spa_debug("graph %p node %p: state %p pending %d/%d status %d", graph, n,
++				s, s->pending, s->required, s->status);
++		if (--s->pending == 0)
++			spa_list_append(&pending, &n->sched_link);
++	}
++	spa_list_for_each_safe(n, t, &pending, sched_link)
++		spa_graph_node_process(n);
++
++	return 0;
++}
++
++static inline int spa_graph_finish(struct spa_graph *graph)
++{
++	spa_debug("graph %p finish", graph);
++	if (graph->parent)
++		return spa_graph_node_trigger(graph->parent);
++	return 0;
++}
++static inline int spa_graph_link_signal_node(void *data)
++{
++	struct spa_graph_node *node = (struct spa_graph_node *)data;
++	spa_debug("node %p call process", node);
++	return spa_graph_node_process(node);
++}
++
++static inline int spa_graph_link_signal_graph(void *data)
++{
++	struct spa_graph_node *node = (struct spa_graph_node *)data;
++	return spa_graph_finish(node->graph);
++}
++
++static inline void spa_graph_init(struct spa_graph *graph, struct spa_graph_state *state)
++{
++	spa_list_init(&graph->nodes);
++	graph->flags = 0;
++	graph->state = state;
++	spa_debug("graph %p init state %p", graph, state);
++}
++
++static inline void
++spa_graph_link_add(struct spa_graph_node *out,
++		   struct spa_graph_state *state,
++		   struct spa_graph_link *link)
++{
++	link->state = state;
++	state->required++;
++	spa_debug("node %p add link %p to state %p %d", out, link, state, state->required);
++	spa_list_append(&out->links, &link->link);
++}
++
++static inline void spa_graph_link_remove(struct spa_graph_link *link)
++{
++	link->state->required--;
++	spa_debug("link %p state %p remove %d", link, link->state, link->state->required);
++	spa_list_remove(&link->link);
++}
++
++static inline void
++spa_graph_node_init(struct spa_graph_node *node, struct spa_graph_state *state)
++{
++	spa_list_init(&node->ports[SPA_DIRECTION_INPUT]);
++	spa_list_init(&node->ports[SPA_DIRECTION_OUTPUT]);
++	spa_list_init(&node->links);
++	node->flags = 0;
++	node->subgraph = NULL;
++	node->state = state;
++	node->state->required = node->state->pending = 0;
++	node->state->status = SPA_STATUS_OK;
++	node->graph_link.signal = spa_graph_link_signal_graph;
++	node->graph_link.signal_data = node;
++	spa_debug("node %p init state %p", node, state);
++}
++
++
++static inline int spa_graph_node_impl_sub_process(void *data, struct spa_graph_node *node)
++{
++	struct spa_graph *graph = node->subgraph;
++	spa_debug("node %p: sub process %p", node, graph);
++	return spa_graph_run(graph);
++}
++
++static const struct spa_graph_node_callbacks spa_graph_node_sub_impl_default = {
++	SPA_VERSION_GRAPH_NODE_CALLBACKS,
++	.process = spa_graph_node_impl_sub_process,
++};
++
++static inline void spa_graph_node_set_subgraph(struct spa_graph_node *node,
++		struct spa_graph *subgraph)
++{
++	node->subgraph = subgraph;
++	subgraph->parent = node;
++	spa_debug("node %p set subgraph %p", node, subgraph);
++}
++
++static inline void
++spa_graph_node_set_callbacks(struct spa_graph_node *node,
++		const struct spa_graph_node_callbacks *callbacks,
++		void *data)
++{
++	node->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
++}
++
++static inline void
++spa_graph_node_add(struct spa_graph *graph,
++		   struct spa_graph_node *node)
++{
++	node->graph = graph;
++	spa_list_append(&graph->nodes, &node->link);
++	node->state->required++;
++	spa_debug("node %p add to graph %p, state %p required %d",
++			node, graph, node->state, node->state->required);
++	spa_graph_link_add(node, graph->state, &node->graph_link);
++}
++
++static inline void spa_graph_node_remove(struct spa_graph_node *node)
++{
++	spa_debug("node %p remove from graph %p, state %p required %d",
++			node, node->graph, node->state, node->state->required);
++	spa_graph_link_remove(&node->graph_link);
++	node->state->required--;
++	spa_list_remove(&node->link);
++}
++
++
++static inline void
++spa_graph_port_init(struct spa_graph_port *port,
++		    enum spa_direction direction,
++		    uint32_t port_id,
++		    uint32_t flags)
++{
++	spa_debug("port %p init type %d id %d", port, direction, port_id);
++	port->direction = direction;
++	port->port_id = port_id;
++	port->flags = flags;
++}
++
++static inline void
++spa_graph_port_add(struct spa_graph_node *node,
++		   struct spa_graph_port *port)
++{
++	spa_debug("port %p add to node %p", port, node);
++	port->node = node;
++	spa_list_append(&node->ports[port->direction], &port->link);
++}
++
++static inline void spa_graph_port_remove(struct spa_graph_port *port)
++{
++	spa_debug("port %p remove", port);
++	spa_list_remove(&port->link);
++}
++
++static inline void
++spa_graph_port_link(struct spa_graph_port *out, struct spa_graph_port *in)
++{
++	spa_debug("port %p link to %p %p %p", out, in, in->node, in->node->state);
++	out->peer = in;
++	in->peer = out;
++}
++
++static inline void
++spa_graph_port_unlink(struct spa_graph_port *port)
++{
++	spa_debug("port %p unlink from %p", port, port->peer);
++	if (port->peer) {
++		port->peer->peer = NULL;
++		port->peer = NULL;
++	}
++}
++
++static inline int spa_graph_node_impl_process(void *data, struct spa_graph_node *node)
++{
++	struct spa_node *n = (struct spa_node *)data;
++	struct spa_graph_state *state = node->state;
++
++	spa_debug("node %p: process state %p: %d, node %p", node, state, state->status, n);
++	if ((state->status = spa_node_process(n)) != SPA_STATUS_OK)
++		spa_graph_node_trigger(node);
++
++        return state->status;
++}
++
++static inline int spa_graph_node_impl_reuse_buffer(void *data, struct spa_graph_node *node,
++		uint32_t port_id, uint32_t buffer_id)
++{
++	struct spa_node *n = (struct spa_node *)data;
++	return spa_node_port_reuse_buffer(n, port_id, buffer_id);
++}
++
++static const struct spa_graph_node_callbacks spa_graph_node_impl_default = {
++	SPA_VERSION_GRAPH_NODE_CALLBACKS,
++	.process = spa_graph_node_impl_process,
++	.reuse_buffer = spa_graph_node_impl_reuse_buffer,
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_GRAPH_H */
+diff --git a/third_party/pipewire/spa/monitor/device.h b/third_party/pipewire/spa/monitor/device.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/monitor/device.h
+@@ -0,0 +1,297 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEVICE_H
++#define SPA_DEVICE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++#include <spa/utils/dict.h>
++#include <spa/pod/event.h>
++
++/**
++ * spa_device:
++ *
++ * The device interface can be used to monitor all kinds of devices
++ * and create objects as a result. Objects a typically other
++ * Devices or Nodes.
++ *
++ */
++#define SPA_TYPE_INTERFACE_Device	SPA_TYPE_INFO_INTERFACE_BASE "Device"
++
++#define SPA_VERSION_DEVICE		0
++struct spa_device { struct spa_interface iface; };
++
++/**
++ * Information about the device and parameters it supports
++ *
++ * This information is part of the info event on a device.
++ */
++struct spa_device_info {
++#define SPA_VERSION_DEVICE_INFO 0
++	uint32_t version;
++
++#define SPA_DEVICE_CHANGE_MASK_FLAGS		(1u<<0)
++#define SPA_DEVICE_CHANGE_MASK_PROPS		(1u<<1)
++#define SPA_DEVICE_CHANGE_MASK_PARAMS		(1u<<2)
++	uint64_t change_mask;
++	uint64_t flags;
++	const struct spa_dict *props;		/**< device properties */
++	struct spa_param_info *params;		/**< supported parameters */
++	uint32_t n_params;			/**< number of elements in params */
++};
++
++#define SPA_DEVICE_INFO_INIT()	(struct spa_device_info){ SPA_VERSION_DEVICE_INFO, }
++
++/**
++ * Information about a device object
++ *
++ * This information is part of the object_info event on the device.
++ */
++struct spa_device_object_info {
++#define SPA_VERSION_DEVICE_OBJECT_INFO 0
++	uint32_t version;
++
++	const char *type;			/**< the object type managed by this device */
++	const char *factory_name;		/**< a factory name that implements the object */
++
++#define SPA_DEVICE_OBJECT_CHANGE_MASK_FLAGS	(1u<<0)
++#define SPA_DEVICE_OBJECT_CHANGE_MASK_PROPS	(1u<<1)
++	uint64_t change_mask;
++	uint64_t flags;
++	const struct spa_dict *props;		/**< extra object properties */
++};
++
++#define SPA_DEVICE_OBJECT_INFO_INIT()	(struct spa_device_object_info){ SPA_VERSION_DEVICE_OBJECT_INFO, }
++
++/** the result of spa_device_enum_params() */
++#define SPA_RESULT_TYPE_DEVICE_PARAMS	1
++struct spa_result_device_params {
++	uint32_t id;
++	uint32_t index;
++	uint32_t next;
++	struct spa_pod *param;
++};
++
++#define SPA_DEVICE_EVENT_INFO		0
++#define SPA_DEVICE_EVENT_RESULT		1
++#define SPA_DEVICE_EVENT_EVENT		2
++#define SPA_DEVICE_EVENT_OBJECT_INFO	3
++#define SPA_DEVICE_EVENT_NUM		4
++
++/**
++ * spa_device_events:
++ *
++ * Events are always emitted from the main thread
++ */
++struct spa_device_events {
++	/** version of the structure */
++#define SPA_VERSION_DEVICE_EVENTS	0
++	uint32_t version;
++
++	/** notify extra information about the device */
++	void (*info) (void *data, const struct spa_device_info *info);
++
++	/** notify a result */
++	void (*result) (void *data, int seq, int res, uint32_t type, const void *result);
++
++	/** a device event */
++	void (*event) (void *data, const struct spa_event *event);
++
++	/** info changed for an object managed by the device, info is NULL when
++	 * the object is removed */
++	void (*object_info) (void *data, uint32_t id,
++		const struct spa_device_object_info *info);
++};
++
++#define SPA_DEVICE_METHOD_ADD_LISTENER	0
++#define SPA_DEVICE_METHOD_SYNC		1
++#define SPA_DEVICE_METHOD_ENUM_PARAMS	2
++#define SPA_DEVICE_METHOD_SET_PARAM	3
++#define SPA_DEVICE_METHOD_NUM		4
++
++/**
++ * spa_device_methods:
++ */
++struct spa_device_methods {
++	/* the version of the methods. This can be used to expand this
++	 * structure in the future */
++#define SPA_VERSION_DEVICE_METHODS	0
++	uint32_t version;
++
++	/**
++	 * Set events to receive asynchronous notifications from
++	 * the device.
++	 *
++	 * Setting the events will trigger the info event and an
++	 * object_info event for each managed object on the new
++	 * listener.
++	 *
++	 * \param device a #spa_device
++	 * \param listener a listener
++	 * \param events a #struct spa_device_events
++	 * \param data data passed as first argument in functions of \a events
++	 * \return 0 on success
++	 *	   < 0 errno on error
++	 */
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct spa_device_events *events,
++			void *data);
++	/**
++	 * Perform a sync operation.
++	 *
++	 * This method will emit the result event with the given sequence
++	 * number synchronously or with the returned async return value
++	 * asynchronously.
++	 *
++	 * Because all methods are serialized in the device, this can be used
++	 * to wait for completion of all previous method calls.
++	 *
++	 * \param seq a sequence number
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL
++	 *         an async result
++	 */
++        int (*sync) (void *object, int seq);
++
++	/**
++	 * Enumerate the parameters of a device.
++	 *
++	 * Parameters are identified with an \a id. Some parameters can have
++	 * multiple values, see the documentation of the parameter id.
++	 *
++	 * Parameters can be filtered by passing a non-NULL \a filter.
++	 *
++	 * The result callback will be called at most \max times with a
++	 * struct spa_result_device_params as the result.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param device a \ref spa_device
++	 * \param seq a sequence number to pass to the result function
++	 * \param id the param id to enumerate
++	 * \param index the index of enumeration, pass 0 for the first item.
++	 * \param max the maximum number of items to iterate
++	 * \param filter and optional filter to use
++	 * \return 0 when there are no more parameters to enumerate
++	 *         -EINVAL when invalid arguments are given
++	 *         -ENOENT the parameter \a id is unknown
++	 *         -ENOTSUP when there are no parameters
++	 *                 implemented on \a device
++	 */
++	int (*enum_params) (void *object, int seq,
++			    uint32_t id, uint32_t index, uint32_t max,
++			    const struct spa_pod *filter);
++
++	/**
++	 * Set the configurable parameter in \a device.
++	 *
++	 * Usually, \a param will be obtained from enum_params and then
++	 * modified but it is also possible to set another spa_pod
++	 * as long as its keys and types match a supported object.
++	 *
++	 * Objects with property keys that are not known are ignored.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param device a \ref spa_device
++	 * \param id the parameter id to configure
++	 * \param flags additional flags
++	 * \param param the parameter to configure
++	 *
++	 * \return 0 on success
++	 *         -EINVAL when invalid arguments are given
++	 *         -ENOTSUP when there are no parameters implemented on \a device
++	 *         -ENOENT the parameter is unknown
++	 */
++	int (*set_param) (void *object,
++			  uint32_t id, uint32_t flags,
++			  const struct spa_pod *param);
++};
++
++#define spa_device_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_device *_o = o;					\
++	spa_interface_call_res(&_o->iface,				\
++			struct spa_device_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define spa_device_add_listener(d,...)	spa_device_method(d, add_listener, 0, __VA_ARGS__)
++#define spa_device_sync(d,...)		spa_device_method(d, sync, 0, __VA_ARGS__)
++#define spa_device_enum_params(d,...)	spa_device_method(d, enum_params, 0, __VA_ARGS__)
++#define spa_device_set_param(d,...)	spa_device_method(d, set_param, 0, __VA_ARGS__)
++
++#define SPA_KEY_DEVICE_ENUM_API		"device.enum.api"	/**< the api used to discover this
++								  *  device */
++#define SPA_KEY_DEVICE_API		"device.api"		/**< the api used by the device
++								  *  Ex. "udev", "alsa", "v4l2". */
++#define SPA_KEY_DEVICE_NAME		"device.name"		/**< the name of the device */
++#define SPA_KEY_DEVICE_ALIAS		"device.alias"		/**< alternative name of the device */
++#define SPA_KEY_DEVICE_NICK		"device.nick"		/**< the device short name */
++#define SPA_KEY_DEVICE_DESCRIPTION	"device.description"	/**< a device description */
++#define SPA_KEY_DEVICE_ICON		"device.icon"		/**< icon for the device. A base64 blob
++								  *  containing PNG image data */
++#define SPA_KEY_DEVICE_ICON_NAME	"device.icon-name"	/**< an XDG icon name for the device.
++								  *  Ex. "sound-card-speakers-usb" */
++#define SPA_KEY_DEVICE_PLUGGED_USEC	"device.plugged.usec"	/**< when the device was plugged */
++
++#define SPA_KEY_DEVICE_BUS_ID		"device.bus-id"		/**< the device bus-id */
++#define SPA_KEY_DEVICE_BUS_PATH		"device.bus-path"	/**< bus path to the device in the OS'
++								  *  format.
++								  *  Ex. "pci-0000:00:14.0-usb-0:3.2:1.0" */
++#define SPA_KEY_DEVICE_BUS		"device.bus"		/**< bus of the device if applicable. One of
++								   *  "isa", "pci", "usb", "firewire",
++								   *  "bluetooth" */
++#define SPA_KEY_DEVICE_SUBSYSTEM	"device.subsystem"	/**< device subsystem */
++#define SPA_KEY_DEVICE_SYSFS_PATH	"device.sysfs.path"	/**< device sysfs path */
++
++#define SPA_KEY_DEVICE_VENDOR_ID	"device.vendor.id"	/**< vendor ID if applicable */
++#define SPA_KEY_DEVICE_VENDOR_NAME	"device.vendor.name"	/**< vendor name if applicable */
++#define SPA_KEY_DEVICE_PRODUCT_ID	"device.product.id"	/**< product ID if applicable */
++#define SPA_KEY_DEVICE_PRODUCT_NAME	"device.product.name"	/**< product name if applicable */
++#define SPA_KEY_DEVICE_SERIAL		"device.serial"		/**< Serial number if applicable */
++#define SPA_KEY_DEVICE_CLASS		"device.class"		/**< device class */
++#define SPA_KEY_DEVICE_CAPABILITIES	"device.capabilities"	/**< api specific device capabilities */
++#define SPA_KEY_DEVICE_FORM_FACTOR	"device.form-factor"	/**< form factor if applicable. One of
++								  *  "internal", "speaker", "handset", "tv",
++								  *  "webcam", "microphone", "headset",
++								  *  "headphone", "hands-free", "car", "hifi",
++								  *  "computer", "portable" */
++#define SPA_KEY_DEVICE_PROFILE		"device.profile	"	/**< profile for the device */
++#define SPA_KEY_DEVICE_PROFILE_SET	"device.profile-set"	/**< profile set for the device */
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEVICE_H */
+diff --git a/third_party/pipewire/spa/monitor/event.h b/third_party/pipewire/spa/monitor/event.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/monitor/event.h
+@@ -0,0 +1,54 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2020 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_EVENT_DEVICE_H
++#define SPA_EVENT_DEVICE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/event.h>
++
++/* object id of SPA_TYPE_EVENT_Device */
++enum spa_device_event {
++	SPA_DEVICE_EVENT_ObjectConfig,
++};
++
++#define SPA_DEVICE_EVENT_ID(ev)	SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Device)
++#define SPA_DEVICE_EVENT_INIT(id) SPA_EVENT_INIT(SPA_TYPE_EVENT_Device, id)
++
++/* properties for SPA_TYPE_EVENT_Device */
++enum spa_event_device {
++	SPA_EVENT_DEVICE_START,
++
++	SPA_EVENT_DEVICE_Object,	/* an object id (Int) */
++	SPA_EVENT_DEVICE_Props,		/* properties for an object (SPA_TYPE_OBJECT_Props) */
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_EVENT_DEVICE */
+diff --git a/third_party/pipewire/spa/monitor/utils.h b/third_party/pipewire/spa/monitor/utils.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/monitor/utils.h
+@@ -0,0 +1,95 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DEVICE_UTILS_H
++#define SPA_DEVICE_UTILS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/builder.h>
++#include <spa/monitor/device.h>
++
++struct spa_result_device_params_data {
++	struct spa_pod_builder *builder;
++	struct spa_result_device_params data;
++};
++
++static inline void spa_result_func_device_params(void *data, int seq, int res,
++		uint32_t type, const void *result)
++{
++	struct spa_result_device_params_data *d =
++		(struct spa_result_device_params_data *)data;
++	const struct spa_result_device_params *r =
++		(const struct spa_result_device_params *)result;
++	uint32_t offset = d->builder->state.offset;
++	spa_pod_builder_raw_padded(d->builder, r->param, SPA_POD_SIZE(r->param));
++	d->data.next = r->next;
++	d->data.param = SPA_MEMBER(d->builder->data, offset, struct spa_pod);
++}
++
++static inline int spa_device_enum_params_sync(struct spa_device *device,
++			uint32_t id, uint32_t *index,
++			const struct spa_pod *filter,
++			struct spa_pod **param,
++			struct spa_pod_builder *builder)
++{
++	struct spa_result_device_params_data data = { builder, };
++	struct spa_hook listener = { 0 };
++	static const struct spa_device_events device_events = {
++		SPA_VERSION_DEVICE_EVENTS,
++		.result = spa_result_func_device_params,
++	};
++	int res;
++
++	spa_device_add_listener(device, &listener, &device_events, &data);
++	res = spa_device_enum_params(device, 0, id, *index, 1, filter);
++	spa_hook_remove(&listener);
++
++	if (data.data.param == NULL) {
++		if (res > 0)
++			res = 0;
++	} else {
++		*index = data.data.next;
++		*param = data.data.param;
++		res = 1;
++	}
++	return res;
++}
++
++#define spa_device_emit(hooks,method,version,...)				\
++		spa_hook_list_call_simple(hooks, struct spa_device_events,	\
++				method, version, ##__VA_ARGS__)
++
++#define spa_device_emit_info(hooks,i)		spa_device_emit(hooks,info, 0, i)
++#define spa_device_emit_result(hooks,s,r,t,res)	spa_device_emit(hooks,result, 0, s, r, t, res)
++#define spa_device_emit_event(hooks,e)		spa_device_emit(hooks,event, 0, e)
++#define spa_device_emit_object_info(hooks,id,i)	spa_device_emit(hooks,object_info, 0, id, i)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DEVICE_UTILS_H */
+diff --git a/third_party/pipewire/spa/node/command.h b/third_party/pipewire/spa/node/command.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/command.h
+@@ -0,0 +1,54 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_COMMAND_NODE_H
++#define SPA_COMMAND_NODE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/command.h>
++
++/* object id of SPA_TYPE_COMMAND_Node */
++enum spa_node_command {
++	SPA_NODE_COMMAND_Suspend,
++	SPA_NODE_COMMAND_Pause,
++	SPA_NODE_COMMAND_Start,
++	SPA_NODE_COMMAND_Enable,
++	SPA_NODE_COMMAND_Disable,
++	SPA_NODE_COMMAND_Flush,
++	SPA_NODE_COMMAND_Drain,
++	SPA_NODE_COMMAND_Marker,
++};
++
++#define SPA_NODE_COMMAND_ID(cmd)	SPA_COMMAND_ID(cmd, SPA_TYPE_COMMAND_Node)
++#define SPA_NODE_COMMAND_INIT(id)	SPA_COMMAND_INIT(SPA_TYPE_COMMAND_Node, id)
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_COMMAND_NODE_H */
+diff --git a/third_party/pipewire/spa/node/event.h b/third_party/pipewire/spa/node/event.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/event.h
+@@ -0,0 +1,48 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_EVENT_NODE_H
++#define SPA_EVENT_NODE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/event.h>
++
++/* object id of SPA_TYPE_EVENT_Node */
++enum spa_node_event {
++	SPA_NODE_EVENT_Error,
++	SPA_NODE_EVENT_Buffering,
++	SPA_NODE_EVENT_RequestRefresh,
++};
++
++#define SPA_NODE_EVENT_ID(ev)	SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Node)
++#define SPA_NODE_EVENT_INIT(id) SPA_EVENT_INIT(SPA_TYPE_EVENT_Node, id)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_EVENT_NODE_H */
+diff --git a/third_party/pipewire/spa/node/io.h b/third_party/pipewire/spa/node/io.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/io.h
+@@ -0,0 +1,294 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_IO_H
++#define SPA_IO_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/pod/pod.h>
++
++/** IO areas
++ *
++ * IO information for a port on a node. This is allocated
++ * by the host and configured on a node or all ports for which
++ * IO is requested.
++ *
++ * The plugin will communicate with the host through the IO
++ * areas.
++ */
++
++/** Different IO area types */
++enum spa_io_type {
++	SPA_IO_Invalid,
++	SPA_IO_Buffers,		/**< area to exchange buffers, struct spa_io_buffers */
++	SPA_IO_Range,		/**< expected byte range, struct spa_io_range */
++	SPA_IO_Clock,		/**< area to update clock information, struct spa_io_clock */
++	SPA_IO_Latency,		/**< latency reporting, struct spa_io_latency */
++	SPA_IO_Control,		/**< area for control messages, struct spa_io_sequence */
++	SPA_IO_Notify,		/**< area for notify messages, struct spa_io_sequence */
++	SPA_IO_Position,	/**< position information in the graph, struct spa_io_position */
++	SPA_IO_RateMatch,	/**< rate matching between nodes, struct spa_io_rate_match */
++	SPA_IO_Memory,		/**< memory pointer, struct spa_io_memory */
++};
++
++/**
++ * IO area to exchange buffers.
++ *
++ * A set of buffers should first be configured on the node/port.
++ * Further references to those buffers will be made by using the
++ * id of the buffer.
++ *
++ * If status is SPA_STATUS_OK, the host should ignore
++ * the io area.
++ *
++ * If status is SPA_STATUS_NEED_DATA, the host should:
++ * 1) recycle the buffer in buffer_id, if possible
++ * 2) prepare a new buffer and place the id in buffer_id.
++ *
++ * If status is SPA_STATUS_HAVE_DATA, the host should consume
++ * the buffer in buffer_id and set the state to
++ * SPA_STATUS_NEED_DATA when new data is requested.
++ *
++ * If status is SPA_STATUS_STOPPED, some error occurred on the
++ * port.
++ *
++ * If status is SPA_STATUS_DRAINED, data from the io area was
++ * used to drain.
++ *
++ * Status can also be a negative errno value to indicate errors.
++ * such as:
++ * -EINVAL: buffer_id is invalid
++ * -EPIPE: no more buffers available
++ */
++struct spa_io_buffers {
++#define SPA_STATUS_OK			0
++#define SPA_STATUS_NEED_DATA		(1<<0)
++#define SPA_STATUS_HAVE_DATA		(1<<1)
++#define SPA_STATUS_STOPPED		(1<<2)
++#define SPA_STATUS_DRAINED		(1<<3)
++	int32_t status;			/**< the status code */
++	uint32_t buffer_id;		/**< a buffer id */
++};
++
++#define SPA_IO_BUFFERS_INIT  (struct spa_io_buffers) { SPA_STATUS_OK, SPA_ID_INVALID, }
++
++/**
++ * IO area to exchange a memory region
++ */
++struct spa_io_memory {
++	int32_t status;			/**< the status code */
++	uint32_t size;			/**< the size of \a data */
++	void *data;			/**< a memory pointer */
++};
++#define SPA_IO_MEMORY_INIT  (struct spa_io_memory) { SPA_STATUS_OK, 0, NULL, }
++
++/** A range, suitable for input ports that can suggest a range to output ports */
++struct spa_io_range {
++	uint64_t offset;	/**< offset in range */
++	uint32_t min_size;	/**< minimum size of data */
++	uint32_t max_size;	/**< maximum size of data */
++};
++
++/**
++ * Absolute time reporting.
++ *
++ * Nodes that can report clocking information will receive this io block.
++ * The application sets the id. This is usually set as part of the
++ * position information but can also be set separately.
++ *
++ * The clock counts the elapsed time according to the clock provider
++ * since the provider was last started.
++ */
++struct spa_io_clock {
++	uint32_t flags;			/**< clock flags */
++	uint32_t id;			/**< unique clock id, set by application */
++	char name[64];			/**< clock name prefixed with API, set by node. The clock name
++					  *  is unique per clock and can be used to check if nodes
++					  *  share the same clock. */
++	uint64_t nsec;			/**< time in nanoseconds against monotonic clock */
++	struct spa_fraction rate;	/**< rate for position/duration/delay */
++	uint64_t position;		/**< current position */
++	uint64_t duration;		/**< duration of current cycle */
++	int64_t delay;			/**< delay between position and hardware,
++					  *  positive for capture, negative for playback */
++	double rate_diff;		/**< rate difference between clock and monotonic time */
++	uint64_t next_nsec;		/**< extimated next wakeup time in nanoseconds */
++	uint32_t padding[8];
++};
++
++/* the size of the video in this cycle */
++struct spa_io_video_size {
++#define SPA_IO_VIDEO_SIZE_VALID		(1<<0)
++	uint32_t flags;			/**< optional flags */
++	uint32_t stride;		/**< video stride in bytes */
++	struct spa_rectangle size;	/**< the video size */
++	struct spa_fraction framerate;  /**< the minimum framerate, the cycle duration is
++					  *  always smaller to ensure there is only one
++					  *  video frame per cycle. */
++	uint32_t padding[4];
++};
++
++/** latency reporting */
++struct spa_io_latency {
++	struct spa_fraction rate;	/**< rate for min/max */
++	uint64_t min;			/**< min latency */
++	uint64_t max;			/**< max latency */
++};
++
++/** control stream, io area for SPA_IO_Control and SPA_IO_Notify */
++struct spa_io_sequence {
++	struct spa_pod_sequence sequence;	/**< sequence of timed events */
++};
++
++/** bar and beat segment */
++struct spa_io_segment_bar {
++#define SPA_IO_SEGMENT_BAR_FLAG_VALID		(1<<0)
++	uint32_t flags;			/**< extra flags */
++	uint32_t offset;		/**< offset in segment of this beat */
++	float signature_num;		/**< time signature numerator */
++	float signature_denom;		/**< time signature denominator */
++	double bpm;			/**< beats per minute */
++	double beat;			/**< current beat in segment */
++	uint32_t padding[8];
++};
++
++/** video frame segment */
++struct spa_io_segment_video {
++#define SPA_IO_SEGMENT_VIDEO_FLAG_VALID		(1<<0)
++#define SPA_IO_SEGMENT_VIDEO_FLAG_DROP_FRAME	(1<<1)
++#define SPA_IO_SEGMENT_VIDEO_FLAG_PULL_DOWN	(1<<2)
++#define SPA_IO_SEGMENT_VIDEO_FLAG_INTERLACED	(1<<3)
++	uint32_t flags;			/**< flags */
++	uint32_t offset;		/**< offset in segment */
++	struct spa_fraction framerate;
++	uint32_t hours;
++	uint32_t minutes;
++	uint32_t seconds;
++	uint32_t frames;
++	uint32_t field_count;		/**< 0 for progressive, 1 and 2 for interlaced */
++	uint32_t padding[11];
++};
++
++/**
++ * A segment converts a running time to a segment (stream) position.
++ *
++ * The segment position is valid when the current running time is between
++ * start and start + duration. The position is then
++ * calculated as:
++ *
++ *   (running time - start) * rate + position;
++ *
++ * Support for looping is done by specifying the LOOPING flags with a
++ * non-zero duration. When the running time reaches start + duration,
++ * duration is added to start and the loop repeats.
++ *
++ * Care has to be taken when the running time + clock.duration extends
++ * past the start + duration from the segment; the user should correctly
++ * wrap around and partially repeat the loop in the current cycle.
++ *
++ * Extra information can be placed in the segment by setting the valid flags
++ * and filling up the corresponding structures.
++ */
++struct spa_io_segment {
++	uint32_t version;
++#define SPA_IO_SEGMENT_FLAG_LOOPING	(1<<0)	/**< after the duration, the segment repeats */
++#define SPA_IO_SEGMENT_FLAG_NO_POSITION	(1<<1)	/**< position is invalid. The position can be invalid
++						  *  after a seek, for example, when the exact mapping
++						  *  of the extra segment info (bar, video, ...) to
++						  *  position has not been determined yet */
++	uint32_t flags;				/**< extra flags */
++	uint64_t start;				/**< value of running time when this
++						  *  info is active. Can be in the future for
++						  *  pending changes. It does not have to be in
++						  *  exact multiples of the clock duration. */
++	uint64_t duration;			/**< duration when this info becomes invalid expressed
++						  *  in running time. If the duration is 0, this
++						  *  segment extends to the next segment. If the
++						  *  segment becomes invalid and the looping flag is
++						  *  set, the segment repeats. */
++	double rate;				/**< overal rate of the segment, can be negative for
++						  *  backwards time reporting. */
++	uint64_t position;			/**< The position when the running time == start.
++						  *  can be invalid when the owner of the extra segment
++						  *  information has not yet made the mapping. */
++
++	struct spa_io_segment_bar bar;
++	struct spa_io_segment_video video;
++};
++
++enum spa_io_position_state {
++	SPA_IO_POSITION_STATE_STOPPED,
++	SPA_IO_POSITION_STATE_STARTING,
++	SPA_IO_POSITION_STATE_RUNNING,
++};
++
++/** the maximum number of segments visible in the future */
++#define SPA_IO_POSITION_MAX_SEGMENTS	8
++
++/**
++ * The position information adds extra meaning to the raw clock times.
++ *
++ * It is set on all nodes and the clock id will contain the clock of the
++ * driving node in the graph.
++ *
++ * The position information contains 1 or more segments that convert the
++ * raw clock times to a stream time. They are sorted based on their
++ * start times, and thus the order in which they will activate in
++ * the future. This makes it possible to look ahead in the scheduled
++ * segments and anticipate the changes in the timeline.
++ */
++struct spa_io_position {
++	struct spa_io_clock clock;		/**< clock position of driver, always valid and
++						  *  read only */
++	struct spa_io_video_size video;		/**< size of the video in the current cycle */
++	int64_t offset;				/**< an offset to subtract from the clock position
++						  *  to get a running time. This is the time that
++						  *  the state has been in the RUNNING state and the
++						  *  time that should be used to compare the segment
++						  *  start values against. */
++	uint32_t state;				/**< one of enum spa_io_position_state */
++
++	uint32_t n_segments;			/**< number of segments */
++	struct spa_io_segment segments[SPA_IO_POSITION_MAX_SEGMENTS];	/**< segments */
++};
++
++/** rate matching */
++struct spa_io_rate_match {
++	uint32_t delay;			/**< extra delay in samples for resampler */
++	uint32_t size;			/**< requested input size for resampler */
++	double rate;			/**< rate for resampler */
++#define SPA_IO_RATE_MATCH_FLAG_ACTIVE	(1 << 0)
++	uint32_t flags;			/**< extra flags */
++	uint32_t padding[7];
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_IO_H */
+diff --git a/third_party/pipewire/spa/node/keys.h b/third_party/pipewire/spa/node/keys.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/keys.h
+@@ -0,0 +1,54 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_NODE_KEYS_H
++#define SPA_NODE_KEYS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** node keys */
++#define SPA_KEY_NODE_NAME		"node.name"		/**< a node name */
++#define SPA_KEY_NODE_LATENCY		"node.latency"		/**< the requested node latency */
++
++#define SPA_KEY_NODE_DRIVER		"node.driver"		/**< the node can be a driver */
++#define SPA_KEY_NODE_ALWAYS_PROCESS	"node.always-process"	/**< call the process function even if
++								  *  not linked. */
++#define SPA_KEY_NODE_PAUSE_ON_IDLE	"node.pause-on-idle"	/**< if the node should be paused
++								  *  immediately when idle. */
++#define SPA_KEY_NODE_MONITOR		"node.monitor"		/**< the node has monitor ports */
++
++
++/** port keys */
++#define SPA_KEY_PORT_NAME		"port.name"		/**< a port name */
++#define SPA_KEY_PORT_ALIAS		"port.alias"		/**< a port alias */
++#define SPA_KEY_PORT_MONITOR		"port.monitor"		/**< this port is a monitor port */
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_NODE_KEYS_H */
+diff --git a/third_party/pipewire/spa/node/node.h b/third_party/pipewire/spa/node/node.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/node.h
+@@ -0,0 +1,662 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_NODE_H
++#define SPA_NODE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/type.h>
++#include <spa/utils/hook.h>
++#include <spa/buffer/buffer.h>
++#include <spa/node/event.h>
++#include <spa/node/command.h>
++
++
++/**
++ * A spa_node is a component that can consume and produce buffers.
++ */
++#define SPA_TYPE_INTERFACE_Node		SPA_TYPE_INFO_INTERFACE_BASE "Node"
++
++#define SPA_VERSION_NODE		0
++struct spa_node { struct spa_interface iface; };
++
++/**
++ * Node information structure
++ *
++ * Contains the basic node information.
++ */
++struct spa_node_info {
++	uint32_t max_input_ports;
++	uint32_t max_output_ports;
++#define SPA_NODE_CHANGE_MASK_FLAGS		(1u<<0)
++#define SPA_NODE_CHANGE_MASK_PROPS		(1u<<1)
++#define SPA_NODE_CHANGE_MASK_PARAMS		(1u<<2)
++	uint64_t change_mask;
++
++#define SPA_NODE_FLAG_RT			(1u<<0)	/**< node can do real-time processing */
++#define SPA_NODE_FLAG_IN_DYNAMIC_PORTS		(1u<<1)	/**< input ports can be added/removed */
++#define SPA_NODE_FLAG_OUT_DYNAMIC_PORTS		(1u<<2)	/**< output ports can be added/removed */
++#define SPA_NODE_FLAG_IN_PORT_CONFIG		(1u<<3)	/**< input ports can be reconfigured with
++							  *  PortConfig parameter */
++#define SPA_NODE_FLAG_OUT_PORT_CONFIG		(1u<<4)	/**< output ports can be reconfigured with
++							  *  PortConfig parameter */
++#define SPA_NODE_FLAG_NEED_CONFIGURE		(1u<<5)	/**< node needs configuration before it can
++							  *  be started. */
++#define SPA_NODE_FLAG_ASYNC			(1u<<6)	/**< the process function might not
++							  *  immediateley produce or consume data
++							  *  but might offload the work to a worker
++							  *  thread. */
++	uint64_t flags;
++	struct spa_dict *props;			/**< extra node properties */
++	struct spa_param_info *params;		/**< parameter information */
++	uint32_t n_params;			/**< number of items in \a params */
++};
++
++#define SPA_NODE_INFO_INIT()	(struct spa_node_info) { 0, }
++
++/**
++ * Port information structure
++ *
++ * Contains the basic port information.
++ */
++struct spa_port_info {
++#define SPA_PORT_CHANGE_MASK_FLAGS		(1u<<0)
++#define SPA_PORT_CHANGE_MASK_RATE		(1u<<1)
++#define SPA_PORT_CHANGE_MASK_PROPS		(1u<<2)
++#define SPA_PORT_CHANGE_MASK_PARAMS		(1u<<3)
++	uint64_t change_mask;
++
++#define SPA_PORT_FLAG_REMOVABLE			(1u<<0)	/**< port can be removed */
++#define SPA_PORT_FLAG_OPTIONAL			(1u<<1)	/**< processing on port is optional */
++#define SPA_PORT_FLAG_CAN_ALLOC_BUFFERS		(1u<<2)	/**< the port can allocate buffer data */
++#define SPA_PORT_FLAG_IN_PLACE			(1u<<3)	/**< the port can process data in-place and
++							 *   will need a writable input buffer */
++#define SPA_PORT_FLAG_NO_REF			(1u<<4)	/**< the port does not keep a ref on the buffer.
++							 *   This means the node will always completely
++							 *   consume the input buffer and it will be
++							 *   recycled after process. */
++#define SPA_PORT_FLAG_LIVE			(1u<<5)	/**< output buffers from this port are
++							 *   timestamped against a live clock. */
++#define SPA_PORT_FLAG_PHYSICAL			(1u<<6)	/**< connects to some device */
++#define SPA_PORT_FLAG_TERMINAL			(1u<<7)	/**< data was not created from this port
++							 *   or will not be made available on another
++							 *   port */
++#define SPA_PORT_FLAG_DYNAMIC_DATA		(1u<<8)	/**< data pointer on buffers can be changed.
++							 *   Only the buffer data marked as DYNAMIC
++							 *   can be changed. */
++	uint64_t flags;				/**< port flags */
++	struct spa_fraction rate;		/**< rate of sequence numbers on port */
++	const struct spa_dict *props;		/**< extra port properties */
++	struct spa_param_info *params;		/**< parameter information */
++	uint32_t n_params;			/**< number of items in \a params */
++};
++
++#define SPA_PORT_INFO_INIT()	(struct spa_port_info) { 0, }
++
++#define SPA_RESULT_TYPE_NODE_ERROR	1
++#define SPA_RESULT_TYPE_NODE_PARAMS	2
++
++/** an error result */
++struct spa_result_node_error {
++	const char *message;
++};
++
++/** the result of enum_params or port_enum_params. */
++struct spa_result_node_params {
++	uint32_t id;		/**< id of parameter */
++	uint32_t index;		/**< index of parameter */
++	uint32_t next;		/**< next index of iteration */
++	struct spa_pod *param;	/**< the result param */
++};
++
++#define SPA_NODE_EVENT_INFO		0
++#define SPA_NODE_EVENT_PORT_INFO	1
++#define SPA_NODE_EVENT_RESULT		2
++#define SPA_NODE_EVENT_EVENT		3
++#define SPA_NODE_EVENT_NUM		4
++
++/** events from the spa_node.
++ *
++ * All event are called from the main thread and multiple
++ * listeners can be registered for the events with
++ * spa_node_add_listener().
++ */
++struct spa_node_events {
++#define SPA_VERSION_NODE_EVENTS	0
++	uint32_t version;	/**< version of this structure */
++
++	/** Emitted when info changes */
++	void (*info) (void *data, const struct spa_node_info *info);
++
++	/** Emitted when port info changes, NULL when port is removed */
++	void (*port_info) (void *data,
++			enum spa_direction direction, uint32_t port,
++			const struct spa_port_info *info);
++
++	/** notify a result.
++	 *
++	 * Some methods will trigger a result event with an optional
++	 * result of the given type. Look at the documentation of the
++	 * method to know when to expect a result event.
++	 *
++	 * The result event can be called synchronously, as an event
++	 * called from inside the method itself, in which case the seq
++	 * number passed to the method will be passed unchanged.
++	 *
++	 * The result event will be called asynchronously when the
++	 * method returned an async return value. In this case, the seq
++	 * number in the result will match the async return value of
++	 * the method call. Users should match the seq number from
++	 * request to the reply.
++	 */
++	void (*result) (void *data, int seq, int res,
++			uint32_t type, const void *result);
++
++	/**
++	 * \param node a spa_node
++	 * \param event the event that was emitted
++	 *
++	 * This will be called when an out-of-bound event is notified
++	 * on \a node.
++	 */
++	void (*event) (void *data, const struct spa_event *event);
++};
++
++#define SPA_NODE_CALLBACK_READY		0
++#define SPA_NODE_CALLBACK_REUSE_BUFFER	1
++#define SPA_NODE_CALLBACK_XRUN		2
++#define SPA_NODE_CALLBACK_NUM		3
++
++/** Node callbacks
++ *
++ * Callbacks are called from the real-time data thread. Only
++ * one callback structure can be set on an spa_node.
++ */
++struct spa_node_callbacks {
++#define SPA_VERSION_NODE_CALLBACKS	0
++	uint32_t version;
++	/**
++	 * \param node a spa_node
++	 *
++	 * The node is ready for processing.
++	 *
++	 * When this function is NULL, synchronous operation is requested
++	 * on the ports.
++	 */
++	int (*ready) (void *data, int state);
++
++	/**
++	 * \param node a spa_node
++	 * \param port_id an input port_id
++	 * \param buffer_id the buffer id to be reused
++	 *
++	 * The node has a buffer that can be reused.
++	 *
++	 * When this function is NULL, the buffers to reuse will be set in
++	 * the io area of the input ports.
++	 */
++	int (*reuse_buffer) (void *data,
++			     uint32_t port_id,
++			     uint32_t buffer_id);
++
++	/**
++	 * \param data user data
++	 * \param trigger the timestamp in microseconds when the xrun happened
++	 * \param delay the amount of microseconds of xrun.
++	 * \param info an object with extra info (NULL for now)
++	 *
++	 * The node has encountered an over or underrun
++	 *
++	 * The info contains an object with more information
++	 */
++	int (*xrun) (void *data, uint64_t trigger, uint64_t delay,
++			struct spa_pod *info);
++};
++
++
++/** flags that can be passed to set_param and port_set_param functions */
++#define SPA_NODE_PARAM_FLAG_TEST_ONLY	(1 << 0)	/**< Just check if the param is accepted */
++#define SPA_NODE_PARAM_FLAG_FIXATE	(1 << 1)	/**< Fixate the non-optional unset fields */
++#define SPA_NODE_PARAM_FLAG_NEAREST	(1 << 2)	/**< Allow set fields to be rounded to the
++							  *  nearest allowed field value. */
++
++/** flags to pass to the use_buffers functions */
++#define SPA_NODE_BUFFERS_FLAG_ALLOC	(1 << 0)	/**< Allocate memory for the buffers. This flag
++							  *  is ignored when the port does not have the
++							  *  SPA_PORT_FLAG_CAN_ALLOC_BUFFERS set. */
++
++
++#define SPA_NODE_METHOD_ADD_LISTENER		0
++#define SPA_NODE_METHOD_SET_CALLBACKS		1
++#define SPA_NODE_METHOD_SYNC			2
++#define SPA_NODE_METHOD_ENUM_PARAMS		3
++#define SPA_NODE_METHOD_SET_PARAM		4
++#define SPA_NODE_METHOD_SET_IO			5
++#define SPA_NODE_METHOD_SEND_COMMAND		6
++#define SPA_NODE_METHOD_ADD_PORT		7
++#define SPA_NODE_METHOD_REMOVE_PORT		8
++#define SPA_NODE_METHOD_PORT_ENUM_PARAMS	9
++#define SPA_NODE_METHOD_PORT_SET_PARAM		10
++#define SPA_NODE_METHOD_PORT_USE_BUFFERS	11
++#define SPA_NODE_METHOD_PORT_SET_IO		12
++#define SPA_NODE_METHOD_PORT_REUSE_BUFFER	13
++#define SPA_NODE_METHOD_PROCESS			14
++#define SPA_NODE_METHOD_NUM			15
++
++/**
++ * Node methods
++ */
++struct spa_node_methods {
++	/* the version of the node methods. This can be used to expand this
++	 * structure in the future */
++#define SPA_VERSION_NODE_METHODS	0
++	uint32_t version;
++
++	/**
++	 * Adds an event listener on \a node.
++	 *
++	 * Setting the events will trigger the info event and a
++	 * port_info event for each managed port on the new
++	 * listener.
++	 *
++	 * \param node a #spa_node
++	 * \param listener a listener
++	 * \param events a #struct spa_node_events
++	 * \param data data passed as first argument in functions of \a events
++	 * \return 0 on success
++	 *	   < 0 errno on error
++	 */
++	int (*add_listener) (void *object,
++			struct spa_hook *listener,
++			const struct spa_node_events *events,
++			void *data);
++	/**
++	 * Set callbacks to on \a node.
++	 * if \a callbacks is NULL, the current callbacks are removed.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * All callbacks are called from the data thread.
++	 *
++	 * \param node a spa_node
++	 * \param callbacks callbacks to set
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL
++	 */
++	int (*set_callbacks) (void *object,
++			      const struct spa_node_callbacks *callbacks,
++			      void *data);
++	/**
++	 * Perform a sync operation.
++	 *
++	 * This method will emit the result event with the given sequence
++	 * number synchronously or with the returned async return value
++	 * asynchronously.
++	 *
++	 * Because all methods are serialized in the node, this can be used
++	 * to wait for completion of all previous method calls.
++	 *
++	 * \param seq a sequence number
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL
++	 *         an async result
++	 */
++	int (*sync) (void *object, int seq);
++
++	/**
++	 * Enumerate the parameters of a node.
++	 *
++	 * Parameters are identified with an \a id. Some parameters can have
++	 * multiple values, see the documentation of the parameter id.
++	 *
++	 * Parameters can be filtered by passing a non-NULL \a filter.
++	 *
++	 * The function will emit the result event up to \a max times with
++	 * the result value. The seq in the result will either be the \a seq
++	 * number when executed synchronously or the async return value of
++	 * this function when executed asynchronously.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param node a \ref spa_node
++	 * \param seq a sequence number to pass to the result event when
++	 *	this method is executed synchronously.
++	 * \param id the param id to enumerate
++	 * \param start the index of enumeration, pass 0 for the first item
++	 * \param max the maximum number of parameters to enumerate
++	 * \param filter and optional filter to use
++	 *
++	 * \return 0 when no more items can be iterated.
++	 *         -EINVAL when invalid arguments are given
++	 *         -ENOENT the parameter \a id is unknown
++	 *         -ENOTSUP when there are no parameters
++	 *                 implemented on \a node
++	 *         an async return value when the result event will be
++	 *             emitted later.
++	 */
++	int (*enum_params) (void *object, int seq,
++			    uint32_t id, uint32_t start, uint32_t max,
++			    const struct spa_pod *filter);
++
++	/**
++	 * Set the configurable parameter in \a node.
++	 *
++	 * Usually, \a param will be obtained from enum_params and then
++	 * modified but it is also possible to set another spa_pod
++	 * as long as its keys and types match a supported object.
++	 *
++	 * Objects with property keys that are not known are ignored.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param node a \ref spa_node
++	 * \param id the parameter id to configure
++	 * \param flags additional flags
++	 * \param param the parameter to configure
++	 *
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL
++	 *         -ENOTSUP when there are no parameters implemented on \a node
++	 *         -ENOENT the parameter is unknown
++	 */
++	int (*set_param) (void *object,
++			  uint32_t id, uint32_t flags,
++			  const struct spa_pod *param);
++
++	/**
++	 * Configure the given memory area with \a id on \a node. This
++	 * structure is allocated by the host and is used to exchange
++	 * data and parameters with the node.
++	 *
++	 * Setting an \a io of NULL will disable the node io.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param id the id of the io area, the available ids can be
++	 *        enumerated with the node parameters.
++	 * \param data a io area memory
++	 * \param size the size of \a data
++	 * \return 0 on success
++	 *         -EINVAL when invalid input is given
++	 *         -ENOENT when \a id is unknown
++	 *         -ENOSPC when \a size is too small
++	 */
++	int (*set_io) (void *object,
++		       uint32_t id, void *data, size_t size);
++
++	/**
++	 * Send a command to a node.
++	 *
++	 * Upon completion, a command might change the state of a node.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param node a  spa_node
++	 * \param command a spa_command
++	 * \return 0 on success
++	 *         -EINVAL when node or command is NULL
++	 *         -ENOTSUP when this node can't process commands
++	 *         -EINVAL \a command is an invalid command
++	 */
++	int (*send_command) (void *object, const struct spa_command *command);
++
++	/**
++	 * Make a new port with \a port_id. The caller should use the lowest unused
++	 * port id for the given \a direction.
++	 *
++	 * Port ids should be between 0 and max_ports as obtained from the info
++	 * event.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param node a  spa_node
++	 * \param direction a #enum spa_direction
++	 * \param port_id an unused port id
++	 * \param props extra properties
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL
++	 */
++	int (*add_port) (void *object,
++			enum spa_direction direction, uint32_t port_id,
++			const struct spa_dict *props);
++
++	/**
++	 * Remove a port with \a port_id.
++	 *
++	 * \param node a  spa_node
++	 * \param direction a #enum spa_direction
++	 * \param port_id a port id
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL or when port_id is unknown or
++	 *		when the port can't be removed.
++	 */
++	int (*remove_port) (void *object,
++			enum spa_direction direction, uint32_t port_id);
++
++	/**
++	 * Enumerate all possible parameters of \a id on \a port_id of \a node
++	 * that are compatible with \a filter.
++	 *
++	 * The result parameters can be queried and modified and ultimately be used
++	 * to call port_set_param.
++	 *
++	 * The function will emit the result event up to \a max times with
++	 * the result value. The seq in the result event will either be the
++	 * \a seq number when executed synchronously or the async return
++	 * value of this function when executed asynchronously.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param node a spa_node
++	 * \param seq a sequence number to pass to the result event when
++	 *	this method is executed synchronously.
++	 * \param direction an spa_direction
++	 * \param port_id the port to query
++	 * \param id the parameter id to query
++	 * \param start the first index to query, 0 to get the first item
++	 * \param max the maximum number of params to query
++	 * \param filter a parameter filter or NULL for no filter
++	 *
++	 * \return 0 when no more items can be iterated.
++	 *         -EINVAL when invalid parameters are given
++	 *         -ENOENT when \a id is unknown
++	 *         an async return value when the result event will be
++	 *             emitted later.
++	 */
++	int (*port_enum_params) (void *object, int seq,
++				 enum spa_direction direction, uint32_t port_id,
++				 uint32_t id, uint32_t start, uint32_t max,
++				 const struct spa_pod *filter);
++	/**
++	 * Set a parameter on \a port_id of \a node.
++	 *
++	 * When \a param is NULL, the parameter will be unset.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param node a #struct spa_node
++	 * \param direction a #enum spa_direction
++	 * \param port_id the port to configure
++	 * \param id the parameter id to set
++	 * \param flags optional flags
++	 * \param param a #struct spa_pod with the parameter to set
++	 * \return 0 on success
++	 *         1 on success, the value of \a param might have been
++	 *                changed depending on \a flags and the final value can be found by
++	 *                doing port_enum_params.
++	 *         -EINVAL when node is NULL or invalid arguments are given
++	 *         -ESRCH when one of the mandatory param
++	 *                 properties is not specified and SPA_NODE_PARAM_FLAG_FIXATE was
++	 *                 not set in \a flags.
++	 *         -ESRCH when the type or size of a property is not correct.
++	 *         -ENOENT when the param id is not found
++	 */
++	int (*port_set_param) (void *object,
++			       enum spa_direction direction,
++			       uint32_t port_id,
++			       uint32_t id, uint32_t flags,
++			       const struct spa_pod *param);
++
++	/**
++	 * Tell the port to use the given buffers
++	 *
++	 * When \a flags contains SPA_NODE_BUFFERS_FLAG_ALLOC, the data
++	 * in the buffers should point to an array of at least 1 data entry
++	 * with the desired supported type that will be filled by this function.
++	 *
++	 * The port should also have a spa_io_buffers io area configured to exchange
++	 * the buffers with the port.
++	 *
++	 * For an input port, all the buffers will remain dequeued.
++	 * Once a buffer has been queued on a port in the spa_io_buffers,
++	 * it should not be reused until the reuse_buffer callback is notified
++	 * or when the buffer has been returned in the spa_io_buffers of
++	 * the port.
++	 *
++	 * For output ports, all buffers will be queued in the port. When process
++	 * returns SPA_STATUS_HAVE_DATA, buffers are available in one or more
++	 * of the spa_io_buffers areas.
++	 *
++	 * When a buffer can be reused, port_reuse_buffer() should be called or the
++	 * buffer_id should be placed in the spa_io_buffers area before calling
++	 * process.
++	 *
++	 * Passing NULL as \a buffers will remove the reference that the port has
++	 * on the buffers.
++	 *
++	 * When this function returns async, use the spa_node_sync operation to
++	 * wait for completion.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param object an object implementing the interface
++	 * \param direction a port direction
++	 * \param port_id a port id
++	 * \param flags extra flags
++	 * \param buffers an array of buffer pointers
++	 * \param n_buffers number of elements in \a buffers
++	 * \return 0 on success
++	 */
++	int (*port_use_buffers) (void *object,
++				 enum spa_direction direction,
++				 uint32_t port_id,
++				 uint32_t flags,
++				 struct spa_buffer **buffers,
++				 uint32_t n_buffers);
++
++	/**
++	 * Configure the given memory area with \a id on \a port_id. This
++	 * structure is allocated by the host and is used to exchange
++	 * data and parameters with the port.
++	 *
++	 * Setting an \a io of NULL will disable the port io.
++	 *
++	 * This function must be called from the main thread.
++	 *
++	 * \param direction a spa_direction
++	 * \param port_id a port id
++	 * \param id the id of the io area, the available ids can be
++	 *        enumerated with the port parameters.
++	 * \param data a io area memory
++	 * \param size the size of \a data
++	 * \return 0 on success
++	 *         -EINVAL when invalid input is given
++	 *         -ENOENT when \a id is unknown
++	 *         -ENOSPC when \a size is too small
++	 */
++	int (*port_set_io) (void *object,
++			    enum spa_direction direction,
++			    uint32_t port_id,
++			    uint32_t id,
++			    void *data, size_t size);
++
++	/**
++	 * Tell an output port to reuse a buffer.
++	 *
++	 * This function must be called from the data thread.
++	 *
++	 * \param node a spa_node
++	 * \param port_id a port id
++	 * \param buffer_id a buffer id to reuse
++	 * \return 0 on success
++	 *         -EINVAL when node is NULL
++	 */
++	int (*port_reuse_buffer) (void *object, uint32_t port_id, uint32_t buffer_id);
++
++	/**
++	 * Process the node
++	 *
++	 * This function must be called from the data thread.
++	 *
++	 * Output io areas with SPA_STATUS_NEED_DATA will recycle the
++	 * buffers if any.
++	 *
++	 * Input areas with SPA_STATUS_HAVE_DATA are consumed if possible
++	 * and the status is set to SPA_STATUS_NEED_DATA or SPA_STATUS_OK.
++	 *
++	 * When the node has new output buffers, the SPA_STATUS_HAVE_DATA
++	 * bit will be set.
++	 *
++	 * When the node can accept new input in the next cycle, the
++	 * SPA_STATUS_NEED_DATA bit will be set.
++	 */
++	int (*process) (void *object);
++};
++
++#define spa_node_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_node *_n = o;					\
++	spa_interface_call_res(&_n->iface,				\
++			struct spa_node_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define spa_node_add_listener(n,...)		spa_node_method(n, add_listener, 0, __VA_ARGS__)
++#define spa_node_set_callbacks(n,...)		spa_node_method(n, set_callbacks, 0, __VA_ARGS__)
++#define spa_node_sync(n,...)			spa_node_method(n, sync, 0, __VA_ARGS__)
++#define spa_node_enum_params(n,...)		spa_node_method(n, enum_params, 0, __VA_ARGS__)
++#define spa_node_set_param(n,...)		spa_node_method(n, set_param, 0, __VA_ARGS__)
++#define spa_node_set_io(n,...)			spa_node_method(n, set_io, 0, __VA_ARGS__)
++#define spa_node_send_command(n,...)		spa_node_method(n, send_command, 0, __VA_ARGS__)
++#define spa_node_add_port(n,...)		spa_node_method(n, add_port, 0, __VA_ARGS__)
++#define spa_node_remove_port(n,...)		spa_node_method(n, remove_port, 0, __VA_ARGS__)
++#define spa_node_port_enum_params(n,...)	spa_node_method(n, port_enum_params, 0, __VA_ARGS__)
++#define spa_node_port_set_param(n,...)		spa_node_method(n, port_set_param, 0, __VA_ARGS__)
++#define spa_node_port_use_buffers(n,...)	spa_node_method(n, port_use_buffers, 0, __VA_ARGS__)
++#define spa_node_port_set_io(n,...)		spa_node_method(n, port_set_io, 0, __VA_ARGS__)
++
++#define spa_node_port_reuse_buffer(n,...)	spa_node_method(n, port_reuse_buffer, 0, __VA_ARGS__)
++#define spa_node_process(n)			spa_node_method(n, process, 0)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_NODE_H */
+diff --git a/third_party/pipewire/spa/node/type-info.h b/third_party/pipewire/spa/node/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/type-info.h
+@@ -0,0 +1,94 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_NODE_TYPES_H
++#define SPA_NODE_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/type-info.h>
++
++#include <spa/node/command.h>
++#include <spa/node/event.h>
++#include <spa/node/io.h>
++
++#define SPA_TYPE_INFO_IO			SPA_TYPE_INFO_ENUM_BASE "IO"
++#define SPA_TYPE_INFO_IO_BASE		SPA_TYPE_INFO_IO ":"
++
++static const struct spa_type_info spa_type_io[] = {
++	{ SPA_IO_Invalid, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Invalid", NULL },
++	{ SPA_IO_Buffers, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Buffers", NULL },
++	{ SPA_IO_Range, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Range", NULL },
++	{ SPA_IO_Clock, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Clock", NULL },
++	{ SPA_IO_Latency, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Latency", NULL },
++	{ SPA_IO_Control, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Control", NULL },
++	{ SPA_IO_Notify, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Notify", NULL },
++	{ SPA_IO_Position, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Position", NULL },
++	{ SPA_IO_RateMatch, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "RateMatch", NULL },
++	{ SPA_IO_Memory, SPA_TYPE_Int, SPA_TYPE_INFO_IO_BASE "Memory", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_NodeEvent			SPA_TYPE_INFO_EVENT_BASE "Node"
++#define SPA_TYPE_INFO_NODE_EVENT_BASE		SPA_TYPE_INFO_NodeEvent ":"
++
++static const struct spa_type_info spa_type_node_event_id[] = {
++	{ SPA_NODE_EVENT_Error,		 SPA_TYPE_Int, SPA_TYPE_INFO_NODE_EVENT_BASE "Error",   NULL },
++	{ SPA_NODE_EVENT_Buffering,	 SPA_TYPE_Int, SPA_TYPE_INFO_NODE_EVENT_BASE "Buffering", NULL },
++	{ SPA_NODE_EVENT_RequestRefresh, SPA_TYPE_Int, SPA_TYPE_INFO_NODE_EVENT_BASE "RequestRefresh", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++static const struct spa_type_info spa_type_node_event[] = {
++	{ 0, SPA_TYPE_Id, SPA_TYPE_INFO_NODE_EVENT_BASE, spa_type_node_event_id },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_NodeCommand			SPA_TYPE_INFO_COMMAND_BASE "Node"
++#define SPA_TYPE_INFO_NODE_COMMAND_BASE		SPA_TYPE_INFO_NodeCommand ":"
++
++static const struct spa_type_info spa_type_node_command_id[] = {
++	{ SPA_NODE_COMMAND_Suspend,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Suspend", NULL },
++	{ SPA_NODE_COMMAND_Pause,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Pause",   NULL },
++	{ SPA_NODE_COMMAND_Start,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Start",   NULL },
++	{ SPA_NODE_COMMAND_Enable,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Enable",  NULL },
++	{ SPA_NODE_COMMAND_Disable,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Disable", NULL },
++	{ SPA_NODE_COMMAND_Flush,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Flush",   NULL },
++	{ SPA_NODE_COMMAND_Drain,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Drain",   NULL },
++	{ SPA_NODE_COMMAND_Marker,	SPA_TYPE_Int, SPA_TYPE_INFO_NODE_COMMAND_BASE "Marker",  NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++static const struct spa_type_info spa_type_node_command[] = {
++	{ 0, SPA_TYPE_Id, SPA_TYPE_INFO_NODE_COMMAND_BASE, spa_type_node_command_id },
++	{ 0, 0, NULL, NULL },
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_NODE_TYPES_H */
+diff --git a/third_party/pipewire/spa/node/utils.h b/third_party/pipewire/spa/node/utils.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/node/utils.h
+@@ -0,0 +1,144 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_NODE_UTILS_H
++#define SPA_NODE_UTILS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/builder.h>
++
++#include <spa/node/node.h>
++
++struct spa_result_node_params_data {
++	struct spa_pod_builder *builder;
++	struct spa_result_node_params data;
++};
++
++static inline void spa_result_func_node_params(void *data,
++		int seq, int res, uint32_t type, const void *result)
++{
++	struct spa_result_node_params_data *d =
++		(struct spa_result_node_params_data *) data;
++	const struct spa_result_node_params *r =
++		(const struct spa_result_node_params *) result;
++	uint32_t offset = d->builder->state.offset;
++	spa_pod_builder_raw_padded(d->builder, r->param, SPA_POD_SIZE(r->param));
++	d->data.next = r->next;
++	d->data.param = SPA_MEMBER(d->builder->data, offset, struct spa_pod);
++}
++
++static inline int spa_node_enum_params_sync(struct spa_node *node,
++			uint32_t id, uint32_t *index,
++			const struct spa_pod *filter,
++			struct spa_pod **param,
++			struct spa_pod_builder *builder)
++{
++	struct spa_result_node_params_data data = { builder, };
++	struct spa_hook listener = { 0 };
++	static const struct spa_node_events node_events = {
++		SPA_VERSION_NODE_EVENTS,
++		.result = spa_result_func_node_params,
++	};
++	int res;
++
++	res = spa_node_add_listener(node, &listener, &node_events, &data);
++	if (res >= 0) {
++		res = spa_node_enum_params(node, 0, id, *index, 1, filter);
++		spa_hook_remove(&listener);
++	}
++
++	if (data.data.param == NULL) {
++		if (res > 0)
++			res = 0;
++	} else {
++		*index = data.data.next;
++		*param = data.data.param;
++		res = 1;
++	}
++	return res;
++}
++
++static inline int spa_node_port_enum_params_sync(struct spa_node *node,
++			enum spa_direction direction, uint32_t port_id,
++			uint32_t id, uint32_t *index,
++			const struct spa_pod *filter,
++			struct spa_pod **param,
++			struct spa_pod_builder *builder)
++{
++	struct spa_result_node_params_data data = { builder, };
++	struct spa_hook listener = { 0 };
++	static const struct spa_node_events node_events = {
++		SPA_VERSION_NODE_EVENTS,
++		.result = spa_result_func_node_params,
++	};
++	int res;
++
++	res = spa_node_add_listener(node, &listener, &node_events, &data);
++	if (res >= 0) {
++		res = spa_node_port_enum_params(node, 0, direction, port_id,
++				id, *index, 1, filter);
++		spa_hook_remove(&listener);
++	}
++
++	if (data.data.param == NULL) {
++		if (res > 0)
++			res = 0;
++	} else {
++		*index = data.data.next;
++		*param = data.data.param;
++		res = 1;
++	}
++	return res;
++}
++
++#define spa_node_emit(hooks,method,version,...)					\
++		spa_hook_list_call_simple(hooks, struct spa_node_events,	\
++				method, version, ##__VA_ARGS__)
++
++#define spa_node_emit_info(hooks,...)		spa_node_emit(hooks,info, 0, __VA_ARGS__)
++#define spa_node_emit_port_info(hooks,...)	spa_node_emit(hooks,port_info, 0, __VA_ARGS__)
++#define spa_node_emit_result(hooks,...)		spa_node_emit(hooks,result, 0, __VA_ARGS__)
++#define spa_node_emit_event(hooks,...)		spa_node_emit(hooks,event, 0, __VA_ARGS__)
++
++
++#define spa_node_call(callbacks,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;							\
++	spa_callbacks_call_res(callbacks, struct spa_node_callbacks,	\
++			_res, method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define spa_node_call_ready(hook,...)		spa_node_call(hook, ready, 0, __VA_ARGS__)
++#define spa_node_call_reuse_buffer(hook,...)	spa_node_call(hook, reuse_buffer, 0, __VA_ARGS__)
++#define spa_node_call_xrun(hook,...)		spa_node_call(hook, xrun, 0, __VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_NODE_UTILS_H */
+diff --git a/third_party/pipewire/spa/param/audio/format-utils.h b/third_party/pipewire/spa/param/audio/format-utils.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/audio/format-utils.h
+@@ -0,0 +1,105 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_AUDIO_FORMAT_UTILS_H
++#define SPA_PARAM_AUDIO_FORMAT_UTILS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++#include <spa/pod/parser.h>
++#include <spa/pod/builder.h>
++#include <spa/param/audio/format.h>
++#include <spa/param/format-utils.h>
++
++static inline int
++spa_format_audio_raw_parse(const struct spa_pod *format, struct spa_audio_info_raw *info)
++{
++	struct spa_pod *position = NULL;
++	int res;
++	info->flags = 0;
++	res = spa_pod_parse_object(format,
++			SPA_TYPE_OBJECT_Format, NULL,
++			SPA_FORMAT_AUDIO_format,	SPA_POD_Id(&info->format),
++			SPA_FORMAT_AUDIO_rate,		SPA_POD_Int(&info->rate),
++			SPA_FORMAT_AUDIO_channels,	SPA_POD_Int(&info->channels),
++			SPA_FORMAT_AUDIO_position,	SPA_POD_OPT_Pod(&position));
++	if (position == NULL ||
++	    !spa_pod_copy_array(position, SPA_TYPE_Id, info->position, SPA_AUDIO_MAX_CHANNELS))
++		SPA_FLAG_SET(info->flags, SPA_AUDIO_FLAG_UNPOSITIONED);
++
++	return res;
++}
++
++static inline int
++spa_format_audio_dsp_parse(const struct spa_pod *format, struct spa_audio_info_dsp *info)
++{
++	int res;
++	res = spa_pod_parse_object(format,
++			SPA_TYPE_OBJECT_Format, NULL,
++			SPA_FORMAT_AUDIO_format,	SPA_POD_Id(&info->format));
++	return res;
++}
++
++static inline struct spa_pod *
++spa_format_audio_raw_build(struct spa_pod_builder *builder, uint32_t id, struct spa_audio_info_raw *info)
++{
++	struct spa_pod_frame f;
++	spa_pod_builder_push_object(builder, &f, SPA_TYPE_OBJECT_Format, id);
++	spa_pod_builder_add(builder,
++			SPA_FORMAT_mediaType,		SPA_POD_Id(SPA_MEDIA_TYPE_audio),
++			SPA_FORMAT_mediaSubtype,	SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
++			SPA_FORMAT_AUDIO_format,	SPA_POD_Id(info->format),
++			SPA_FORMAT_AUDIO_rate,		SPA_POD_Int(info->rate),
++			SPA_FORMAT_AUDIO_channels,	SPA_POD_Int(info->channels),
++			0);
++
++	if (!SPA_FLAG_IS_SET(info->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
++		spa_pod_builder_prop(builder, SPA_FORMAT_AUDIO_position, 0);
++		spa_pod_builder_array(builder, sizeof(uint32_t), SPA_TYPE_Id,
++				info->channels, info->position);
++	}
++	return (struct spa_pod*)spa_pod_builder_pop(builder, &f);
++}
++
++static inline struct spa_pod *
++spa_format_audio_dsp_build(struct spa_pod_builder *builder, uint32_t id, struct spa_audio_info_dsp *info)
++{
++	struct spa_pod_frame f;
++	spa_pod_builder_push_object(builder, &f, SPA_TYPE_OBJECT_Format, id);
++	spa_pod_builder_add(builder,
++			SPA_FORMAT_mediaType,		SPA_POD_Id(SPA_MEDIA_TYPE_audio),
++			SPA_FORMAT_mediaSubtype,	SPA_POD_Id(SPA_MEDIA_SUBTYPE_dsp),
++			SPA_FORMAT_AUDIO_format,	SPA_POD_Id(info->format),
++			0);
++	return (struct spa_pod*)spa_pod_builder_pop(builder, &f);
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_AUDIO_FORMAT_UTILS_H */
+diff --git a/third_party/pipewire/spa/param/audio/format.h b/third_party/pipewire/spa/param/audio/format.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/audio/format.h
+@@ -0,0 +1,48 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_AUDIO_FORMAT_H
++#define SPA_PARAM_AUDIO_FORMAT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/format.h>
++#include <spa/param/audio/raw.h>
++
++struct spa_audio_info {
++	uint32_t media_type;
++	uint32_t media_subtype;
++	union {
++		struct spa_audio_info_raw raw;
++		struct spa_audio_info_dsp dsp;
++	} info;
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_AUDIO_FORMAT_H */
+diff --git a/third_party/pipewire/spa/param/audio/layout.h b/third_party/pipewire/spa/param/audio/layout.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/audio/layout.h
+@@ -0,0 +1,184 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_AUDIO_LAYOUT_H
++#define SPA_AUDIO_LAYOUT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#ifndef __FreeBSD__
++#include <endian.h>
++#endif
++
++#include <spa/param/audio/raw.h>
++
++struct spa_audio_layout_info {
++	uint32_t n_channels;
++	uint32_t position[SPA_AUDIO_MAX_CHANNELS];
++};
++
++#define SPA_AUDIO_LAYOUT_Mono		1, { SPA_AUDIO_CHANNEL_MONO, }
++#define SPA_AUDIO_LAYOUT_Stereo		2, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, }
++#define SPA_AUDIO_LAYOUT_Quad		4, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, }
++#define SPA_AUDIO_LAYOUT_Pentagonal	5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_FC, }
++#define SPA_AUDIO_LAYOUT_Hexagonal	6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_Octagonal	8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RC, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_Cube		8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR }, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_TFL, SPA_AUDIO_CHANNEL_TFR, \
++					     SPA_AUDIO_CHANNEL_TRL, SPA_AUDIO_CHANNEL_TRR, }
++
++
++#define SPA_AUDIO_LAYOUT_MPEG_1_0	SPA_AUDIO_LAYOUT_MONO
++#define SPA_AUDIO_LAYOUT_MPEG_2_0	SPA_AUDIO_LAYOUT_STEREO
++#define SPA_AUDIO_LAYOUT_MPEG_3_0A	3, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, }
++#define SPA_AUDIO_LAYOUT_MPEG_3_0B	3, { SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_FL, \
++					     SPA_AUDIO_CHANNEL_FR, }
++#define SPA_AUDIO_LAYOUT_MPEG_4_0A	4, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_MPEG_4_0B	4, { SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_FL, \
++					     SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_0A	5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_0B	5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, \
++					     SPA_AUDIO_CHANNEL_FC, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_0C	5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FC, \
++					     SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_0D	5, { SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_FL, \
++					     SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_1A	6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_1B	6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_1C	6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FC, \
++					     SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, SPA_AUDIO_CHANNEL_LFE, }
++#define SPA_AUDIO_LAYOUT_MPEG_5_1D	6, { SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_FL, \
++					     SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, SPA_AUDIO_CHANNEL_LFE, }
++#define SPA_AUDIO_LAYOUT_MPEG_6_1A	7, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, \
++					     SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_MPEG_7_1A	8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_MPEG_7_1B	8, { SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, SPA_AUDIO_CHANNEL_FL, \
++					     SPA_AUDIO_CHANNEL_FR, SPA_AUDIO_CHANNEL_RL, \
++					     SPA_AUDIO_CHANNEL_RR, SPA_AUDIO_CHANNEL_LFE, }
++#define SPA_AUDIO_LAYOUT_MPEG_7_1C	8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, }
++
++
++#define SPA_AUDIO_LAYOUT_2_1		3, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_LFE, }
++
++#define SPA_AUDIO_LAYOUT_2RC		3, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_2FC		3, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, }
++
++#define SPA_AUDIO_LAYOUT_3_1		4, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, }
++#define SPA_AUDIO_LAYOUT_4_0		4, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_2_2		4, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++
++#define SPA_AUDIO_LAYOUT_4_1		5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_5_0		5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_5_0R		5, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RL, \
++					     SPA_AUDIO_CHANNEL_RR, }
++#define SPA_AUDIO_LAYOUT_5_1		6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_5_1R		6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, }
++#define SPA_AUDIO_LAYOUT_6_0		6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RC, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_6_0F		6, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FLC, SPA_AUDIO_CHANNEL_FRC, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_6_1		7, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RC, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_6_1F		7, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_RC, }
++#define SPA_AUDIO_LAYOUT_7_0		7, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_RL, \
++					     SPA_AUDIO_CHANNEL_RR, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_7_0F		7, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_FLC, \
++					     SPA_AUDIO_CHANNEL_FRC, SPA_AUDIO_CHANNEL_SL, \
++					     SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_7_1		8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_7_1W		8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_FLC, SPA_AUDIO_CHANNEL_FRC, \
++					     SPA_AUDIO_CHANNEL_SL, SPA_AUDIO_CHANNEL_SR, }
++#define SPA_AUDIO_LAYOUT_7_1WR		8, { SPA_AUDIO_CHANNEL_FL, SPA_AUDIO_CHANNEL_FR, \
++					     SPA_AUDIO_CHANNEL_FC, SPA_AUDIO_CHANNEL_LFE, \
++					     SPA_AUDIO_CHANNEL_RL, SPA_AUDIO_CHANNEL_RR, \
++					     SPA_AUDIO_CHANNEL_FLC, SPA_AUDIO_CHANNEL_FRC, }
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_AUDIO_LAYOUT_H */
+diff --git a/third_party/pipewire/spa/param/audio/raw.h b/third_party/pipewire/spa/param/audio/raw.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/audio/raw.h
+@@ -0,0 +1,237 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_AUDIO_RAW_H
++#define SPA_AUDIO_RAW_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdint.h>
++
++#ifndef __FreeBSD__
++#include <endian.h>
++#endif
++
++#define SPA_AUDIO_MAX_CHANNELS	64u
++
++enum spa_audio_format {
++	SPA_AUDIO_FORMAT_UNKNOWN,
++	SPA_AUDIO_FORMAT_ENCODED,
++
++	/* interleaved formats */
++	SPA_AUDIO_FORMAT_START_Interleaved	= 0x100,
++	SPA_AUDIO_FORMAT_S8,
++	SPA_AUDIO_FORMAT_U8,
++	SPA_AUDIO_FORMAT_S16_LE,
++	SPA_AUDIO_FORMAT_S16_BE,
++	SPA_AUDIO_FORMAT_U16_LE,
++	SPA_AUDIO_FORMAT_U16_BE,
++	SPA_AUDIO_FORMAT_S24_32_LE,
++	SPA_AUDIO_FORMAT_S24_32_BE,
++	SPA_AUDIO_FORMAT_U24_32_LE,
++	SPA_AUDIO_FORMAT_U24_32_BE,
++	SPA_AUDIO_FORMAT_S32_LE,
++	SPA_AUDIO_FORMAT_S32_BE,
++	SPA_AUDIO_FORMAT_U32_LE,
++	SPA_AUDIO_FORMAT_U32_BE,
++	SPA_AUDIO_FORMAT_S24_LE,
++	SPA_AUDIO_FORMAT_S24_BE,
++	SPA_AUDIO_FORMAT_U24_LE,
++	SPA_AUDIO_FORMAT_U24_BE,
++	SPA_AUDIO_FORMAT_S20_LE,
++	SPA_AUDIO_FORMAT_S20_BE,
++	SPA_AUDIO_FORMAT_U20_LE,
++	SPA_AUDIO_FORMAT_U20_BE,
++	SPA_AUDIO_FORMAT_S18_LE,
++	SPA_AUDIO_FORMAT_S18_BE,
++	SPA_AUDIO_FORMAT_U18_LE,
++	SPA_AUDIO_FORMAT_U18_BE,
++	SPA_AUDIO_FORMAT_F32_LE,
++	SPA_AUDIO_FORMAT_F32_BE,
++	SPA_AUDIO_FORMAT_F64_LE,
++	SPA_AUDIO_FORMAT_F64_BE,
++
++	/* planar formats */
++	SPA_AUDIO_FORMAT_START_Planar		= 0x200,
++	SPA_AUDIO_FORMAT_U8P,
++	SPA_AUDIO_FORMAT_S16P,
++	SPA_AUDIO_FORMAT_S24_32P,
++	SPA_AUDIO_FORMAT_S32P,
++	SPA_AUDIO_FORMAT_S24P,
++	SPA_AUDIO_FORMAT_F32P,
++	SPA_AUDIO_FORMAT_F64P,
++
++	/* other formats start here */
++	SPA_AUDIO_FORMAT_START_Other		= 0x400,
++
++	/* Aliases */
++
++	/* DSP formats */
++	SPA_AUDIO_FORMAT_DSP_S32 = SPA_AUDIO_FORMAT_S24_32P,
++	SPA_AUDIO_FORMAT_DSP_F32 = SPA_AUDIO_FORMAT_F32P,
++	SPA_AUDIO_FORMAT_DSP_F64 = SPA_AUDIO_FORMAT_F64P,
++
++	/* native endian */
++#if __BYTE_ORDER == __BIG_ENDIAN
++	SPA_AUDIO_FORMAT_S16 = SPA_AUDIO_FORMAT_S16_BE,
++	SPA_AUDIO_FORMAT_U16 = SPA_AUDIO_FORMAT_U16_BE,
++	SPA_AUDIO_FORMAT_S24_32 = SPA_AUDIO_FORMAT_S24_32_BE,
++	SPA_AUDIO_FORMAT_U24_32 = SPA_AUDIO_FORMAT_U24_32_BE,
++	SPA_AUDIO_FORMAT_S32 = SPA_AUDIO_FORMAT_S32_BE,
++	SPA_AUDIO_FORMAT_U32 = SPA_AUDIO_FORMAT_U32_BE,
++	SPA_AUDIO_FORMAT_S24 = SPA_AUDIO_FORMAT_S24_BE,
++	SPA_AUDIO_FORMAT_U24 = SPA_AUDIO_FORMAT_U24_BE,
++	SPA_AUDIO_FORMAT_S20 = SPA_AUDIO_FORMAT_S20_BE,
++	SPA_AUDIO_FORMAT_U20 = SPA_AUDIO_FORMAT_U20_BE,
++	SPA_AUDIO_FORMAT_S18 = SPA_AUDIO_FORMAT_S18_BE,
++	SPA_AUDIO_FORMAT_U18 = SPA_AUDIO_FORMAT_U18_BE,
++	SPA_AUDIO_FORMAT_F32 = SPA_AUDIO_FORMAT_F32_BE,
++	SPA_AUDIO_FORMAT_F64 = SPA_AUDIO_FORMAT_F64_BE,
++	SPA_AUDIO_FORMAT_S16_OE = SPA_AUDIO_FORMAT_S16_LE,
++	SPA_AUDIO_FORMAT_U16_OE = SPA_AUDIO_FORMAT_U16_LE,
++	SPA_AUDIO_FORMAT_S24_32_OE = SPA_AUDIO_FORMAT_S24_32_LE,
++	SPA_AUDIO_FORMAT_U24_32_OE = SPA_AUDIO_FORMAT_U24_32_LE,
++	SPA_AUDIO_FORMAT_S32_OE = SPA_AUDIO_FORMAT_S32_LE,
++	SPA_AUDIO_FORMAT_U32_OE = SPA_AUDIO_FORMAT_U32_LE,
++	SPA_AUDIO_FORMAT_S24_OE = SPA_AUDIO_FORMAT_S24_LE,
++	SPA_AUDIO_FORMAT_U24_OE = SPA_AUDIO_FORMAT_U24_LE,
++	SPA_AUDIO_FORMAT_S20_OE = SPA_AUDIO_FORMAT_S20_LE,
++	SPA_AUDIO_FORMAT_U20_OE = SPA_AUDIO_FORMAT_U20_LE,
++	SPA_AUDIO_FORMAT_S18_OE = SPA_AUDIO_FORMAT_S18_LE,
++	SPA_AUDIO_FORMAT_U18_OE = SPA_AUDIO_FORMAT_U18_LE,
++	SPA_AUDIO_FORMAT_F32_OE = SPA_AUDIO_FORMAT_F32_LE,
++	SPA_AUDIO_FORMAT_F64_OE = SPA_AUDIO_FORMAT_F64_LE,
++#elif __BYTE_ORDER == __LITTLE_ENDIAN
++	SPA_AUDIO_FORMAT_S16 = SPA_AUDIO_FORMAT_S16_LE,
++	SPA_AUDIO_FORMAT_U16 = SPA_AUDIO_FORMAT_U16_LE,
++	SPA_AUDIO_FORMAT_S24_32 = SPA_AUDIO_FORMAT_S24_32_LE,
++	SPA_AUDIO_FORMAT_U24_32 = SPA_AUDIO_FORMAT_U24_32_LE,
++	SPA_AUDIO_FORMAT_S32 = SPA_AUDIO_FORMAT_S32_LE,
++	SPA_AUDIO_FORMAT_U32 = SPA_AUDIO_FORMAT_U32_LE,
++	SPA_AUDIO_FORMAT_S24 = SPA_AUDIO_FORMAT_S24_LE,
++	SPA_AUDIO_FORMAT_U24 = SPA_AUDIO_FORMAT_U24_LE,
++	SPA_AUDIO_FORMAT_S20 = SPA_AUDIO_FORMAT_S20_LE,
++	SPA_AUDIO_FORMAT_U20 = SPA_AUDIO_FORMAT_U20_LE,
++	SPA_AUDIO_FORMAT_S18 = SPA_AUDIO_FORMAT_S18_LE,
++	SPA_AUDIO_FORMAT_U18 = SPA_AUDIO_FORMAT_U18_LE,
++	SPA_AUDIO_FORMAT_F32 = SPA_AUDIO_FORMAT_F32_LE,
++	SPA_AUDIO_FORMAT_F64 = SPA_AUDIO_FORMAT_F64_LE,
++	SPA_AUDIO_FORMAT_S16_OE = SPA_AUDIO_FORMAT_S16_BE,
++	SPA_AUDIO_FORMAT_U16_OE = SPA_AUDIO_FORMAT_U16_BE,
++	SPA_AUDIO_FORMAT_S24_32_OE = SPA_AUDIO_FORMAT_S24_32_BE,
++	SPA_AUDIO_FORMAT_U24_32_OE = SPA_AUDIO_FORMAT_U24_32_BE,
++	SPA_AUDIO_FORMAT_S32_OE = SPA_AUDIO_FORMAT_S32_BE,
++	SPA_AUDIO_FORMAT_U32_OE = SPA_AUDIO_FORMAT_U32_BE,
++	SPA_AUDIO_FORMAT_S24_OE = SPA_AUDIO_FORMAT_S24_BE,
++	SPA_AUDIO_FORMAT_U24_OE = SPA_AUDIO_FORMAT_U24_BE,
++	SPA_AUDIO_FORMAT_S20_OE = SPA_AUDIO_FORMAT_S20_BE,
++	SPA_AUDIO_FORMAT_U20_OE = SPA_AUDIO_FORMAT_U20_BE,
++	SPA_AUDIO_FORMAT_S18_OE = SPA_AUDIO_FORMAT_S18_BE,
++	SPA_AUDIO_FORMAT_U18_OE = SPA_AUDIO_FORMAT_U18_BE,
++	SPA_AUDIO_FORMAT_F32_OE = SPA_AUDIO_FORMAT_F32_BE,
++	SPA_AUDIO_FORMAT_F64_OE = SPA_AUDIO_FORMAT_F64_BE,
++#endif
++};
++
++#define SPA_AUDIO_FORMAT_IS_INTERLEAVED(fmt)	((fmt) > SPA_AUDIO_FORMAT_START_Interleaved && (fmt) < SPA_AUDIO_FORMAT_START_Planar)
++#define SPA_AUDIO_FORMAT_IS_PLANAR(fmt)		((fmt) > SPA_AUDIO_FORMAT_START_Planar && (fmt) < SPA_AUDIO_FORMAT_START_Other)
++
++enum spa_audio_channel {
++	SPA_AUDIO_CHANNEL_UNKNOWN,	/**< unspecified */
++	SPA_AUDIO_CHANNEL_NA,		/**< N/A, silent */
++
++	SPA_AUDIO_CHANNEL_MONO,         /**< mono stream */
++
++	SPA_AUDIO_CHANNEL_FL,           /**< front left */
++	SPA_AUDIO_CHANNEL_FR,           /**< front right */
++	SPA_AUDIO_CHANNEL_FC,           /**< front center */
++	SPA_AUDIO_CHANNEL_LFE,          /**< LFE */
++	SPA_AUDIO_CHANNEL_SL,           /**< side left */
++	SPA_AUDIO_CHANNEL_SR,           /**< side right */
++	SPA_AUDIO_CHANNEL_FLC,          /**< front left center */
++	SPA_AUDIO_CHANNEL_FRC,          /**< front right center */
++	SPA_AUDIO_CHANNEL_RC,           /**< rear center */
++	SPA_AUDIO_CHANNEL_RL,           /**< rear left */
++	SPA_AUDIO_CHANNEL_RR,           /**< rear right */
++	SPA_AUDIO_CHANNEL_TC,           /**< top center */
++	SPA_AUDIO_CHANNEL_TFL,          /**< top front left */
++	SPA_AUDIO_CHANNEL_TFC,          /**< top front center */
++	SPA_AUDIO_CHANNEL_TFR,          /**< top front right */
++	SPA_AUDIO_CHANNEL_TRL,          /**< top rear left */
++	SPA_AUDIO_CHANNEL_TRC,          /**< top rear center */
++	SPA_AUDIO_CHANNEL_TRR,          /**< top rear right */
++	SPA_AUDIO_CHANNEL_RLC,          /**< rear left center */
++	SPA_AUDIO_CHANNEL_RRC,          /**< rear right center */
++	SPA_AUDIO_CHANNEL_FLW,          /**< front left wide */
++	SPA_AUDIO_CHANNEL_FRW,          /**< front right wide */
++	SPA_AUDIO_CHANNEL_LFE2,		/**< LFE 2 */
++	SPA_AUDIO_CHANNEL_FLH,          /**< front left high */
++	SPA_AUDIO_CHANNEL_FCH,          /**< front center high */
++	SPA_AUDIO_CHANNEL_FRH,          /**< front right high */
++	SPA_AUDIO_CHANNEL_TFLC,         /**< top front left center */
++	SPA_AUDIO_CHANNEL_TFRC,         /**< top front right center */
++	SPA_AUDIO_CHANNEL_TSL,          /**< top side left */
++	SPA_AUDIO_CHANNEL_TSR,          /**< top side right */
++	SPA_AUDIO_CHANNEL_LLFE,         /**< left LFE */
++	SPA_AUDIO_CHANNEL_RLFE,         /**< right LFE */
++	SPA_AUDIO_CHANNEL_BC,           /**< bottom center */
++	SPA_AUDIO_CHANNEL_BLC,          /**< bottom left center */
++	SPA_AUDIO_CHANNEL_BRC,          /**< bottom right center */
++
++	SPA_AUDIO_CHANNEL_CUSTOM_START	= 0x10000,
++};
++
++/** Extra audio flags */
++#define SPA_AUDIO_FLAG_NONE		(0)		/*< no valid flag */
++#define SPA_AUDIO_FLAG_UNPOSITIONED	(1 << 0)	/*< the position array explicitly
++							 *  contains unpositioned channels. */
++/** Audio information description */
++struct spa_audio_info_raw {
++	enum spa_audio_format format;		/*< format, one of enum spa_audio_format */
++	uint32_t flags;				/*< extra flags */
++	uint32_t rate;				/*< sample rate */
++	uint32_t channels;			/*< number of channels */
++	uint32_t position[SPA_AUDIO_MAX_CHANNELS];	/*< channel position from enum spa_audio_channel */
++};
++
++#define SPA_AUDIO_INFO_RAW_INIT(...)		(struct spa_audio_info_raw) { __VA_ARGS__ }
++
++#define SPA_KEY_AUDIO_CHANNEL		"audio.channel"		/**< an audio channel as string,
++								  *  Ex. "FL" */
++#define SPA_KEY_AUDIO_CHANNELS		"audio.channels"	/**< an audio channel count as int */
++#define SPA_KEY_AUDIO_RATE		"audio.rate"		/**< an audio sample rate as int */
++
++struct spa_audio_info_dsp {
++	enum spa_audio_format format;		/*< format, one of the DSP formats in enum spa_audio_format_dsp */
++};
++
++#define SPA_AUDIO_INFO_DSP_INIT(...)		(struct spa_audio_info_dsp) { __VA_ARGS__ }
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_AUDIO_RAW_H */
+diff --git a/third_party/pipewire/spa/param/audio/type-info.h b/third_party/pipewire/spa/param/audio/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/audio/type-info.h
+@@ -0,0 +1,140 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_AUDIO_TYPES_H
++#define SPA_AUDIO_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/audio/raw.h>
++
++#define SPA_TYPE_INFO_AudioFormat		SPA_TYPE_INFO_ENUM_BASE "AudioFormat"
++#define SPA_TYPE_INFO_AUDIO_FORMAT_BASE		SPA_TYPE_INFO_AudioFormat ":"
++
++static const struct spa_type_info spa_type_audio_format[] = {
++	{ SPA_AUDIO_FORMAT_UNKNOWN, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "UNKNOWN", NULL },
++	{ SPA_AUDIO_FORMAT_ENCODED, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "ENCODED", NULL },
++	{ SPA_AUDIO_FORMAT_S8, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S8", NULL },
++	{ SPA_AUDIO_FORMAT_U8, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U8", NULL },
++	{ SPA_AUDIO_FORMAT_S16_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S16LE", NULL },
++	{ SPA_AUDIO_FORMAT_S16_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S16BE", NULL },
++	{ SPA_AUDIO_FORMAT_U16_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U16LE", NULL },
++	{ SPA_AUDIO_FORMAT_U16_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U16BE", NULL },
++	{ SPA_AUDIO_FORMAT_S24_32_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S24_32LE", NULL },
++	{ SPA_AUDIO_FORMAT_S24_32_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S24_32BE", NULL },
++	{ SPA_AUDIO_FORMAT_U24_32_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U24_32LE", NULL },
++	{ SPA_AUDIO_FORMAT_U24_32_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U24_32BE", NULL },
++	{ SPA_AUDIO_FORMAT_S32_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S32LE", NULL },
++	{ SPA_AUDIO_FORMAT_S32_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S32BE", NULL },
++	{ SPA_AUDIO_FORMAT_U32_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U32LE", NULL },
++	{ SPA_AUDIO_FORMAT_U32_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U32BE", NULL },
++	{ SPA_AUDIO_FORMAT_S24_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S24LE", NULL },
++	{ SPA_AUDIO_FORMAT_S24_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S24BE", NULL },
++	{ SPA_AUDIO_FORMAT_U24_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U24LE", NULL },
++	{ SPA_AUDIO_FORMAT_U24_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U24BE", NULL },
++	{ SPA_AUDIO_FORMAT_S20_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S20LE", NULL },
++	{ SPA_AUDIO_FORMAT_S20_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S20BE", NULL },
++	{ SPA_AUDIO_FORMAT_U20_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U20LE", NULL },
++	{ SPA_AUDIO_FORMAT_U20_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U20BE", NULL },
++	{ SPA_AUDIO_FORMAT_S18_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S18LE", NULL },
++	{ SPA_AUDIO_FORMAT_S18_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S18BE", NULL },
++	{ SPA_AUDIO_FORMAT_U18_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U18LE", NULL },
++	{ SPA_AUDIO_FORMAT_U18_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U18BE", NULL },
++	{ SPA_AUDIO_FORMAT_F32_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "F32LE", NULL },
++	{ SPA_AUDIO_FORMAT_F32_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "F32BE", NULL },
++	{ SPA_AUDIO_FORMAT_F64_LE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "F64LE", NULL },
++	{ SPA_AUDIO_FORMAT_F64_BE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "F64BE", NULL },
++
++	{ SPA_AUDIO_FORMAT_U8P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "U8P", NULL },
++	{ SPA_AUDIO_FORMAT_S16P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S16P", NULL },
++	{ SPA_AUDIO_FORMAT_S24_32P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S24_32P", NULL },
++	{ SPA_AUDIO_FORMAT_S32P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S32P", NULL },
++	{ SPA_AUDIO_FORMAT_S24P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "S24P", NULL },
++	{ SPA_AUDIO_FORMAT_F32P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "F32P", NULL },
++	{ SPA_AUDIO_FORMAT_F64P, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FORMAT_BASE "F64P", NULL },
++
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_AudioFlags		SPA_TYPE_INFO_FLAGS_BASE "AudioFlags"
++#define SPA_TYPE_INFO_AUDIO_FLAGS_BASE	SPA_TYPE_INFO_AudioFlags ":"
++
++static const struct spa_type_info spa_type_audio_flags[] = {
++	{ SPA_AUDIO_FLAG_NONE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FLAGS_BASE "none", NULL },
++	{ SPA_AUDIO_FLAG_UNPOSITIONED, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_FLAGS_BASE "unpositioned", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_AudioChannel		SPA_TYPE_INFO_ENUM_BASE "AudioChannel"
++#define SPA_TYPE_INFO_AUDIO_CHANNEL_BASE	SPA_TYPE_INFO_AudioChannel ":"
++
++static const struct spa_type_info spa_type_audio_channel[] = {
++	{ SPA_AUDIO_CHANNEL_UNKNOWN, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "UNK", NULL },
++	{ SPA_AUDIO_CHANNEL_NA,	SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "NA", NULL },
++	{ SPA_AUDIO_CHANNEL_MONO, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "MONO", NULL },
++	{ SPA_AUDIO_CHANNEL_FL, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FL", NULL },
++	{ SPA_AUDIO_CHANNEL_FR, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FR", NULL },
++	{ SPA_AUDIO_CHANNEL_FC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FC", NULL },
++	{ SPA_AUDIO_CHANNEL_LFE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "LFE", NULL },
++	{ SPA_AUDIO_CHANNEL_SL, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "SL", NULL },
++	{ SPA_AUDIO_CHANNEL_SR, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "SR", NULL },
++	{ SPA_AUDIO_CHANNEL_FLC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FLC", NULL },
++	{ SPA_AUDIO_CHANNEL_FRC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FRC", NULL },
++	{ SPA_AUDIO_CHANNEL_RC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "RC", NULL },
++	{ SPA_AUDIO_CHANNEL_RL, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "RL", NULL },
++	{ SPA_AUDIO_CHANNEL_RR, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "RR", NULL },
++	{ SPA_AUDIO_CHANNEL_TC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TC", NULL },
++	{ SPA_AUDIO_CHANNEL_TFL, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TFL", NULL },
++	{ SPA_AUDIO_CHANNEL_TFC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TFC", NULL },
++	{ SPA_AUDIO_CHANNEL_TFR, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TFR", NULL },
++	{ SPA_AUDIO_CHANNEL_TRL, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TRL", NULL },
++	{ SPA_AUDIO_CHANNEL_TRC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TRC", NULL },
++	{ SPA_AUDIO_CHANNEL_TRR, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TRR", NULL },
++	{ SPA_AUDIO_CHANNEL_RLC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "RLC", NULL },
++	{ SPA_AUDIO_CHANNEL_RRC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "RRC", NULL },
++	{ SPA_AUDIO_CHANNEL_FLW, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FLW", NULL },
++	{ SPA_AUDIO_CHANNEL_FRW, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FRW", NULL },
++	{ SPA_AUDIO_CHANNEL_LFE2, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "LFE2", NULL },
++	{ SPA_AUDIO_CHANNEL_FLH, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FLH", NULL },
++	{ SPA_AUDIO_CHANNEL_FCH, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FCH", NULL },
++	{ SPA_AUDIO_CHANNEL_FRH, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "FRH", NULL },
++	{ SPA_AUDIO_CHANNEL_TFLC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TFLC", NULL },
++	{ SPA_AUDIO_CHANNEL_TFRC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TFRC", NULL },
++	{ SPA_AUDIO_CHANNEL_TSL, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TSL", NULL },
++	{ SPA_AUDIO_CHANNEL_TSR, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "TSR", NULL },
++	{ SPA_AUDIO_CHANNEL_LLFE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "LLFR", NULL },
++	{ SPA_AUDIO_CHANNEL_RLFE, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "RLFE", NULL },
++	{ SPA_AUDIO_CHANNEL_BC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "BC", NULL },
++	{ SPA_AUDIO_CHANNEL_BLC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "BLC", NULL },
++	{ SPA_AUDIO_CHANNEL_BRC, SPA_TYPE_Int, SPA_TYPE_INFO_AUDIO_CHANNEL_BASE "BRC", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_AUDIO_RAW_TYPES_H */
+diff --git a/third_party/pipewire/spa/param/format-utils.h b/third_party/pipewire/spa/param/format-utils.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/format-utils.h
+@@ -0,0 +1,49 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_FORMAT_UTILS_H
++#define SPA_PARAM_FORMAT_UTILS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++#include <spa/pod/parser.h>
++#include <spa/param/format.h>
++
++static inline int
++spa_format_parse(const struct spa_pod *format, uint32_t *media_type, uint32_t *media_subtype)
++{
++	return spa_pod_parse_object(format,
++		SPA_TYPE_OBJECT_Format, NULL,
++		SPA_FORMAT_mediaType,    SPA_POD_Id(media_type),
++		SPA_FORMAT_mediaSubtype, SPA_POD_Id(media_subtype));
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_FORMAT_UTILS_H */
+diff --git a/third_party/pipewire/spa/param/format.h b/third_party/pipewire/spa/param/format.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/format.h
+@@ -0,0 +1,147 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_FORMAT_H
++#define SPA_PARAM_FORMAT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/param.h>
++
++/** media type for SPA_TYPE_OBJECT_Format */
++enum spa_media_type {
++	SPA_MEDIA_TYPE_unknown,
++	SPA_MEDIA_TYPE_audio,
++	SPA_MEDIA_TYPE_video,
++	SPA_MEDIA_TYPE_image,
++	SPA_MEDIA_TYPE_binary,
++	SPA_MEDIA_TYPE_stream,
++	SPA_MEDIA_TYPE_application,
++};
++
++/** media subtype for SPA_TYPE_OBJECT_Format */
++enum spa_media_subtype {
++	SPA_MEDIA_SUBTYPE_unknown,
++	SPA_MEDIA_SUBTYPE_raw,
++	SPA_MEDIA_SUBTYPE_dsp,
++
++	SPA_MEDIA_SUBTYPE_START_Audio	= 0x10000,
++	SPA_MEDIA_SUBTYPE_mp3,
++	SPA_MEDIA_SUBTYPE_aac,
++	SPA_MEDIA_SUBTYPE_vorbis,
++	SPA_MEDIA_SUBTYPE_wma,
++	SPA_MEDIA_SUBTYPE_ra,
++	SPA_MEDIA_SUBTYPE_sbc,
++	SPA_MEDIA_SUBTYPE_adpcm,
++	SPA_MEDIA_SUBTYPE_g723,
++	SPA_MEDIA_SUBTYPE_g726,
++	SPA_MEDIA_SUBTYPE_g729,
++	SPA_MEDIA_SUBTYPE_amr,
++	SPA_MEDIA_SUBTYPE_gsm,
++
++	SPA_MEDIA_SUBTYPE_START_Video	= 0x20000,
++	SPA_MEDIA_SUBTYPE_h264,
++	SPA_MEDIA_SUBTYPE_mjpg,
++	SPA_MEDIA_SUBTYPE_dv,
++	SPA_MEDIA_SUBTYPE_mpegts,
++	SPA_MEDIA_SUBTYPE_h263,
++	SPA_MEDIA_SUBTYPE_mpeg1,
++	SPA_MEDIA_SUBTYPE_mpeg2,
++	SPA_MEDIA_SUBTYPE_mpeg4,
++	SPA_MEDIA_SUBTYPE_xvid,
++	SPA_MEDIA_SUBTYPE_vc1,
++	SPA_MEDIA_SUBTYPE_vp8,
++	SPA_MEDIA_SUBTYPE_vp9,
++	SPA_MEDIA_SUBTYPE_bayer,
++
++	SPA_MEDIA_SUBTYPE_START_Image	= 0x30000,
++	SPA_MEDIA_SUBTYPE_jpeg,
++
++	SPA_MEDIA_SUBTYPE_START_Binary	= 0x40000,
++
++	SPA_MEDIA_SUBTYPE_START_Stream	= 0x50000,
++	SPA_MEDIA_SUBTYPE_midi,
++
++	SPA_MEDIA_SUBTYPE_START_Application	= 0x60000,
++	SPA_MEDIA_SUBTYPE_control,		/**< control stream, data contains
++						  *  spa_pod_sequence with control info. */
++};
++
++/** properties for audio SPA_TYPE_OBJECT_Format */
++enum spa_format {
++	SPA_FORMAT_START,
++
++	SPA_FORMAT_mediaType,		/**< media type (Id enum spa_media_type) */
++	SPA_FORMAT_mediaSubtype,	/**< media subtype (Id enum spa_media_subtype) */
++
++	/* Audio format keys */
++	SPA_FORMAT_START_Audio = 0x10000,
++	SPA_FORMAT_AUDIO_format,	/**< audio format, (Id enum spa_audio_format) */
++	SPA_FORMAT_AUDIO_flags,		/**< optional flags (Int) */
++	SPA_FORMAT_AUDIO_rate,		/**< sample rate (Int) */
++	SPA_FORMAT_AUDIO_channels,	/**< number of audio channels (Int) */
++	SPA_FORMAT_AUDIO_position,	/**< channel positions (Id enum spa_audio_position) */
++
++	/* Video Format keys */
++	SPA_FORMAT_START_Video = 0x20000,
++	SPA_FORMAT_VIDEO_format,		/**< video format (Id enum spa_video_format) */
++	SPA_FORMAT_VIDEO_modifier,		/**< format modifier (Long) */
++	SPA_FORMAT_VIDEO_size,			/**< size (Rectangle) */
++	SPA_FORMAT_VIDEO_framerate,		/**< frame rate (Fraction) */
++	SPA_FORMAT_VIDEO_maxFramerate,		/**< maximum frame rate (Fraction) */
++	SPA_FORMAT_VIDEO_views,			/**< number of views (Int) */
++	SPA_FORMAT_VIDEO_interlaceMode,		/**< (Id enum spa_video_interlace_mode) */
++	SPA_FORMAT_VIDEO_pixelAspectRatio,	/**< (Rectangle) */
++	SPA_FORMAT_VIDEO_multiviewMode,		/**< (Id enum spa_video_multiview_mode) */
++	SPA_FORMAT_VIDEO_multiviewFlags,	/**< (Id enum spa_video_multiview_flags) */
++	SPA_FORMAT_VIDEO_chromaSite,		/**< /Id enum spa_video_chroma_site) */
++	SPA_FORMAT_VIDEO_colorRange,		/**< /Id enum spa_video_color_range) */
++	SPA_FORMAT_VIDEO_colorMatrix,		/**< /Id enum spa_video_color_matrix) */
++	SPA_FORMAT_VIDEO_transferFunction,	/**< /Id enum spa_video_transfer_function) */
++	SPA_FORMAT_VIDEO_colorPrimaries,	/**< /Id enum spa_video_color_primaries) */
++	SPA_FORMAT_VIDEO_profile,		/**< (Int) */
++	SPA_FORMAT_VIDEO_level,			/**< (Int) */
++	SPA_FORMAT_VIDEO_H264_streamFormat,	/**< (Id enum spa_h264_stream_format) */
++	SPA_FORMAT_VIDEO_H264_alignment,	/**< (Id enum spa_h264_alignment) */
++
++	/* Image Format keys */
++	SPA_FORMAT_START_Image = 0x30000,
++	/* Binary Format keys */
++	SPA_FORMAT_START_Binary = 0x40000,
++	/* Stream Format keys */
++	SPA_FORMAT_START_Stream = 0x50000,
++	/* Application Format keys */
++	SPA_FORMAT_START_Application = 0x60000,
++};
++
++#define SPA_KEY_FORMAT_DSP		"format.dsp"		/**< a predefined DSP format,
++								  *  Ex. "32 bit float mono audio" */
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_FORMAT_H */
+diff --git a/third_party/pipewire/spa/param/param.h b/third_party/pipewire/spa/param/param.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/param.h
+@@ -0,0 +1,166 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_H
++#define SPA_PARAM_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++
++/** different parameter types that can be queried */
++enum spa_param_type {
++	SPA_PARAM_Invalid,		/**< invalid */
++	SPA_PARAM_PropInfo,		/**< property information as SPA_TYPE_OBJECT_PropInfo */
++	SPA_PARAM_Props,		/**< properties as SPA_TYPE_OBJECT_Props */
++	SPA_PARAM_EnumFormat,		/**< available formats as SPA_TYPE_OBJECT_Format */
++	SPA_PARAM_Format,		/**< configured format as SPA_TYPE_OBJECT_Format */
++	SPA_PARAM_Buffers,		/**< buffer configurations as SPA_TYPE_OBJECT_ParamBuffers*/
++	SPA_PARAM_Meta,			/**< allowed metadata for buffers as SPA_TYPE_OBJECT_ParamMeta*/
++	SPA_PARAM_IO,			/**< configurable IO areas as SPA_TYPE_OBJECT_ParamIO */
++	SPA_PARAM_EnumProfile,		/**< profile enumeration as SPA_TYPE_OBJECT_ParamProfile */
++	SPA_PARAM_Profile,		/**< profile configuration as SPA_TYPE_OBJECT_ParamProfile */
++	SPA_PARAM_EnumPortConfig,	/**< port configuration enumeration as SPA_TYPE_OBJECT_ParamPortConfig */
++	SPA_PARAM_PortConfig,		/**< port configuration as SPA_TYPE_OBJECT_ParamPortConfig */
++	SPA_PARAM_EnumRoute,		/**< routing enumeration as SPA_TYPE_OBJECT_ParamRoute */
++	SPA_PARAM_Route,		/**< routing configuration as SPA_TYPE_OBJECT_ParamRoute */
++	SPA_PARAM_Control,		/**< Control parameter, a SPA_TYPE_Sequence */
++};
++
++/** information about a parameter */
++struct spa_param_info {
++	uint32_t id;			/**< enum spa_param_type */
++#define SPA_PARAM_INFO_SERIAL		(1<<0)	/**< bit to signal update even when the
++						 *   read/write flags don't change */
++#define SPA_PARAM_INFO_READ		(1<<1)
++#define SPA_PARAM_INFO_WRITE		(1<<2)
++#define SPA_PARAM_INFO_READWRITE	(SPA_PARAM_INFO_WRITE|SPA_PARAM_INFO_READ)
++	uint32_t flags;
++	uint32_t user;			/**< private user field. You can use this to keep
++					  *  state. */
++	uint32_t padding[5];
++};
++
++#define SPA_PARAM_INFO(id,flags) (struct spa_param_info){ (id), (flags) }
++
++/** properties for SPA_TYPE_OBJECT_ParamBuffers */
++enum spa_param_buffers {
++	SPA_PARAM_BUFFERS_START,
++	SPA_PARAM_BUFFERS_buffers,	/**< number of buffers (Int) */
++	SPA_PARAM_BUFFERS_blocks,	/**< number of data blocks per buffer (Int) */
++	SPA_PARAM_BUFFERS_size,		/**< size of a data block memory (Int)*/
++	SPA_PARAM_BUFFERS_stride,	/**< stride of data block memory (Int) */
++	SPA_PARAM_BUFFERS_align,	/**< alignment of data block memory (Int) */
++	SPA_PARAM_BUFFERS_dataType,	/**< possible memory types (Int, mask of enum spa_data_type) */
++};
++
++/** properties for SPA_TYPE_OBJECT_ParamMeta */
++enum spa_param_meta {
++	SPA_PARAM_META_START,
++	SPA_PARAM_META_type,	/**< the metadata, one of enum spa_meta_type (Id enum spa_meta_type) */
++	SPA_PARAM_META_size,	/**< the expected maximum size the meta (Int) */
++};
++
++/** properties for SPA_TYPE_OBJECT_ParamIO */
++enum spa_param_io {
++	SPA_PARAM_IO_START,
++	SPA_PARAM_IO_id,	/**< type ID, uniquely identifies the io area (Id enum spa_io_type) */
++	SPA_PARAM_IO_size,	/**< size of the io area (Int) */
++};
++
++enum spa_param_availability {
++	SPA_PARAM_AVAILABILITY_unknown,	/**< unknown availability */
++	SPA_PARAM_AVAILABILITY_no,	/**< not available */
++	SPA_PARAM_AVAILABILITY_yes,	/**< available */
++};
++
++/** properties for SPA_TYPE_OBJECT_ParamProfile */
++enum spa_param_profile {
++	SPA_PARAM_PROFILE_START,
++	SPA_PARAM_PROFILE_index,	/**< profile index (Int) */
++	SPA_PARAM_PROFILE_name,		/**< profile name (String) */
++	SPA_PARAM_PROFILE_description,	/**< profile description (String) */
++	SPA_PARAM_PROFILE_priority,	/**< profile priority (Int) */
++	SPA_PARAM_PROFILE_available,	/**< availability of the profile
++					  *  (Id enum spa_param_availability) */
++	SPA_PARAM_PROFILE_info,		/**< info (Struct(
++					  *		  Int : n_items,
++					  *		  (String : key,
++					  *		   String : value)*)) */
++	SPA_PARAM_PROFILE_classes,	/**< node classes provided by this profile
++					  *  (Struct(
++					  *	   Int : number of items following
++					  *        Struct(
++					  *           String : class name (eg. "Audio/Source"),
++					  *           Int : number of nodes)*)) */
++};
++
++enum spa_param_port_config_mode {
++	SPA_PARAM_PORT_CONFIG_MODE_none,	/**< no configuration */
++	SPA_PARAM_PORT_CONFIG_MODE_passthrough,	/**< passthrough configuration */
++	SPA_PARAM_PORT_CONFIG_MODE_convert,	/**< convert configuration */
++	SPA_PARAM_PORT_CONFIG_MODE_dsp,		/**< dsp configuration, depending on the external
++						  *  format. For audio, ports will be configured for
++						  *  the given number of channels with F32 format. */
++};
++
++/** properties for SPA_TYPE_OBJECT_ParamPortConfig */
++enum spa_param_port_config {
++	SPA_PARAM_PORT_CONFIG_START,
++	SPA_PARAM_PORT_CONFIG_direction,	/**< direction, input/output (Id enum spa_direction) */
++	SPA_PARAM_PORT_CONFIG_mode,		/**< (Id enum spa_param_port_config_mode) mode */
++	SPA_PARAM_PORT_CONFIG_monitor,		/**< (Bool) enable monitor output ports on input ports */
++	SPA_PARAM_PORT_CONFIG_control,		/**< (Bool) enable control ports */
++	SPA_PARAM_PORT_CONFIG_format,		/**< (Object) format filter */
++};
++
++/** properties for SPA_TYPE_OBJECT_ParamRoute */
++enum spa_param_route {
++	SPA_PARAM_ROUTE_START,
++	SPA_PARAM_ROUTE_index,			/**< index of the routing destination (Int) */
++	SPA_PARAM_ROUTE_direction,		/**< direction, input/output (Id enum spa_direction) */
++	SPA_PARAM_ROUTE_device,			/**< device id (Int) */
++	SPA_PARAM_ROUTE_name,			/**< name of the routing destination (String) */
++	SPA_PARAM_ROUTE_description,		/**< description of the destination (String) */
++	SPA_PARAM_ROUTE_priority,		/**< priority of the destination (Int) */
++	SPA_PARAM_ROUTE_available,		/**< availability of the destination
++						  *  (Id enum spa_param_availability) */
++	SPA_PARAM_ROUTE_info,			/**< info (Struct(
++						  *		  Int : n_items,
++						  *		  (String : key,
++						  *		   String : value)*)) */
++	SPA_PARAM_ROUTE_profiles,		/**< associated profile indexes (Array of Int) */
++	SPA_PARAM_ROUTE_props,			/**< properties SPA_TYPE_OBJECT_Props */
++	SPA_PARAM_ROUTE_devices,		/**< associated device indexes (Array of Int) */
++	SPA_PARAM_ROUTE_profile,		/**< profile id (Int) */
++};
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_H */
+diff --git a/third_party/pipewire/spa/param/profiler.h b/third_party/pipewire/spa/param/profiler.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/profiler.h
+@@ -0,0 +1,84 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2020 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_PROFILER_H
++#define SPA_PARAM_PROFILER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/param.h>
++
++/** properties for SPA_TYPE_OBJECT_Profiler */
++enum spa_profiler {
++	SPA_PROFILER_START,
++
++	SPA_PROFILER_START_Driver	= 0x10000,	/**< driver related profiler properties */
++	SPA_PROFILER_info,				/**< Generic info, counter and CPU load,
++							  * (Struct(
++							  *      Long : counter,
++							  *      Float : cpu_load fast,
++							  *      Float : cpu_load medium,
++							  *      Float : cpu_load slow))  */
++	SPA_PROFILER_clock,				/**< clock information
++							  *  (Struct(
++							  *      Int : clock flags,
++							  *      Int : clock id,
++							  *      String: clock name,
++							  *      Long : clock nsec,
++							  *      Fraction : clock rate,
++							  *      Long : clock position,
++							  *      Long : clock duration,
++							  *      Long : clock delay,
++							  *      Double : clock rate_diff,
++							  *      Long : clock next_nsec)) */
++	SPA_PROFILER_driverBlock,			/**< generic driver info block
++							  *  (Struct(
++							  *      Int : driver_id,
++							  *      String : name,
++							  *      Long : driver prev_signal,
++							  *      Long : driver signal,
++							  *      Long : driver awake,
++							  *      Long : driver finish,
++							  *      Int : driver status)) */
++
++	SPA_PROFILER_START_Follower	= 0x20000,	/**< follower related profiler properties */
++	SPA_PROFILER_followerBlock,			/**< generic follower info block
++							  *  (Struct(
++							  *      Int : id,
++							  *      String : name,
++							  *      Long : prev_signal,
++							  *      Long : signal,
++							  *      Long : awake,
++							  *      Long : finish,
++							  *      Int : status)) */
++	SPA_PROFILER_START_CUSTOM	= 0x1000000,
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_PROFILER_H */
+diff --git a/third_party/pipewire/spa/param/props.h b/third_party/pipewire/spa/param/props.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/props.h
+@@ -0,0 +1,99 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_PROPS_H
++#define SPA_PARAM_PROPS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/param.h>
++
++/** properties of SPA_TYPE_OBJECT_PropInfo */
++enum spa_prop_info {
++	SPA_PROP_INFO_START,
++	SPA_PROP_INFO_id,		/**< associated id of the property */
++	SPA_PROP_INFO_name,		/**< name of the property */
++	SPA_PROP_INFO_type,		/**< type and range/enums of property */
++	SPA_PROP_INFO_labels,		/**< labels of property if any, this is a
++					  *  struct with pairs of values, the first one
++					  *  is of the type of the property, the second
++					  *  one is a string with a user readable label
++					  *  for the value. */
++};
++
++/** predefined properties for SPA_TYPE_OBJECT_Props */
++enum spa_prop {
++	SPA_PROP_START,
++
++	SPA_PROP_unknown,		/**< an unknown property */
++
++	SPA_PROP_START_Device	= 0x100,	/**< device related properties */
++	SPA_PROP_device,
++	SPA_PROP_deviceName,
++	SPA_PROP_deviceFd,
++	SPA_PROP_card,
++	SPA_PROP_cardName,
++
++	SPA_PROP_minLatency,
++	SPA_PROP_maxLatency,
++	SPA_PROP_periods,
++	SPA_PROP_periodSize,
++	SPA_PROP_periodEvent,
++	SPA_PROP_live,
++	SPA_PROP_rate,
++	SPA_PROP_quality,
++
++	SPA_PROP_START_Audio	= 0x10000,	/**< audio related properties */
++	SPA_PROP_waveType,
++	SPA_PROP_frequency,
++	SPA_PROP_volume,			/**< a volume (Float), 0.0 silence, 1.0 normal */
++	SPA_PROP_mute,				/**< mute (Bool) */
++	SPA_PROP_patternType,
++	SPA_PROP_ditherType,
++	SPA_PROP_truncate,
++	SPA_PROP_channelVolumes,		/**< a volume array, one volume per
++						  *  channel (Array of Float) */
++	SPA_PROP_volumeBase,			/**< a volume base (Float) */
++	SPA_PROP_volumeStep,			/**< a volume step (Float) */
++
++	SPA_PROP_START_Video	= 0x20000,	/**< video related properties */
++	SPA_PROP_brightness,
++	SPA_PROP_contrast,
++	SPA_PROP_saturation,
++	SPA_PROP_hue,
++	SPA_PROP_gamma,
++	SPA_PROP_exposure,
++	SPA_PROP_gain,
++	SPA_PROP_sharpness,
++
++	SPA_PROP_START_CUSTOM	= 0x1000000,
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_PROPS_H */
+diff --git a/third_party/pipewire/spa/param/type-info.h b/third_party/pipewire/spa/param/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/type-info.h
+@@ -0,0 +1,362 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_TYPES_H
++#define SPA_PARAM_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/param/props.h>
++#include <spa/param/format.h>
++#include <spa/buffer/type-info.h>
++
++/* base for parameter object enumerations */
++#define SPA_TYPE_INFO_ParamId		SPA_TYPE_INFO_ENUM_BASE "ParamId"
++#define SPA_TYPE_INFO_PARAM_ID_BASE	SPA_TYPE_INFO_ParamId ":"
++
++static const struct spa_type_info spa_type_param[] = {
++	{ SPA_PARAM_Invalid, SPA_TYPE_None, SPA_TYPE_INFO_PARAM_ID_BASE "Invalid", NULL },
++	{ SPA_PARAM_PropInfo, SPA_TYPE_OBJECT_Props, SPA_TYPE_INFO_PARAM_ID_BASE "PropInfo", NULL },
++	{ SPA_PARAM_Props, SPA_TYPE_OBJECT_Props, SPA_TYPE_INFO_PARAM_ID_BASE "Props", NULL },
++	{ SPA_PARAM_EnumFormat, SPA_TYPE_OBJECT_Format, SPA_TYPE_INFO_PARAM_ID_BASE "EnumFormat", NULL },
++	{ SPA_PARAM_Format, SPA_TYPE_OBJECT_Format, SPA_TYPE_INFO_PARAM_ID_BASE "Format", NULL },
++	{ SPA_PARAM_Buffers, SPA_TYPE_OBJECT_ParamBuffers, SPA_TYPE_INFO_PARAM_ID_BASE "Buffers", NULL },
++	{ SPA_PARAM_Meta, SPA_TYPE_OBJECT_ParamMeta, SPA_TYPE_INFO_PARAM_ID_BASE "Meta", NULL },
++	{ SPA_PARAM_IO, SPA_TYPE_OBJECT_ParamIO, SPA_TYPE_INFO_PARAM_ID_BASE "IO", NULL },
++	{ SPA_PARAM_EnumProfile, SPA_TYPE_OBJECT_ParamProfile, SPA_TYPE_INFO_PARAM_ID_BASE "EnumProfile", NULL },
++	{ SPA_PARAM_Profile, SPA_TYPE_OBJECT_ParamProfile, SPA_TYPE_INFO_PARAM_ID_BASE "Profile", NULL },
++	{ SPA_PARAM_EnumPortConfig, SPA_TYPE_OBJECT_ParamPortConfig, SPA_TYPE_INFO_PARAM_ID_BASE "EnumPortConfig", NULL },
++	{ SPA_PARAM_PortConfig, SPA_TYPE_OBJECT_ParamPortConfig, SPA_TYPE_INFO_PARAM_ID_BASE "PortConfig", NULL },
++	{ SPA_PARAM_EnumRoute, SPA_TYPE_OBJECT_ParamRoute, SPA_TYPE_INFO_PARAM_ID_BASE "EnumRoute", NULL },
++	{ SPA_PARAM_Route, SPA_TYPE_OBJECT_ParamRoute, SPA_TYPE_INFO_PARAM_ID_BASE "Route", NULL },
++	{ SPA_PARAM_Control, SPA_TYPE_Sequence, SPA_TYPE_INFO_PARAM_ID_BASE "Control", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++/* base for parameter objects */
++#define SPA_TYPE_INFO_Param			SPA_TYPE_INFO_OBJECT_BASE "Param"
++#define SPA_TYPE_INFO_PARAM_BASE		SPA_TYPE_INFO_Param ":"
++
++#define SPA_TYPE_INFO_Props			SPA_TYPE_INFO_PARAM_BASE "Props"
++#define SPA_TYPE_INFO_PROPS_BASE		SPA_TYPE_INFO_Props ":"
++
++static const struct spa_type_info spa_type_props[] = {
++	{ SPA_PROP_START, SPA_TYPE_Id, SPA_TYPE_INFO_PROPS_BASE, spa_type_param, },
++	{ SPA_PROP_unknown, SPA_TYPE_None, SPA_TYPE_INFO_PROPS_BASE "unknown", NULL },
++	{ SPA_PROP_device, SPA_TYPE_String, SPA_TYPE_INFO_PROPS_BASE "device", NULL },
++	{ SPA_PROP_deviceName, SPA_TYPE_String, SPA_TYPE_INFO_PROPS_BASE "deviceName", NULL },
++	{ SPA_PROP_deviceFd, SPA_TYPE_Fd, SPA_TYPE_INFO_PROPS_BASE "deviceFd", NULL },
++	{ SPA_PROP_card, SPA_TYPE_String, SPA_TYPE_INFO_PROPS_BASE "card", NULL },
++	{ SPA_PROP_cardName, SPA_TYPE_String, SPA_TYPE_INFO_PROPS_BASE "cardName", NULL },
++	{ SPA_PROP_minLatency, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "minLatency", NULL },
++	{ SPA_PROP_maxLatency, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "maxLatency", NULL },
++	{ SPA_PROP_periods, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "periods", NULL },
++	{ SPA_PROP_periodSize, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "periodSize", NULL },
++	{ SPA_PROP_periodEvent, SPA_TYPE_Bool, SPA_TYPE_INFO_PROPS_BASE "periodEvent", NULL },
++	{ SPA_PROP_live, SPA_TYPE_Bool, SPA_TYPE_INFO_PROPS_BASE "live", NULL },
++	{ SPA_PROP_rate, SPA_TYPE_Double, SPA_TYPE_INFO_PROPS_BASE "rate", NULL },
++	{ SPA_PROP_quality, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "quality", NULL },
++
++	{ SPA_PROP_waveType, SPA_TYPE_Id, SPA_TYPE_INFO_PROPS_BASE "waveType", NULL },
++	{ SPA_PROP_frequency, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "frequency", NULL },
++	{ SPA_PROP_volume, SPA_TYPE_Float, SPA_TYPE_INFO_PROPS_BASE "volume", NULL },
++	{ SPA_PROP_mute, SPA_TYPE_Bool, SPA_TYPE_INFO_PROPS_BASE "mute", NULL },
++	{ SPA_PROP_patternType, SPA_TYPE_Id, SPA_TYPE_INFO_PROPS_BASE "patternType", NULL },
++	{ SPA_PROP_ditherType, SPA_TYPE_Id, SPA_TYPE_INFO_PROPS_BASE "ditherType", NULL },
++	{ SPA_PROP_truncate, SPA_TYPE_Bool, SPA_TYPE_INFO_PROPS_BASE "truncate", NULL },
++	{ SPA_PROP_channelVolumes, SPA_TYPE_Array, SPA_TYPE_INFO_PROPS_BASE "channelVolumes", NULL },
++	{ SPA_PROP_volumeBase, SPA_TYPE_Float, SPA_TYPE_INFO_PROPS_BASE "volumeBase", NULL },
++	{ SPA_PROP_volumeStep, SPA_TYPE_Float, SPA_TYPE_INFO_PROPS_BASE "volumeStep", NULL },
++
++	{ SPA_PROP_brightness, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "brightness", NULL },
++	{ SPA_PROP_contrast, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "contrast", NULL },
++	{ SPA_PROP_saturation, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "saturation", NULL },
++	{ SPA_PROP_hue, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "hue", NULL },
++	{ SPA_PROP_gamma, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "gamma", NULL },
++	{ SPA_PROP_exposure, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "exposure", NULL },
++	{ SPA_PROP_gain, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "gain", NULL },
++	{ SPA_PROP_sharpness, SPA_TYPE_Int, SPA_TYPE_INFO_PROPS_BASE "sharpness", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++/** Enum Property info */
++#define SPA_TYPE_INFO_PropInfo			SPA_TYPE_INFO_PARAM_BASE "PropInfo"
++#define SPA_TYPE_INFO_PROP_INFO_BASE		SPA_TYPE_INFO_PropInfo ":"
++
++static const struct spa_type_info spa_type_prop_info[] = {
++	{ SPA_PROP_INFO_START, SPA_TYPE_Id, SPA_TYPE_INFO_PROP_INFO_BASE, spa_type_param, },
++	{ SPA_PROP_INFO_id, SPA_TYPE_Id, SPA_TYPE_INFO_PROP_INFO_BASE "id", spa_type_props },
++	{ SPA_PROP_INFO_name, SPA_TYPE_String, SPA_TYPE_INFO_PROP_INFO_BASE "name", NULL },
++	{ SPA_PROP_INFO_type, SPA_TYPE_Pod, SPA_TYPE_INFO_PROP_INFO_BASE "type", NULL },
++	{ SPA_PROP_INFO_labels, SPA_TYPE_Struct, SPA_TYPE_INFO_PROP_INFO_BASE "labels", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_PARAM_Meta		SPA_TYPE_INFO_PARAM_BASE "Meta"
++#define SPA_TYPE_INFO_PARAM_META_BASE		SPA_TYPE_INFO_PARAM_Meta ":"
++
++static const struct spa_type_info spa_type_param_meta[] = {
++	{ SPA_PARAM_META_START, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_META_BASE, spa_type_param },
++	{ SPA_PARAM_META_type, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_META_BASE "type", spa_type_meta_type },
++	{ SPA_PARAM_META_size, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_META_BASE "size", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++/** Base for parameters that describe IO areas to exchange data,
++ * control and properties with a node.
++ */
++#define SPA_TYPE_INFO_PARAM_IO		SPA_TYPE_INFO_PARAM_BASE "IO"
++#define SPA_TYPE_INFO_PARAM_IO_BASE		SPA_TYPE_INFO_PARAM_IO ":"
++
++static const struct spa_type_info spa_type_param_io[] = {
++	{ SPA_PARAM_IO_START, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_IO_BASE, spa_type_param, },
++	{ SPA_PARAM_IO_id, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_IO_BASE "id", spa_type_io },
++	{ SPA_PARAM_IO_size, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_IO_BASE "size", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_Format			SPA_TYPE_INFO_PARAM_BASE "Format"
++#define SPA_TYPE_INFO_FORMAT_BASE		SPA_TYPE_INFO_Format ":"
++
++#define SPA_TYPE_INFO_MediaType		SPA_TYPE_INFO_ENUM_BASE "MediaType"
++#define SPA_TYPE_INFO_MEDIA_TYPE_BASE	SPA_TYPE_INFO_MediaType ":"
++
++#include <spa/param/audio/type-info.h>
++#include <spa/param/video/type-info.h>
++
++static const struct spa_type_info spa_type_media_type[] = {
++	{ SPA_MEDIA_TYPE_unknown, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "unknown", NULL },
++	{ SPA_MEDIA_TYPE_audio,   SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "audio", NULL },
++	{ SPA_MEDIA_TYPE_video,   SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "video", NULL },
++	{ SPA_MEDIA_TYPE_image,   SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "image", NULL },
++	{ SPA_MEDIA_TYPE_binary,  SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "binary", NULL },
++	{ SPA_MEDIA_TYPE_stream,  SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "stream", NULL },
++	{ SPA_MEDIA_TYPE_application,  SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_TYPE_BASE "application", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_MediaSubtype		SPA_TYPE_INFO_ENUM_BASE "MediaSubtype"
++#define SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE	SPA_TYPE_INFO_MediaSubtype ":"
++
++static const struct spa_type_info spa_type_media_subtype[] = {
++	{ SPA_MEDIA_SUBTYPE_unknown, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "unknown", NULL },
++	/* generic subtypes */
++	{ SPA_MEDIA_SUBTYPE_raw, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "raw", NULL },
++	{ SPA_MEDIA_SUBTYPE_dsp, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "dsp", NULL },
++	/* audio subtypes */
++	{ SPA_MEDIA_SUBTYPE_mp3, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "mp3", NULL },
++	{ SPA_MEDIA_SUBTYPE_aac, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "aac", NULL },
++	{ SPA_MEDIA_SUBTYPE_vorbis, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "vorbis", NULL },
++	{ SPA_MEDIA_SUBTYPE_wma, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "wma", NULL },
++	{ SPA_MEDIA_SUBTYPE_ra, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "ra", NULL },
++	{ SPA_MEDIA_SUBTYPE_sbc, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "sbc", NULL },
++	{ SPA_MEDIA_SUBTYPE_adpcm, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "adpcm", NULL },
++	{ SPA_MEDIA_SUBTYPE_g723, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "g723", NULL },
++	{ SPA_MEDIA_SUBTYPE_g726, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "g726", NULL },
++	{ SPA_MEDIA_SUBTYPE_g729, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "g729", NULL },
++	{ SPA_MEDIA_SUBTYPE_amr, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "amr", NULL },
++	{ SPA_MEDIA_SUBTYPE_gsm, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "gsm", NULL },
++	/* video subtypes */
++	{ SPA_MEDIA_SUBTYPE_h264, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "h264", NULL },
++	{ SPA_MEDIA_SUBTYPE_mjpg, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "mjpg", NULL },
++	{ SPA_MEDIA_SUBTYPE_dv, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "dv", NULL },
++	{ SPA_MEDIA_SUBTYPE_mpegts, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "mpegts", NULL },
++	{ SPA_MEDIA_SUBTYPE_h263, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "h263", NULL },
++	{ SPA_MEDIA_SUBTYPE_mpeg1, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "mpeg1", NULL },
++	{ SPA_MEDIA_SUBTYPE_mpeg2, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "mpeg2", NULL },
++	{ SPA_MEDIA_SUBTYPE_mpeg4, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "mpeg4", NULL },
++	{ SPA_MEDIA_SUBTYPE_xvid, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "xvid", NULL },
++	{ SPA_MEDIA_SUBTYPE_vc1, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "vc1", NULL },
++	{ SPA_MEDIA_SUBTYPE_vp8, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "vp8", NULL },
++	{ SPA_MEDIA_SUBTYPE_vp9, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "vp9", NULL },
++	{ SPA_MEDIA_SUBTYPE_bayer, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "bayer", NULL },
++	/* image subtypes */
++	{ SPA_MEDIA_SUBTYPE_jpeg, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "jpeg", NULL },
++	/* stream subtypes */
++	{ SPA_MEDIA_SUBTYPE_midi, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "midi", NULL },
++	/* application subtypes */
++	{ SPA_MEDIA_SUBTYPE_control, SPA_TYPE_Int, SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE "control", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_FormatAudio		SPA_TYPE_INFO_FORMAT_BASE "Audio"
++#define SPA_TYPE_INFO_FORMAT_AUDIO_BASE		SPA_TYPE_INFO_FormatAudio ":"
++
++#define SPA_TYPE_INFO_FormatVideo		SPA_TYPE_INFO_FORMAT_BASE "Video"
++#define SPA_TYPE_INFO_FORMAT_VIDEO_BASE		SPA_TYPE_INFO_FormatVideo ":"
++
++#define SPA_TYPE_INFO_FORMAT_VIDEO_H264		SPA_TYPE_INFO_FORMAT_VIDEO_BASE "H264"
++#define SPA_TYPE_INFO_FORMAT_VIDEO_H264_BASE	SPA_TYPE_INFO_FORMAT_VIDEO_H264 ":"
++
++static const struct spa_type_info spa_type_format[] = {
++	{ SPA_FORMAT_START, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_BASE, spa_type_param, },
++
++	{ SPA_FORMAT_mediaType, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_BASE "mediaType",
++		spa_type_media_type, },
++	{ SPA_FORMAT_mediaSubtype, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_BASE "mediaSubtype",
++		spa_type_media_subtype, },
++
++	{ SPA_FORMAT_AUDIO_format, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_AUDIO_BASE "format",
++		spa_type_audio_format },
++	{ SPA_FORMAT_AUDIO_flags, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_AUDIO_BASE "flags",
++		spa_type_audio_flags },
++	{ SPA_FORMAT_AUDIO_rate, SPA_TYPE_Int, SPA_TYPE_INFO_FORMAT_AUDIO_BASE "rate", NULL },
++	{ SPA_FORMAT_AUDIO_channels, SPA_TYPE_Int, SPA_TYPE_INFO_FORMAT_AUDIO_BASE "channels", NULL },
++	{ SPA_FORMAT_AUDIO_position, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_AUDIO_BASE "position",
++		spa_type_audio_channel },
++
++	{ SPA_FORMAT_VIDEO_format, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "format",
++		spa_type_video_format, },
++	{ SPA_FORMAT_VIDEO_modifier, SPA_TYPE_Long, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "modifier", NULL },
++	{ SPA_FORMAT_VIDEO_size,  SPA_TYPE_Rectangle, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "size", NULL },
++	{ SPA_FORMAT_VIDEO_framerate, SPA_TYPE_Fraction, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "framerate", NULL },
++	{ SPA_FORMAT_VIDEO_maxFramerate, SPA_TYPE_Fraction, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "maxFramerate", NULL },
++	{ SPA_FORMAT_VIDEO_views, SPA_TYPE_Int, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "views", NULL },
++	{ SPA_FORMAT_VIDEO_interlaceMode, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "interlaceMode", NULL },
++	{ SPA_FORMAT_VIDEO_pixelAspectRatio, SPA_TYPE_Fraction, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "pixelAspectRatio", NULL },
++	{ SPA_FORMAT_VIDEO_multiviewMode, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "multiviewMode", NULL },
++	{ SPA_FORMAT_VIDEO_multiviewFlags, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "multiviewFlags", NULL },
++	{ SPA_FORMAT_VIDEO_chromaSite, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "chromaSite", NULL },
++	{ SPA_FORMAT_VIDEO_colorRange, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "colorRange", NULL },
++	{ SPA_FORMAT_VIDEO_colorMatrix, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "colorMatrix", NULL },
++	{ SPA_FORMAT_VIDEO_transferFunction, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "transferFunction", NULL },
++	{ SPA_FORMAT_VIDEO_colorPrimaries, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "colorPrimaries", NULL },
++	{ SPA_FORMAT_VIDEO_profile, SPA_TYPE_Int, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "profile", NULL },
++	{ SPA_FORMAT_VIDEO_level, SPA_TYPE_Int, SPA_TYPE_INFO_FORMAT_VIDEO_BASE "level", NULL },
++
++	{ SPA_FORMAT_VIDEO_H264_streamFormat, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_H264_BASE "streamFormat", NULL },
++	{ SPA_FORMAT_VIDEO_H264_alignment, SPA_TYPE_Id, SPA_TYPE_INFO_FORMAT_VIDEO_H264_BASE "alignment", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_PARAM_Buffers			SPA_TYPE_INFO_PARAM_BASE "Buffers"
++#define SPA_TYPE_INFO_PARAM_BUFFERS_BASE		SPA_TYPE_INFO_PARAM_Buffers ":"
++
++#define SPA_TYPE_INFO_PARAM_BlockInfo			SPA_TYPE_INFO_PARAM_BUFFERS_BASE "BlockInfo"
++#define SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE		SPA_TYPE_INFO_PARAM_BlockInfo ":"
++
++static const struct spa_type_info spa_type_param_buffers[] = {
++	{ SPA_PARAM_BUFFERS_START,    SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_BUFFERS_BASE, spa_type_param, },
++	{ SPA_PARAM_BUFFERS_buffers,  SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_BUFFERS_BASE "buffers", NULL },
++	{ SPA_PARAM_BUFFERS_blocks,   SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_BUFFERS_BASE "blocks", NULL },
++	{ SPA_PARAM_BUFFERS_size,     SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE "size", NULL },
++	{ SPA_PARAM_BUFFERS_stride,   SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE "stride", NULL },
++	{ SPA_PARAM_BUFFERS_align,    SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE "align", NULL },
++	{ SPA_PARAM_BUFFERS_dataType, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE "dataType", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_ParamAvailability		SPA_TYPE_INFO_ENUM_BASE "ParamAvailability"
++#define SPA_TYPE_INFO_PARAM_AVAILABILITY_BASE	SPA_TYPE_INFO_ParamAvailability ":"
++
++static const struct spa_type_info spa_type_param_availability[] = {
++	{ SPA_PARAM_AVAILABILITY_unknown, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_AVAILABILITY_BASE "unknown", NULL },
++	{ SPA_PARAM_AVAILABILITY_no, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_AVAILABILITY_BASE "no", NULL },
++	{ SPA_PARAM_AVAILABILITY_yes, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_AVAILABILITY_BASE "yes", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_PARAM_Profile		SPA_TYPE_INFO_PARAM_BASE "Profile"
++#define SPA_TYPE_INFO_PARAM_PROFILE_BASE	SPA_TYPE_INFO_PARAM_Profile ":"
++
++static const struct spa_type_info spa_type_param_profile[] = {
++	{ SPA_PARAM_PROFILE_START, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_PROFILE_BASE, spa_type_param, },
++	{ SPA_PARAM_PROFILE_index, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_PROFILE_BASE "index", NULL },
++	{ SPA_PARAM_PROFILE_name, SPA_TYPE_String, SPA_TYPE_INFO_PARAM_PROFILE_BASE "name", NULL },
++	{ SPA_PARAM_PROFILE_description, SPA_TYPE_String, SPA_TYPE_INFO_PARAM_PROFILE_BASE "description", NULL },
++	{ SPA_PARAM_PROFILE_priority, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_PROFILE_BASE "priority", NULL },
++	{ SPA_PARAM_PROFILE_available, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_PROFILE_BASE "available", spa_type_param_availability, },
++	{ SPA_PARAM_PROFILE_info, SPA_TYPE_Struct, SPA_TYPE_INFO_PARAM_PROFILE_BASE "info", NULL, },
++	{ SPA_PARAM_PROFILE_classes, SPA_TYPE_Struct, SPA_TYPE_INFO_PARAM_PROFILE_BASE "classes", NULL, },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_ParamPortConfigMode		SPA_TYPE_INFO_ENUM_BASE "ParamPortConfigMode"
++#define SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE	SPA_TYPE_INFO_ParamPortConfigMode ":"
++
++static const struct spa_type_info spa_type_param_port_config_mode[] = {
++	{ SPA_PARAM_PORT_CONFIG_MODE_none, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE "none", NULL },
++	{ SPA_PARAM_PORT_CONFIG_MODE_passthrough, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE "passthrough", NULL },
++	{ SPA_PARAM_PORT_CONFIG_MODE_convert, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE "convert", NULL },
++	{ SPA_PARAM_PORT_CONFIG_MODE_dsp, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE "dsp", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#define SPA_TYPE_INFO_PARAM_PortConfig		SPA_TYPE_INFO_PARAM_BASE "PortConfig"
++#define SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE	SPA_TYPE_INFO_PARAM_PortConfig ":"
++
++static const struct spa_type_info spa_type_param_port_config[] = {
++	{ SPA_PARAM_PORT_CONFIG_START, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE, spa_type_param, },
++	{ SPA_PARAM_PORT_CONFIG_direction, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE "direction", spa_type_direction, },
++	{ SPA_PARAM_PORT_CONFIG_mode, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE "mode", spa_type_param_port_config_mode },
++	{ SPA_PARAM_PORT_CONFIG_monitor, SPA_TYPE_Bool, SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE "monitor", NULL },
++	{ SPA_PARAM_PORT_CONFIG_control, SPA_TYPE_Bool, SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE "control", NULL },
++	{ SPA_PARAM_PORT_CONFIG_format, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE "format", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++
++#define SPA_TYPE_INFO_PARAM_Route		SPA_TYPE_INFO_PARAM_BASE "Route"
++#define SPA_TYPE_INFO_PARAM_ROUTE_BASE		SPA_TYPE_INFO_PARAM_Route ":"
++
++static const struct spa_type_info spa_type_param_route[] = {
++	{ SPA_PARAM_ROUTE_START, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_ROUTE_BASE, spa_type_param, },
++	{ SPA_PARAM_ROUTE_index, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_ROUTE_BASE "index", NULL, },
++	{ SPA_PARAM_ROUTE_direction, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_ROUTE_BASE "direction", spa_type_direction, },
++	{ SPA_PARAM_ROUTE_device, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_ROUTE_BASE "device", NULL, },
++	{ SPA_PARAM_ROUTE_name, SPA_TYPE_String, SPA_TYPE_INFO_PARAM_ROUTE_BASE "name", NULL, },
++	{ SPA_PARAM_ROUTE_description, SPA_TYPE_String, SPA_TYPE_INFO_PARAM_ROUTE_BASE "description", NULL, },
++	{ SPA_PARAM_ROUTE_priority, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_ROUTE_BASE "priority", NULL, },
++	{ SPA_PARAM_ROUTE_available, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_ROUTE_BASE "available", spa_type_param_availability, },
++	{ SPA_PARAM_ROUTE_info, SPA_TYPE_Struct, SPA_TYPE_INFO_PARAM_ROUTE_BASE "info", NULL, },
++	{ SPA_PARAM_ROUTE_profiles, SPA_TYPE_Array, SPA_TYPE_INFO_PARAM_ROUTE_BASE "profiles", NULL, },
++	{ SPA_PARAM_ROUTE_props, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_ROUTE_BASE "props", NULL, },
++	{ SPA_PARAM_ROUTE_devices, SPA_TYPE_Array, SPA_TYPE_INFO_PARAM_ROUTE_BASE "devices", NULL, },
++	{ SPA_PARAM_ROUTE_profile, SPA_TYPE_Int, SPA_TYPE_INFO_PARAM_ROUTE_BASE "profile", NULL, },
++	{ 0, 0, NULL, NULL },
++};
++
++#include <spa/param/profiler.h>
++
++#define SPA_TYPE_INFO_Profiler		SPA_TYPE_INFO_OBJECT_BASE "Profiler"
++#define SPA_TYPE_INFO_PROFILER_BASE	SPA_TYPE_INFO_Profiler ":"
++
++static const struct spa_type_info spa_type_profiler[] = {
++	{ SPA_PROFILER_START, SPA_TYPE_Id, SPA_TYPE_INFO_PROFILER_BASE, spa_type_param, },
++	{ SPA_PROFILER_info, SPA_TYPE_Struct, SPA_TYPE_INFO_PROFILER_BASE "info", NULL, },
++	{ SPA_PROFILER_clock, SPA_TYPE_Struct, SPA_TYPE_INFO_PROFILER_BASE "clock", NULL, },
++	{ SPA_PROFILER_driverBlock, SPA_TYPE_Struct, SPA_TYPE_INFO_PROFILER_BASE "driverBlock", NULL, },
++	{ SPA_PROFILER_followerBlock, SPA_TYPE_Struct, SPA_TYPE_INFO_PROFILER_BASE "followerBlock", NULL, },
++	{ 0, 0, NULL, NULL },
++};
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_TYPES_H */
+diff --git a/third_party/pipewire/spa/param/video/chroma.h b/third_party/pipewire/spa/param/video/chroma.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/chroma.h
+@@ -0,0 +1,60 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_VIDEO_CHROMA_H
++#define SPA_VIDEO_CHROMA_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** Various Chroma sitings.
++ * @SPA_VIDEO_CHROMA_SITE_UNKNOWN: unknown cositing
++ * @SPA_VIDEO_CHROMA_SITE_NONE: no cositing
++ * @SPA_VIDEO_CHROMA_SITE_H_COSITED: chroma is horizontally cosited
++ * @SPA_VIDEO_CHROMA_SITE_V_COSITED: chroma is vertically cosited
++ * @SPA_VIDEO_CHROMA_SITE_ALT_LINE: choma samples are sited on alternate lines
++ * @SPA_VIDEO_CHROMA_SITE_COSITED: chroma samples cosited with luma samples
++ * @SPA_VIDEO_CHROMA_SITE_JPEG: jpeg style cositing, also for mpeg1 and mjpeg
++ * @SPA_VIDEO_CHROMA_SITE_MPEG2: mpeg2 style cositing
++ * @SPA_VIDEO_CHROMA_SITE_DV: DV style cositing
++ */
++enum spa_video_chroma_site {
++	SPA_VIDEO_CHROMA_SITE_UNKNOWN = 0,
++	SPA_VIDEO_CHROMA_SITE_NONE = (1 << 0),
++	SPA_VIDEO_CHROMA_SITE_H_COSITED = (1 << 1),
++	SPA_VIDEO_CHROMA_SITE_V_COSITED = (1 << 2),
++	SPA_VIDEO_CHROMA_SITE_ALT_LINE = (1 << 3),
++	/* some common chroma cositing */
++	SPA_VIDEO_CHROMA_SITE_COSITED = (SPA_VIDEO_CHROMA_SITE_H_COSITED | SPA_VIDEO_CHROMA_SITE_V_COSITED),
++	SPA_VIDEO_CHROMA_SITE_JPEG = (SPA_VIDEO_CHROMA_SITE_NONE),
++	SPA_VIDEO_CHROMA_SITE_MPEG2 = (SPA_VIDEO_CHROMA_SITE_H_COSITED),
++	SPA_VIDEO_CHROMA_SITE_DV = (SPA_VIDEO_CHROMA_SITE_COSITED | SPA_VIDEO_CHROMA_SITE_ALT_LINE),
++};
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_VIDEO_CHROMA_H */
+diff --git a/third_party/pipewire/spa/param/video/color.h b/third_party/pipewire/spa/param/video/color.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/color.h
+@@ -0,0 +1,162 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_VIDEO_COLOR_H
++#define SPA_VIDEO_COLOR_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/**
++ * spa_video_color_range:
++ * @SPA_VIDEO_COLOR_RANGE_UNKNOWN: unknown range
++ * @SPA_VIDEO_COLOR_RANGE_0_255: [0..255] for 8 bit components
++ * @SPA_VIDEO_COLOR_RANGE_16_235: [16..235] for 8 bit components. Chroma has
++ *                 [16..240] range.
++ *
++ * Possible color range values. These constants are defined for 8 bit color
++ * values and can be scaled for other bit depths.
++ */
++enum spa_video_color_range {
++	SPA_VIDEO_COLOR_RANGE_UNKNOWN = 0,
++	SPA_VIDEO_COLOR_RANGE_0_255,
++	SPA_VIDEO_COLOR_RANGE_16_235
++};
++
++/**
++ * spa_video_color_matrix:
++ * @SPA_VIDEO_COLOR_MATRIX_UNKNOWN: unknown matrix
++ * @SPA_VIDEO_COLOR_MATRIX_RGB: identity matrix
++ * @SPA_VIDEO_COLOR_MATRIX_FCC: FCC color matrix
++ * @SPA_VIDEO_COLOR_MATRIX_BT709: ITU-R BT.709 color matrix
++ * @SPA_VIDEO_COLOR_MATRIX_BT601: ITU-R BT.601 color matrix
++ * @SPA_VIDEO_COLOR_MATRIX_SMPTE240M: SMPTE 240M color matrix
++ * @SPA_VIDEO_COLOR_MATRIX_BT2020: ITU-R BT.2020 color matrix. Since: 1.6.
++ *
++ * The color matrix is used to convert between Y'PbPr and
++ * non-linear RGB (R'G'B')
++ */
++enum spa_video_color_matrix {
++	SPA_VIDEO_COLOR_MATRIX_UNKNOWN = 0,
++	SPA_VIDEO_COLOR_MATRIX_RGB,
++	SPA_VIDEO_COLOR_MATRIX_FCC,
++	SPA_VIDEO_COLOR_MATRIX_BT709,
++	SPA_VIDEO_COLOR_MATRIX_BT601,
++	SPA_VIDEO_COLOR_MATRIX_SMPTE240M,
++	SPA_VIDEO_COLOR_MATRIX_BT2020
++};
++
++/**
++ * spa_video_transfer_function:
++ * @SPA_VIDEO_TRANSFER_UNKNOWN: unknown transfer function
++ * @SPA_VIDEO_TRANSFER_GAMMA10: linear RGB, gamma 1.0 curve
++ * @SPA_VIDEO_TRANSFER_GAMMA18: Gamma 1.8 curve
++ * @SPA_VIDEO_TRANSFER_GAMMA20: Gamma 2.0 curve
++ * @SPA_VIDEO_TRANSFER_GAMMA22: Gamma 2.2 curve
++ * @SPA_VIDEO_TRANSFER_BT709: Gamma 2.2 curve with a linear segment in the lower
++ *                           range
++ * @SPA_VIDEO_TRANSFER_SMPTE240M: Gamma 2.2 curve with a linear segment in the
++ *                               lower range
++ * @SPA_VIDEO_TRANSFER_SRGB: Gamma 2.4 curve with a linear segment in the lower
++ *                          range
++ * @SPA_VIDEO_TRANSFER_GAMMA28: Gamma 2.8 curve
++ * @SPA_VIDEO_TRANSFER_LOG100: Logarithmic transfer characteristic
++ *                             100:1 range
++ * @SPA_VIDEO_TRANSFER_LOG316: Logarithmic transfer characteristic
++ *                             316.22777:1 range
++ * @SPA_VIDEO_TRANSFER_BT2020_12: Gamma 2.2 curve with a linear segment in the lower
++ *                                range. Used for BT.2020 with 12 bits per
++ *                                component. Since: 1.6.
++ * @SPA_VIDEO_TRANSFER_ADOBERGB: Gamma 2.19921875. Since: 1.8
++ *
++ * The video transfer function defines the formula for converting between
++ * non-linear RGB (R'G'B') and linear RGB
++ */
++enum spa_video_transfer_function {
++	SPA_VIDEO_TRANSFER_UNKNOWN = 0,
++	SPA_VIDEO_TRANSFER_GAMMA10,
++	SPA_VIDEO_TRANSFER_GAMMA18,
++	SPA_VIDEO_TRANSFER_GAMMA20,
++	SPA_VIDEO_TRANSFER_GAMMA22,
++	SPA_VIDEO_TRANSFER_BT709,
++	SPA_VIDEO_TRANSFER_SMPTE240M,
++	SPA_VIDEO_TRANSFER_SRGB,
++	SPA_VIDEO_TRANSFER_GAMMA28,
++	SPA_VIDEO_TRANSFER_LOG100,
++	SPA_VIDEO_TRANSFER_LOG316,
++	SPA_VIDEO_TRANSFER_BT2020_12,
++	SPA_VIDEO_TRANSFER_ADOBERGB
++};
++
++/**
++ * spa_video_color_primaries:
++ * @SPA_VIDEO_COLOR_PRIMARIES_UNKNOWN: unknown color primaries
++ * @SPA_VIDEO_COLOR_PRIMARIES_BT709: BT709 primaries
++ * @SPA_VIDEO_COLOR_PRIMARIES_BT470M: BT470M primaries
++ * @SPA_VIDEO_COLOR_PRIMARIES_BT470BG: BT470BG primaries
++ * @SPA_VIDEO_COLOR_PRIMARIES_SMPTE170M: SMPTE170M primaries
++ * @SPA_VIDEO_COLOR_PRIMARIES_SMPTE240M: SMPTE240M primaries
++ * @SPA_VIDEO_COLOR_PRIMARIES_FILM: Generic film
++ * @SPA_VIDEO_COLOR_PRIMARIES_BT2020: BT2020 primaries. Since: 1.6.
++ * @SPA_VIDEO_COLOR_PRIMARIES_ADOBERGB: Adobe RGB primaries. Since: 1.8
++ *
++ * The color primaries define the how to transform linear RGB values to and from
++ * the CIE XYZ colorspace.
++ */
++enum spa_video_color_primaries {
++	SPA_VIDEO_COLOR_PRIMARIES_UNKNOWN = 0,
++	SPA_VIDEO_COLOR_PRIMARIES_BT709,
++	SPA_VIDEO_COLOR_PRIMARIES_BT470M,
++	SPA_VIDEO_COLOR_PRIMARIES_BT470BG,
++	SPA_VIDEO_COLOR_PRIMARIES_SMPTE170M,
++	SPA_VIDEO_COLOR_PRIMARIES_SMPTE240M,
++	SPA_VIDEO_COLOR_PRIMARIES_FILM,
++	SPA_VIDEO_COLOR_PRIMARIES_BT2020,
++	SPA_VIDEO_COLOR_PRIMARIES_ADOBERGB
++};
++
++/**
++ * spa_video_colorimetry:
++ * @range: the color range. This is the valid range for the samples.
++ *         It is used to convert the samples to Y'PbPr values.
++ * @matrix: the color matrix. Used to convert between Y'PbPr and
++ *          non-linear RGB (R'G'B')
++ * @transfer: the transfer function. used to convert between R'G'B' and RGB
++ * @primaries: color primaries. used to convert between R'G'B' and CIE XYZ
++ *
++ * Structure describing the color info.
++ */
++struct spa_video_colorimetry {
++	enum spa_video_color_range range;
++	enum spa_video_color_matrix matrix;
++	enum spa_video_transfer_function transfer;
++	enum spa_video_color_primaries primaries;
++};
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_VIDEO_COLOR_H */
+diff --git a/third_party/pipewire/spa/param/video/encoded.h b/third_party/pipewire/spa/param/video/encoded.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/encoded.h
+@@ -0,0 +1,65 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_VIDEO_ENCODED_H
++#define SPA_VIDEO_ENCODED_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/format.h>
++
++enum spa_h264_stream_format {
++	SPA_H264_STREAM_FORMAT_UNKNOWN = 0,
++	SPA_H264_STREAM_FORMAT_AVC,
++	SPA_H264_STREAM_FORMAT_AVC3,
++	SPA_H264_STREAM_FORMAT_BYTESTREAM
++};
++
++enum spa_h264_alignment {
++	SPA_H264_ALIGNMENT_UNKNOWN = 0,
++	SPA_H264_ALIGNMENT_AU,
++	SPA_H264_ALIGNMENT_NAL
++};
++
++struct spa_video_info_h264 {
++	struct spa_rectangle size;
++	struct spa_fraction framerate;
++	struct spa_fraction max_framerate;
++	enum spa_h264_stream_format stream_format;
++	enum spa_h264_alignment alignment;
++};
++
++struct spa_video_info_mjpg {
++	struct spa_rectangle size;
++	struct spa_fraction framerate;
++	struct spa_fraction max_framerate;
++};
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_VIDEO_ENCODED_H */
+diff --git a/third_party/pipewire/spa/param/video/format-utils.h b/third_party/pipewire/spa/param/video/format-utils.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/format-utils.h
+@@ -0,0 +1,167 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_VIDEO_FORMAT_UTILS_H
++#define SPA_PARAM_VIDEO_FORMAT_UTILS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/parser.h>
++#include <spa/pod/builder.h>
++#include <spa/param/video/format.h>
++#include <spa/param/format-utils.h>
++
++static inline int
++spa_format_video_raw_parse(const struct spa_pod *format,
++			   struct spa_video_info_raw *info)
++{
++	return spa_pod_parse_object(format,
++		SPA_TYPE_OBJECT_Format, NULL,
++		SPA_FORMAT_VIDEO_format,		SPA_POD_Id(&info->format),
++		SPA_FORMAT_VIDEO_modifier,		SPA_POD_OPT_Long(&info->modifier),
++		SPA_FORMAT_VIDEO_size,			SPA_POD_Rectangle(&info->size),
++		SPA_FORMAT_VIDEO_framerate,		SPA_POD_Fraction(&info->framerate),
++		SPA_FORMAT_VIDEO_maxFramerate,		SPA_POD_OPT_Fraction(&info->max_framerate),
++		SPA_FORMAT_VIDEO_views,			SPA_POD_OPT_Int(&info->views),
++		SPA_FORMAT_VIDEO_interlaceMode,		SPA_POD_OPT_Id(&info->interlace_mode),
++		SPA_FORMAT_VIDEO_pixelAspectRatio,	SPA_POD_OPT_Fraction(&info->pixel_aspect_ratio),
++		SPA_FORMAT_VIDEO_multiviewMode,		SPA_POD_OPT_Id(&info->multiview_mode),
++		SPA_FORMAT_VIDEO_multiviewFlags,	SPA_POD_OPT_Id(&info->multiview_flags),
++		SPA_FORMAT_VIDEO_chromaSite,		SPA_POD_OPT_Id(&info->chroma_site),
++		SPA_FORMAT_VIDEO_colorRange,		SPA_POD_OPT_Id(&info->color_range),
++		SPA_FORMAT_VIDEO_colorMatrix,		SPA_POD_OPT_Id(&info->color_matrix),
++		SPA_FORMAT_VIDEO_transferFunction,	SPA_POD_OPT_Id(&info->transfer_function),
++		SPA_FORMAT_VIDEO_colorPrimaries,	SPA_POD_OPT_Id(&info->color_primaries));
++}
++
++static inline int
++spa_format_video_dsp_parse(const struct spa_pod *format,
++			   struct spa_video_info_dsp *info)
++{
++	return spa_pod_parse_object(format,
++		SPA_TYPE_OBJECT_Format, NULL,
++		SPA_FORMAT_VIDEO_format,		SPA_POD_Id(&info->format),
++		SPA_FORMAT_VIDEO_modifier,		SPA_POD_OPT_Long(&info->modifier));
++}
++
++static inline struct spa_pod *
++spa_format_video_raw_build(struct spa_pod_builder *builder, uint32_t id,
++			   struct spa_video_info_raw *info)
++{
++	struct spa_pod_frame f;
++	spa_pod_builder_push_object(builder, &f, SPA_TYPE_OBJECT_Format, id);
++	spa_pod_builder_add(builder,
++			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_Id(info->format),
++			SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&info->size),
++			SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&info->framerate),
++			0);
++	if (info->modifier != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_modifier,	SPA_POD_Long(info->modifier), 0);
++	if (info->max_framerate.denom != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_maxFramerate,	SPA_POD_Fraction(info->max_framerate), 0);
++	if (info->views != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_views,		SPA_POD_Int(info->views), 0);
++	if (info->interlace_mode != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_interlaceMode,	SPA_POD_Id(info->interlace_mode), 0);
++	if (info->pixel_aspect_ratio.denom != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_pixelAspectRatio,SPA_POD_Fraction(info->pixel_aspect_ratio), 0);
++	if (info->multiview_mode != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_multiviewMode,	SPA_POD_Id(info->multiview_mode), 0);
++	if (info->multiview_flags != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_multiviewFlags,SPA_POD_Id(info->multiview_flags), 0);
++	if (info->chroma_site != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_chromaSite,	SPA_POD_Id(info->chroma_site), 0);
++	if (info->color_range != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_colorRange,	SPA_POD_Id(info->color_range), 0);
++	if (info->color_matrix != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_colorMatrix,	SPA_POD_Id(info->color_matrix), 0);
++	if (info->transfer_function != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_transferFunction,SPA_POD_Id(info->transfer_function), 0);
++	if (info->color_primaries != 0)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_colorPrimaries,SPA_POD_Id(info->color_primaries), 0);
++	return (struct spa_pod*)spa_pod_builder_pop(builder, &f);
++}
++
++static inline struct spa_pod *
++spa_format_video_dsp_build(struct spa_pod_builder *builder, uint32_t id,
++			   struct spa_video_info_dsp *info)
++{
++	struct spa_pod_frame f;
++	spa_pod_builder_push_object(builder, &f, SPA_TYPE_OBJECT_Format, id);
++	spa_pod_builder_add(builder,
++			SPA_FORMAT_mediaType,		SPA_POD_Id(SPA_MEDIA_TYPE_video),
++			SPA_FORMAT_mediaSubtype,	SPA_POD_Id(SPA_MEDIA_SUBTYPE_dsp),
++			SPA_FORMAT_VIDEO_format,	SPA_POD_Id(info->format),
++			0);
++	if (info->modifier)
++		spa_pod_builder_add(builder,
++			SPA_FORMAT_VIDEO_modifier,	SPA_POD_Long(info->modifier), 0);
++	return (struct spa_pod*)spa_pod_builder_pop(builder, &f);
++}
++
++static inline int
++spa_format_video_h264_parse(const struct spa_pod *format,
++			    struct spa_video_info_h264 *info)
++{
++	return spa_pod_parse_object(format,
++			SPA_TYPE_OBJECT_Format, NULL,
++			SPA_FORMAT_VIDEO_size,			SPA_POD_OPT_Rectangle(&info->size),
++			SPA_FORMAT_VIDEO_framerate,		SPA_POD_OPT_Fraction(&info->framerate),
++			SPA_FORMAT_VIDEO_maxFramerate,		SPA_POD_OPT_Fraction(&info->max_framerate),
++			SPA_FORMAT_VIDEO_H264_streamFormat,	SPA_POD_OPT_Id(&info->stream_format),
++			SPA_FORMAT_VIDEO_H264_alignment,	SPA_POD_OPT_Id(&info->alignment));
++}
++
++static inline int
++spa_format_video_mjpg_parse(const struct spa_pod *format,
++			    struct spa_video_info_mjpg *info)
++{
++	return spa_pod_parse_object(format,
++			SPA_TYPE_OBJECT_Format, NULL,
++			SPA_FORMAT_VIDEO_size,		SPA_POD_OPT_Rectangle(&info->size),
++			SPA_FORMAT_VIDEO_framerate,	SPA_POD_OPT_Fraction(&info->framerate),
++			SPA_FORMAT_VIDEO_maxFramerate,	SPA_POD_OPT_Fraction(&info->max_framerate));
++}
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_VIDEO_FORMAT_UTILS_H */
+diff --git a/third_party/pipewire/spa/param/video/format.h b/third_party/pipewire/spa/param/video/format.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/format.h
+@@ -0,0 +1,50 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PARAM_VIDEO_FORMAT_H
++#define SPA_PARAM_VIDEO_FORMAT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/video/raw.h>
++#include <spa/param/video/encoded.h>
++
++struct spa_video_info {
++	uint32_t media_type;
++	uint32_t media_subtype;
++	union {
++		struct spa_video_info_raw raw;
++		struct spa_video_info_dsp dsp;
++		struct spa_video_info_h264 h264;
++		struct spa_video_info_mjpg mjpg;
++	} info;
++};
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_PARAM_VIDEO_FORMAT_H */
+diff --git a/third_party/pipewire/spa/param/video/multiview.h b/third_party/pipewire/spa/param/video/multiview.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/multiview.h
+@@ -0,0 +1,140 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_VIDEO_MULTIVIEW_H
++#define SPA_VIDEO_MULTIVIEW_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/**
++ * spa_video_multiview_mode:
++ * @SPA_VIDEO_MULTIVIEW_MODE_NONE: A special value indicating
++ * no multiview information. Used in spa_video_info and other places to
++ * indicate that no specific multiview handling has been requested or
++ * provided. This value is never carried on caps.
++ * @SPA_VIDEO_MULTIVIEW_MODE_MONO: All frames are monoscopic.
++ * @SPA_VIDEO_MULTIVIEW_MODE_LEFT: All frames represent a left-eye view.
++ * @SPA_VIDEO_MULTIVIEW_MODE_RIGHT: All frames represent a right-eye view.
++ * @SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE: Left and right eye views are
++ * provided in the left and right half of the frame respectively.
++ * @SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX: Left and right eye
++ * views are provided in the left and right half of the frame, but
++ * have been sampled using quincunx method, with half-pixel offset
++ * between the 2 views.
++ * @SPA_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED: Alternating vertical
++ * columns of pixels represent the left and right eye view respectively.
++ * @SPA_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED: Alternating horizontal
++ * rows of pixels represent the left and right eye view respectively.
++ * @SPA_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM: The top half of the frame
++ * contains the left eye, and the bottom half the right eye.
++ * @SPA_VIDEO_MULTIVIEW_MODE_CHECKERBOARD: Pixels are arranged with
++ * alternating pixels representing left and right eye views in a
++ * checkerboard fashion.
++ * @SPA_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME: Left and right eye views
++ * are provided in separate frames alternately.
++ * @SPA_VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME: Multiple
++ * independent views are provided in separate frames in sequence.
++ * This method only applies to raw video buffers at the moment.
++ * Specific view identification is via the #spa_video_multiview_meta
++ * on raw video buffers.
++ * @SPA_VIDEO_MULTIVIEW_MODE_SEPARATED: Multiple views are
++ * provided as separate #spa_data framebuffers attached to each
++ * #spa_buffer, described by the #spa_video_multiview_meta
++ *
++ * All possible stereoscopic 3D and multiview representations.
++ * In conjunction with #soa_video_multiview_flags, describes how
++ * multiview content is being transported in the stream.
++ */
++enum spa_video_multiview_mode {
++	SPA_VIDEO_MULTIVIEW_MODE_NONE = -1,
++	SPA_VIDEO_MULTIVIEW_MODE_MONO = 0,
++	/* Single view modes */
++	SPA_VIDEO_MULTIVIEW_MODE_LEFT,
++	SPA_VIDEO_MULTIVIEW_MODE_RIGHT,
++	/* Stereo view modes */
++	SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE,
++	SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX,
++	SPA_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED,
++	SPA_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED,
++	SPA_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM,
++	SPA_VIDEO_MULTIVIEW_MODE_CHECKERBOARD,
++	/* Padding for new frame packing modes */
++
++	SPA_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME = 32,
++	/* Multivew mode(s) */
++	SPA_VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME,
++	SPA_VIDEO_MULTIVIEW_MODE_SEPARATED
++	    /* future expansion for annotated modes */
++};
++
++/**
++ * spa_video_multiview_flags:
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_NONE: No flags
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST: For stereo streams, the
++ *     normal arrangement of left and right views is reversed.
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED: The left view is vertically
++ *     mirrored.
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED: The left view is horizontally
++ *     mirrored.
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED: The right view is
++ *     vertically mirrored.
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED: The right view is
++ *     horizontally mirrored.
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT: For frame-packed
++ *     multiview modes, indicates that the individual
++ *     views have been encoded with half the true width or height
++ *     and should be scaled back up for display. This flag
++ *     is used for overriding input layout interpretation
++ *     by adjusting pixel-aspect-ratio.
++ *     For side-by-side, column interleaved or checkerboard packings, the
++ *     pixel width will be doubled. For row interleaved and top-bottom
++ *     encodings, pixel height will be doubled.
++ * @SPA_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO: The video stream contains both
++ *     mono and multiview portions, signalled on each buffer by the
++ *     absence or presence of the @SPA_VIDEO_BUFFER_FLAG_MULTIPLE_VIEW
++ *     buffer flag.
++ *
++ * spa_video_multiview_flags are used to indicate extra properties of a
++ * stereo/multiview stream beyond the frame layout and buffer mapping
++ * that is conveyed in the #spa_video_multiview_mode.
++ */
++enum spa_video_multiview_flags {
++	SPA_VIDEO_MULTIVIEW_FLAGS_NONE = 0,
++	SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST = (1 << 0),
++	SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED = (1 << 1),
++	SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED = (1 << 2),
++	SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED = (1 << 3),
++	SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED = (1 << 4),
++	SPA_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT = (1 << 14),
++	SPA_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO = (1 << 15)
++};
++
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_VIDEO_MULTIVIEW_H */
+diff --git a/third_party/pipewire/spa/param/video/raw.h b/third_party/pipewire/spa/param/video/raw.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/raw.h
+@@ -0,0 +1,221 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_VIDEO_RAW_H
++#define SPA_VIDEO_RAW_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/param/video/chroma.h>
++#include <spa/param/video/color.h>
++#include <spa/param/video/multiview.h>
++
++#define SPA_VIDEO_MAX_PLANES 4
++#define SPA_VIDEO_MAX_COMPONENTS 4
++
++enum spa_video_format {
++	SPA_VIDEO_FORMAT_UNKNOWN,
++	SPA_VIDEO_FORMAT_ENCODED,
++
++	SPA_VIDEO_FORMAT_I420,
++	SPA_VIDEO_FORMAT_YV12,
++	SPA_VIDEO_FORMAT_YUY2,
++	SPA_VIDEO_FORMAT_UYVY,
++	SPA_VIDEO_FORMAT_AYUV,
++	SPA_VIDEO_FORMAT_RGBx,
++	SPA_VIDEO_FORMAT_BGRx,
++	SPA_VIDEO_FORMAT_xRGB,
++	SPA_VIDEO_FORMAT_xBGR,
++	SPA_VIDEO_FORMAT_RGBA,
++	SPA_VIDEO_FORMAT_BGRA,
++	SPA_VIDEO_FORMAT_ARGB,
++	SPA_VIDEO_FORMAT_ABGR,
++	SPA_VIDEO_FORMAT_RGB,
++	SPA_VIDEO_FORMAT_BGR,
++	SPA_VIDEO_FORMAT_Y41B,
++	SPA_VIDEO_FORMAT_Y42B,
++	SPA_VIDEO_FORMAT_YVYU,
++	SPA_VIDEO_FORMAT_Y444,
++	SPA_VIDEO_FORMAT_v210,
++	SPA_VIDEO_FORMAT_v216,
++	SPA_VIDEO_FORMAT_NV12,
++	SPA_VIDEO_FORMAT_NV21,
++	SPA_VIDEO_FORMAT_GRAY8,
++	SPA_VIDEO_FORMAT_GRAY16_BE,
++	SPA_VIDEO_FORMAT_GRAY16_LE,
++	SPA_VIDEO_FORMAT_v308,
++	SPA_VIDEO_FORMAT_RGB16,
++	SPA_VIDEO_FORMAT_BGR16,
++	SPA_VIDEO_FORMAT_RGB15,
++	SPA_VIDEO_FORMAT_BGR15,
++	SPA_VIDEO_FORMAT_UYVP,
++	SPA_VIDEO_FORMAT_A420,
++	SPA_VIDEO_FORMAT_RGB8P,
++	SPA_VIDEO_FORMAT_YUV9,
++	SPA_VIDEO_FORMAT_YVU9,
++	SPA_VIDEO_FORMAT_IYU1,
++	SPA_VIDEO_FORMAT_ARGB64,
++	SPA_VIDEO_FORMAT_AYUV64,
++	SPA_VIDEO_FORMAT_r210,
++	SPA_VIDEO_FORMAT_I420_10BE,
++	SPA_VIDEO_FORMAT_I420_10LE,
++	SPA_VIDEO_FORMAT_I422_10BE,
++	SPA_VIDEO_FORMAT_I422_10LE,
++	SPA_VIDEO_FORMAT_Y444_10BE,
++	SPA_VIDEO_FORMAT_Y444_10LE,
++	SPA_VIDEO_FORMAT_GBR,
++	SPA_VIDEO_FORMAT_GBR_10BE,
++	SPA_VIDEO_FORMAT_GBR_10LE,
++	SPA_VIDEO_FORMAT_NV16,
++	SPA_VIDEO_FORMAT_NV24,
++	SPA_VIDEO_FORMAT_NV12_64Z32,
++	SPA_VIDEO_FORMAT_A420_10BE,
++	SPA_VIDEO_FORMAT_A420_10LE,
++	SPA_VIDEO_FORMAT_A422_10BE,
++	SPA_VIDEO_FORMAT_A422_10LE,
++	SPA_VIDEO_FORMAT_A444_10BE,
++	SPA_VIDEO_FORMAT_A444_10LE,
++	SPA_VIDEO_FORMAT_NV61,
++	SPA_VIDEO_FORMAT_P010_10BE,
++	SPA_VIDEO_FORMAT_P010_10LE,
++	SPA_VIDEO_FORMAT_IYU2,
++	SPA_VIDEO_FORMAT_VYUY,
++	SPA_VIDEO_FORMAT_GBRA,
++	SPA_VIDEO_FORMAT_GBRA_10BE,
++	SPA_VIDEO_FORMAT_GBRA_10LE,
++	SPA_VIDEO_FORMAT_GBR_12BE,
++	SPA_VIDEO_FORMAT_GBR_12LE,
++	SPA_VIDEO_FORMAT_GBRA_12BE,
++	SPA_VIDEO_FORMAT_GBRA_12LE,
++	SPA_VIDEO_FORMAT_I420_12BE,
++	SPA_VIDEO_FORMAT_I420_12LE,
++	SPA_VIDEO_FORMAT_I422_12BE,
++	SPA_VIDEO_FORMAT_I422_12LE,
++	SPA_VIDEO_FORMAT_Y444_12BE,
++	SPA_VIDEO_FORMAT_Y444_12LE,
++
++	SPA_VIDEO_FORMAT_RGBA_F16,
++	SPA_VIDEO_FORMAT_RGBA_F32,
++
++	/* Aliases */
++	SPA_VIDEO_FORMAT_DSP_F32 = SPA_VIDEO_FORMAT_RGBA_F32,
++};
++
++/**
++ * spa_video_flags:
++ * @SPA_VIDEO_FLAG_NONE: no flags
++ * @SPA_VIDEO_FLAG_VARIABLE_FPS: a variable fps is selected, fps_n and fps_d
++ *     denote the maximum fps of the video
++ * @SPA_VIDEO_FLAG_PREMULTIPLIED_ALPHA: Each color has been scaled by the alpha
++ *     value.
++ *
++ * Extra video flags
++ */
++enum spa_video_flags {
++	SPA_VIDEO_FLAG_NONE = 0,
++	SPA_VIDEO_FLAG_VARIABLE_FPS = (1 << 0),
++	SPA_VIDEO_FLAG_PREMULTIPLIED_ALPHA = (1 << 1)
++};
++
++/**
++ * spa_video_interlace_mode:
++ * @SPA_VIDEO_INTERLACE_MODE_PROGRESSIVE: all frames are progressive
++ * @SPA_VIDEO_INTERLACE_MODE_INTERLEAVED: 2 fields are interleaved in one video
++ *     frame. Extra buffer flags describe the field order.
++ * @SPA_VIDEO_INTERLACE_MODE_MIXED: frames contains both interlaced and
++ *     progressive video, the buffer flags describe the frame and fields.
++ * @SPA_VIDEO_INTERLACE_MODE_FIELDS: 2 fields are stored in one buffer, use the
++ *     frame ID to get access to the required field. For multiview (the
++ *     'views' property > 1) the fields of view N can be found at frame ID
++ *     (N * 2) and (N * 2) + 1.
++ *     Each field has only half the amount of lines as noted in the
++ *     height property. This mode requires multiple spa_data
++ *     to describe the fields.
++ *
++ * The possible values of the #spa_video_interlace_mode describing the interlace
++ * mode of the stream.
++ */
++enum spa_video_interlace_mode {
++	SPA_VIDEO_INTERLACE_MODE_PROGRESSIVE = 0,
++	SPA_VIDEO_INTERLACE_MODE_INTERLEAVED,
++	SPA_VIDEO_INTERLACE_MODE_MIXED,
++	SPA_VIDEO_INTERLACE_MODE_FIELDS
++};
++
++/**
++ * spa_video_info_raw:
++ * @format: the format
++ * @modifier: format modifier
++ * @size: the frame size of the video
++ * @framerate: the framerate of the video 0/1 means variable rate
++ * @max_framerate: the maximum framerate of the video. This is only valid when
++ *             @framerate is 0/1
++ * @views: the number of views in this video
++ * @interlace_mode: the interlace mode
++ * @pixel_aspect_ratio: The pixel aspect ratio
++ * @multiview_mode: multiview mode
++ * @multiview_flags: multiview flags
++ * @chroma_site: the chroma siting
++ * @color_range: the color range. This is the valid range for the samples.
++ *         It is used to convert the samples to Y'PbPr values.
++ * @color_matrix: the color matrix. Used to convert between Y'PbPr and
++ *         non-linear RGB (R'G'B')
++ * @transfer_function: the transfer function. used to convert between R'G'B' and RGB
++ * @color_primaries: color primaries. used to convert between R'G'B' and CIE XYZ
++ */
++struct spa_video_info_raw {
++	enum spa_video_format format;
++	int64_t modifier;
++	struct spa_rectangle size;
++	struct spa_fraction framerate;
++	struct spa_fraction max_framerate;
++	uint32_t views;
++	enum spa_video_interlace_mode interlace_mode;
++	struct spa_fraction pixel_aspect_ratio;
++	enum spa_video_multiview_mode multiview_mode;
++	enum spa_video_multiview_flags multiview_flags;
++	enum spa_video_chroma_site chroma_site;
++	enum spa_video_color_range color_range;
++	enum spa_video_color_matrix color_matrix;
++	enum spa_video_transfer_function transfer_function;
++	enum spa_video_color_primaries color_primaries;
++};
++
++#define SPA_VIDEO_INFO_RAW_INIT(...)	(struct spa_video_info_raw) { __VA_ARGS__ }
++
++struct spa_video_info_dsp {
++	enum spa_video_format format;
++	int64_t modifier;
++};
++
++#define SPA_VIDEO_INFO_DSP_INIT(...)	(struct spa_video_info_dsp) { __VA_ARGS__ }
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_VIDEO_RAW_H */
+diff --git a/third_party/pipewire/spa/param/video/type-info.h b/third_party/pipewire/spa/param/video/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/param/video/type-info.h
+@@ -0,0 +1,124 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_VIDEO_TYPES_H
++#define SPA_VIDEO_TYPES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/param/video/raw.h>
++
++#define SPA_TYPE_INFO_VideoFormat		SPA_TYPE_INFO_ENUM_BASE "VideoFormat"
++#define SPA_TYPE_INFO_VIDEO_FORMAT_BASE		SPA_TYPE_INFO_VideoFormat ":"
++
++static const struct spa_type_info spa_type_video_format[] = {
++	{ SPA_VIDEO_FORMAT_ENCODED,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "encoded", NULL },
++	{ SPA_VIDEO_FORMAT_I420,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I420", NULL },
++	{ SPA_VIDEO_FORMAT_YV12,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "YV12", NULL },
++	{ SPA_VIDEO_FORMAT_YUY2,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "YUY2", NULL },
++	{ SPA_VIDEO_FORMAT_UYVY,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "UYVY", NULL },
++	{ SPA_VIDEO_FORMAT_AYUV,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "AYUV", NULL },
++	{ SPA_VIDEO_FORMAT_RGBx,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGBx", NULL },
++	{ SPA_VIDEO_FORMAT_BGRx,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "BGRx", NULL },
++	{ SPA_VIDEO_FORMAT_xRGB,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "xRGB", NULL },
++	{ SPA_VIDEO_FORMAT_xBGR,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "xBGR", NULL },
++	{ SPA_VIDEO_FORMAT_RGBA,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGBA", NULL },
++	{ SPA_VIDEO_FORMAT_BGRA,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "BGRA", NULL },
++	{ SPA_VIDEO_FORMAT_ARGB,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "ARGB", NULL },
++	{ SPA_VIDEO_FORMAT_ABGR,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "ABGR", NULL },
++	{ SPA_VIDEO_FORMAT_RGB,		SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGB", NULL },
++	{ SPA_VIDEO_FORMAT_BGR,		SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "BGR", NULL },
++	{ SPA_VIDEO_FORMAT_Y41B,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y41B", NULL },
++	{ SPA_VIDEO_FORMAT_Y42B,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y42B", NULL },
++	{ SPA_VIDEO_FORMAT_YVYU,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "YVYU", NULL },
++	{ SPA_VIDEO_FORMAT_Y444,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y444", NULL },
++	{ SPA_VIDEO_FORMAT_v210,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "v210", NULL },
++	{ SPA_VIDEO_FORMAT_v216,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "v216", NULL },
++	{ SPA_VIDEO_FORMAT_NV12,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "NV12", NULL },
++	{ SPA_VIDEO_FORMAT_NV21,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "NV21", NULL },
++	{ SPA_VIDEO_FORMAT_GRAY8,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GRAY8", NULL },
++	{ SPA_VIDEO_FORMAT_GRAY16_BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GRAY16_BE", NULL },
++	{ SPA_VIDEO_FORMAT_GRAY16_LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GRAY16_LE", NULL },
++	{ SPA_VIDEO_FORMAT_v308,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "v308", NULL },
++	{ SPA_VIDEO_FORMAT_RGB16,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGB16", NULL },
++	{ SPA_VIDEO_FORMAT_BGR16,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "BGR16", NULL },
++	{ SPA_VIDEO_FORMAT_RGB15,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGB15", NULL },
++	{ SPA_VIDEO_FORMAT_BGR15,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "BGR15", NULL },
++	{ SPA_VIDEO_FORMAT_UYVP,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "UYVP", NULL },
++	{ SPA_VIDEO_FORMAT_A420,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A420", NULL },
++	{ SPA_VIDEO_FORMAT_RGB8P,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGB8P", NULL },
++	{ SPA_VIDEO_FORMAT_YUV9,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "YUV9", NULL },
++	{ SPA_VIDEO_FORMAT_YVU9,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "YVU9", NULL },
++	{ SPA_VIDEO_FORMAT_IYU1,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "IYU1", NULL },
++	{ SPA_VIDEO_FORMAT_ARGB64,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "ARGB64", NULL },
++	{ SPA_VIDEO_FORMAT_AYUV64,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "AYUV64", NULL },
++	{ SPA_VIDEO_FORMAT_r210,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "r210", NULL },
++	{ SPA_VIDEO_FORMAT_I420_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I420_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_I420_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I420_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_I422_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I422_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_I422_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I422_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_Y444_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y444_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_Y444_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y444_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_GBR,		SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBR", NULL },
++	{ SPA_VIDEO_FORMAT_GBR_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBR_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_GBR_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBR_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_NV16,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "NV16", NULL },
++	{ SPA_VIDEO_FORMAT_NV24,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "NV24", NULL },
++	{ SPA_VIDEO_FORMAT_NV12_64Z32,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "NV12_64Z32", NULL },
++	{ SPA_VIDEO_FORMAT_A420_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A420_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_A420_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A420_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_A422_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A422_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_A422_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A422_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_A444_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A444_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_A444_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "A444_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_NV61,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "NV61", NULL },
++	{ SPA_VIDEO_FORMAT_P010_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "P010_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_P010_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "P010_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_IYU2,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "IYU2", NULL },
++	{ SPA_VIDEO_FORMAT_VYUY,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "VYUY", NULL },
++	{ SPA_VIDEO_FORMAT_GBRA,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBRA", NULL },
++	{ SPA_VIDEO_FORMAT_GBRA_10BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBRA_10BE", NULL },
++	{ SPA_VIDEO_FORMAT_GBRA_10LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBRA_10LE", NULL },
++	{ SPA_VIDEO_FORMAT_GBR_12BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBR_12BE", NULL },
++	{ SPA_VIDEO_FORMAT_GBR_12LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBR_12LE", NULL },
++	{ SPA_VIDEO_FORMAT_GBRA_12BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBRA_12BE", NULL },
++	{ SPA_VIDEO_FORMAT_GBRA_12LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "GBRA_12LE", NULL },
++	{ SPA_VIDEO_FORMAT_I420_12BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I420_12BE", NULL },
++	{ SPA_VIDEO_FORMAT_I420_12LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I420_12LE", NULL },
++	{ SPA_VIDEO_FORMAT_I422_12BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I422_12BE", NULL },
++	{ SPA_VIDEO_FORMAT_I422_12LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "I422_12LE", NULL },
++	{ SPA_VIDEO_FORMAT_Y444_12BE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y444_12BE", NULL },
++	{ SPA_VIDEO_FORMAT_Y444_12LE,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "Y444_12LE", NULL },
++	{ SPA_VIDEO_FORMAT_RGBA_F16,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGBA_F16", NULL },
++	{ SPA_VIDEO_FORMAT_RGBA_F32,	SPA_TYPE_Int, SPA_TYPE_INFO_VIDEO_FORMAT_BASE "RGBA_F32", NULL },
++	{ 0, 0, NULL, NULL },
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_VIDEO_RAW_TYPES_H */
+diff --git a/third_party/pipewire/spa/pod/builder.h b/third_party/pipewire/spa/pod/builder.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/builder.h
+@@ -0,0 +1,671 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_POD_BUILDER_H
++#define SPA_POD_BUILDER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++
++#include <spa/utils/hook.h>
++#include <spa/pod/iter.h>
++#include <spa/pod/vararg.h>
++
++struct spa_pod_builder_state {
++	uint32_t offset;
++#define SPA_POD_BUILDER_FLAG_BODY	(1<<0)
++#define SPA_POD_BUILDER_FLAG_FIRST	(1<<1)
++	uint32_t flags;
++	struct spa_pod_frame *frame;
++};
++
++struct spa_pod_builder;
++
++struct spa_pod_builder_callbacks {
++#define SPA_VERSION_POD_BUILDER_CALLBACKS 0
++	uint32_t version;
++
++	int (*overflow) (void *data, uint32_t size);
++};
++
++struct spa_pod_builder {
++	void *data;
++	uint32_t size;
++	uint32_t _padding;
++	struct spa_pod_builder_state state;
++	struct spa_callbacks callbacks;
++};
++
++#define SPA_POD_BUILDER_INIT(buffer,size)  (struct spa_pod_builder){ buffer, size, }
++
++static inline void
++spa_pod_builder_get_state(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
++{
++	*state = builder->state;
++}
++
++static inline void
++spa_pod_builder_set_callbacks(struct spa_pod_builder *builder,
++		const struct spa_pod_builder_callbacks *callbacks, void *data)
++{
++	builder->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
++}
++
++static inline void
++spa_pod_builder_reset(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
++{
++	struct spa_pod_frame *f;
++	uint32_t size = builder->state.offset - state->offset;
++	builder->state = *state;
++	for (f = builder->state.frame; f ; f = f->parent)
++		f->pod.size -= size;
++}
++
++static inline void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
++{
++	*builder = SPA_POD_BUILDER_INIT(data, size);
++}
++
++static inline struct spa_pod *
++spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t offset)
++{
++	uint32_t size = builder->size;
++	if (offset + 8 <= size) {
++		struct spa_pod *pod = SPA_MEMBER(builder->data, offset, struct spa_pod);
++		if (offset + SPA_POD_SIZE(pod) <= size)
++			return pod;
++	}
++	return NULL;
++}
++
++static inline struct spa_pod *
++spa_pod_builder_frame(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
++{
++	if (frame->offset + SPA_POD_SIZE(&frame->pod) <= builder->size)
++		return SPA_MEMBER(builder->data, frame->offset, struct spa_pod);
++	return NULL;
++}
++
++static inline void
++spa_pod_builder_push(struct spa_pod_builder *builder,
++		     struct spa_pod_frame *frame,
++		     const struct spa_pod *pod,
++		     uint32_t offset)
++{
++	frame->pod = *pod;
++	frame->offset = offset;
++	frame->parent = builder->state.frame;
++	frame->flags = builder->state.flags;
++	builder->state.frame = frame;
++
++	if (frame->pod.type == SPA_TYPE_Array || frame->pod.type == SPA_TYPE_Choice)
++		builder->state.flags = SPA_POD_BUILDER_FLAG_FIRST | SPA_POD_BUILDER_FLAG_BODY;
++}
++
++static inline int spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
++{
++	int res = 0;
++	struct spa_pod_frame *f;
++	uint32_t offset = builder->state.offset;
++
++	if (offset + size > builder->size) {
++		res = -ENOSPC;
++		spa_callbacks_call_res(&builder->callbacks, struct spa_pod_builder_callbacks, res,
++				overflow, 0, offset + size);
++	}
++	if (res == 0 && data)
++		memcpy(SPA_MEMBER(builder->data, offset, void), data, size);
++
++	builder->state.offset += size;
++
++	for (f = builder->state.frame; f ; f = f->parent)
++		f->pod.size += size;
++
++	return res;
++}
++
++static inline int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
++{
++	uint64_t zeroes = 0;
++	size = SPA_ROUND_UP_N(size, 8) - size;
++	return size ? spa_pod_builder_raw(builder, &zeroes, size) : 0;
++}
++
++static inline int
++spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
++{
++	int r, res = spa_pod_builder_raw(builder, data, size);
++	if ((r = spa_pod_builder_pad(builder, size)) < 0)
++		res = r;
++	return res;
++}
++
++static inline void *spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
++{
++	struct spa_pod *pod;
++
++	if ((pod = (struct spa_pod*)spa_pod_builder_frame(builder, frame)) != NULL)
++		*pod = frame->pod;
++
++	builder->state.frame = frame->parent;
++	builder->state.flags = frame->flags;
++	spa_pod_builder_pad(builder, builder->state.offset);
++	return pod;
++}
++
++static inline int
++spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
++{
++	const void *data;
++	uint32_t size;
++	int r, res;
++
++	if (builder->state.flags == SPA_POD_BUILDER_FLAG_BODY) {
++		data = SPA_POD_BODY_CONST(p);
++		size = SPA_POD_BODY_SIZE(p);
++	} else {
++		data = p;
++		size = SPA_POD_SIZE(p);
++		SPA_FLAG_CLEAR(builder->state.flags, SPA_POD_BUILDER_FLAG_FIRST);
++	}
++	res = spa_pod_builder_raw(builder, data, size);
++	if (builder->state.flags != SPA_POD_BUILDER_FLAG_BODY)
++		if ((r = spa_pod_builder_pad(builder, size)) < 0)
++			res = r;
++	return res;
++}
++
++#define SPA_POD_INIT(size,type) (struct spa_pod) { size, type }
++
++#define SPA_POD_INIT_None() SPA_POD_INIT(0, SPA_TYPE_None)
++
++static inline int spa_pod_builder_none(struct spa_pod_builder *builder)
++{
++	const struct spa_pod p = SPA_POD_INIT_None();
++	return spa_pod_builder_primitive(builder, &p);
++}
++
++#define SPA_POD_INIT_Bool(val) (struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, val ? 1 : 0, 0 }
++
++static inline int spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
++{
++	const struct spa_pod_bool p = SPA_POD_INIT_Bool(val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Id(val) (struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (uint32_t)val, 0 }
++
++static inline int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
++{
++	const struct spa_pod_id p = SPA_POD_INIT_Id(val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Int(val) (struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (int32_t)val, 0 }
++
++static inline int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
++{
++	const struct spa_pod_int p = SPA_POD_INIT_Int(val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Long(val) (struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (int64_t)val }
++
++static inline int spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
++{
++	const struct spa_pod_long p = SPA_POD_INIT_Long(val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Float(val) (struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, val }
++
++static inline int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
++{
++	const struct spa_pod_float p = SPA_POD_INIT_Float(val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Double(val) (struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, val }
++
++static inline int spa_pod_builder_double(struct spa_pod_builder *builder, double val)
++{
++	const struct spa_pod_double p = SPA_POD_INIT_Double(val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_String(len) (struct spa_pod_string){ { len, SPA_TYPE_String } }
++
++static inline int
++spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
++{
++	int r, res;
++	res = spa_pod_builder_raw(builder, str, len);
++	if ((r = spa_pod_builder_raw(builder, "", 1)) < 0)
++		res = r;
++	if ((r = spa_pod_builder_pad(builder, builder->state.offset)) < 0)
++		res = r;
++	return res;
++}
++
++static inline int
++spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
++{
++	const struct spa_pod_string p = SPA_POD_INIT_String(len+1);
++	int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
++	if ((r = spa_pod_builder_write_string(builder, str, len)) < 0)
++		res = r;
++	return res;
++}
++
++static inline int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
++{
++	uint32_t len = str ? strlen(str) : 0;
++	return spa_pod_builder_string_len(builder, str ? str : "", len);
++}
++
++#define SPA_POD_INIT_Bytes(len) (struct spa_pod_bytes){ { len, SPA_TYPE_Bytes } }
++
++static inline int
++spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
++{
++	const struct spa_pod_bytes p = SPA_POD_INIT_Bytes(len);
++	int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
++	if ((r = spa_pod_builder_raw_padded(builder, bytes, len)) < 0)
++		res = r;
++	return res;
++}
++static inline void *
++spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
++{
++	uint32_t offset = builder->state.offset;
++	if (spa_pod_builder_bytes(builder, NULL, len) < 0)
++		return NULL;
++	return SPA_POD_BODY(spa_pod_builder_deref(builder, offset));
++}
++
++#define SPA_POD_INIT_Pointer(type,value) (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { type, 0, value } }
++
++static inline int
++spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const void *val)
++{
++	const struct spa_pod_pointer p = SPA_POD_INIT_Pointer(type, val);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Fd(fd) (struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, fd }
++
++static inline int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
++{
++	const struct spa_pod_fd p = SPA_POD_INIT_Fd(fd);
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Rectangle(val) (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, val }
++
++static inline int
++spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
++{
++	const struct spa_pod_rectangle p = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(width, height));
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++#define SPA_POD_INIT_Fraction(val) (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, val }
++
++static inline int
++spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
++{
++	const struct spa_pod_fraction p = SPA_POD_INIT_Fraction(SPA_FRACTION(num, denom));
++	return spa_pod_builder_primitive(builder, &p.pod);
++}
++
++static inline int
++spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
++{
++	const struct spa_pod_array p =
++	    { {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_TYPE_Array},
++	    {{0, 0}} };
++	uint32_t offset = builder->state.offset;
++	int res = spa_pod_builder_raw(builder, &p, sizeof(p) - sizeof(struct spa_pod));
++	spa_pod_builder_push(builder, frame, &p.pod, offset);
++	return res;
++}
++
++static inline int
++spa_pod_builder_array(struct spa_pod_builder *builder,
++		      uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
++{
++	const struct spa_pod_array p = {
++		{(uint32_t)(sizeof(struct spa_pod_array_body) + n_elems * child_size), SPA_TYPE_Array},
++		{{child_size, child_type}}
++	};
++	int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
++	if ((r = spa_pod_builder_raw_padded(builder, elems, child_size * n_elems)) < 0)
++		res = r;
++	return res;
++}
++
++#define SPA_POD_INIT_CHOICE_BODY(type, flags, child_size, child_type)				\
++	(struct spa_pod_choice_body) { type, flags, { child_size, child_type }}
++
++#define SPA_POD_INIT_Choice(type, ctype, child_type, n_vals, ...)				\
++	(struct { struct spa_pod_choice choice; ctype vals[n_vals];})				\
++	{ { { n_vals * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice },	\
++		{ type, 0, { sizeof(ctype), child_type } } }, { __VA_ARGS__ } }
++
++static inline int
++spa_pod_builder_push_choice(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
++		uint32_t type, uint32_t flags)
++{
++	const struct spa_pod_choice p =
++	    { {sizeof(struct spa_pod_choice_body) - sizeof(struct spa_pod), SPA_TYPE_Choice},
++	    { type, flags, {0, 0}} };
++	uint32_t offset = builder->state.offset;
++	int res = spa_pod_builder_raw(builder, &p, sizeof(p) - sizeof(struct spa_pod));
++	spa_pod_builder_push(builder, frame, &p.pod, offset);
++	return res;
++}
++
++#define SPA_POD_INIT_Struct(size) (struct spa_pod_struct){ { size, SPA_TYPE_Struct } }
++
++static inline int
++spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
++{
++	const struct spa_pod_struct p = SPA_POD_INIT_Struct(0);
++	uint32_t offset = builder->state.offset;
++	int res = spa_pod_builder_raw(builder, &p, sizeof(p));
++	spa_pod_builder_push(builder, frame, &p.pod, offset);
++	return res;
++}
++
++#define SPA_POD_INIT_Object(size,type,id,...)	(struct spa_pod_object){ { size, SPA_TYPE_Object }, { type, id }, ##__VA_ARGS__ }
++
++static inline int
++spa_pod_builder_push_object(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
++		uint32_t type, uint32_t id)
++{
++	const struct spa_pod_object p =
++	    SPA_POD_INIT_Object(sizeof(struct spa_pod_object_body), type, id);
++	uint32_t offset = builder->state.offset;
++	int res = spa_pod_builder_raw(builder, &p, sizeof(p));
++	spa_pod_builder_push(builder, frame, &p.pod, offset);
++	return res;
++}
++
++#define SPA_POD_INIT_Prop(key,flags,size,type)	\
++	(struct spa_pod_prop){ key, flags, { size, type } }
++
++static inline int
++spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
++{
++	const struct { uint32_t key; uint32_t flags; } p = { key, flags };
++	return spa_pod_builder_raw(builder, &p, sizeof(p));
++}
++
++#define SPA_POD_INIT_Sequence(size,unit)	\
++	(struct spa_pod_sequence){ { size, SPA_TYPE_Sequence}, {unit, 0 } }
++
++static inline int
++spa_pod_builder_push_sequence(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t unit)
++{
++	const struct spa_pod_sequence p =
++	    SPA_POD_INIT_Sequence(sizeof(struct spa_pod_sequence_body), unit);
++	uint32_t offset = builder->state.offset;
++	int res = spa_pod_builder_raw(builder, &p, sizeof(p));
++	spa_pod_builder_push(builder, frame, &p.pod, offset);
++	return res;
++}
++
++static inline uint32_t
++spa_pod_builder_control(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
++{
++	const struct { uint32_t offset; uint32_t type; } p = { offset, type };
++	return spa_pod_builder_raw(builder, &p, sizeof(p));
++}
++
++static inline uint32_t spa_choice_from_id(char id)
++{
++	switch (id) {
++	case 'r':
++		return SPA_CHOICE_Range;
++	case 's':
++		return SPA_CHOICE_Step;
++	case 'e':
++		return SPA_CHOICE_Enum;
++	case 'f':
++		return SPA_CHOICE_Flags;
++	case 'n':
++	default:
++		return SPA_CHOICE_None;
++	}
++}
++
++#define SPA_POD_BUILDER_COLLECT(builder,type,args)				\
++do {										\
++	switch (type) {								\
++	case 'b':								\
++		spa_pod_builder_bool(builder, !!va_arg(args, int));		\
++		break;								\
++	case 'I':								\
++		spa_pod_builder_id(builder, va_arg(args, uint32_t));		\
++		break;								\
++	case 'i':								\
++		spa_pod_builder_int(builder, va_arg(args, int));		\
++		break;								\
++	case 'l':								\
++		spa_pod_builder_long(builder, va_arg(args, int64_t));		\
++		break;								\
++	case 'f':								\
++		spa_pod_builder_float(builder, va_arg(args, double));		\
++		break;								\
++	case 'd':								\
++		spa_pod_builder_double(builder, va_arg(args, double));		\
++		break;								\
++	case 's':								\
++	{									\
++		char *strval = va_arg(args, char *);				\
++		if (strval != NULL) {						\
++			size_t len = strlen(strval);				\
++			spa_pod_builder_string_len(builder, strval, len);	\
++		}								\
++		else								\
++			spa_pod_builder_none(builder);				\
++		break;								\
++	}									\
++	case 'S':								\
++	{									\
++		char *strval = va_arg(args, char *);				\
++		size_t len = va_arg(args, int);					\
++		spa_pod_builder_string_len(builder, strval, len);		\
++		break;								\
++	}									\
++	case 'y':								\
++	{									\
++		void *ptr  = va_arg(args, void *);				\
++		int len = va_arg(args, int);					\
++		spa_pod_builder_bytes(builder, ptr, len);			\
++		break;								\
++	}									\
++	case 'R':								\
++	{									\
++		struct spa_rectangle *rectval =					\
++			va_arg(args, struct spa_rectangle *);			\
++		spa_pod_builder_rectangle(builder,				\
++				rectval->width, rectval->height);		\
++		break;								\
++	}									\
++	case 'F':								\
++	{									\
++		struct spa_fraction *fracval =					\
++			va_arg(args, struct spa_fraction *);			\
++		spa_pod_builder_fraction(builder, fracval->num, fracval->denom);\
++		break;								\
++	}									\
++	case 'a':								\
++	{									\
++		int child_size = va_arg(args, int);				\
++		int child_type = va_arg(args, int);				\
++		int n_elems = va_arg(args, int);				\
++		void *elems = va_arg(args, void *);				\
++		spa_pod_builder_array(builder, child_size,			\
++				child_type, n_elems, elems);			\
++		break;								\
++	}									\
++	case 'p':								\
++	{									\
++		int t = va_arg(args, uint32_t);					\
++		spa_pod_builder_pointer(builder, t, va_arg(args, void *));	\
++		break;								\
++	}									\
++	case 'h':								\
++		spa_pod_builder_fd(builder, va_arg(args, int));			\
++		break;								\
++	case 'P':								\
++	case 'O':								\
++	case 'T':								\
++	case 'V':								\
++	{									\
++		struct spa_pod *pod = va_arg(args, struct spa_pod *);		\
++		if (pod == NULL)						\
++			spa_pod_builder_none(builder);				\
++		else								\
++			spa_pod_builder_primitive(builder, pod);		\
++		break;								\
++	}									\
++	}									\
++} while(false)
++
++static inline int
++spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
++{
++	int res = 0;
++	struct spa_pod_frame *f = builder->state.frame;
++	uint32_t ftype = f ? f->pod.type : (uint32_t)SPA_TYPE_None;
++
++	do {
++		const char *format;
++		int n_values = 1;
++		struct spa_pod_frame f;
++		bool choice;
++
++		switch (ftype) {
++		case SPA_TYPE_Object:
++		{
++			uint32_t key = va_arg(args, uint32_t);
++			if (key == 0)
++				goto exit;
++			spa_pod_builder_prop(builder, key, 0);
++			break;
++		}
++		case SPA_TYPE_Sequence:
++		{
++			uint32_t offset = va_arg(args, uint32_t);
++			uint32_t type = va_arg(args, uint32_t);
++			if (type == 0)
++				goto exit;
++			spa_pod_builder_control(builder, offset, type);
++		}
++		default:
++			break;
++		}
++		if ((format = va_arg(args, const char *)) == NULL)
++			break;
++
++		choice = *format == '?';
++		if (choice) {
++			uint32_t type = spa_choice_from_id(*++format);
++			if (*format != '\0')
++				format++;
++
++			spa_pod_builder_push_choice(builder, &f, type, 0);
++
++			n_values = va_arg(args, int);
++		}
++		while (n_values-- > 0)
++			SPA_POD_BUILDER_COLLECT(builder, *format, args);
++
++		if (choice)
++			spa_pod_builder_pop(builder, &f);
++	} while (true);
++
++      exit:
++	return res;
++}
++
++static inline int spa_pod_builder_add(struct spa_pod_builder *builder, ...)
++{
++	int res;
++	va_list args;
++
++	va_start(args, builder);
++	res = spa_pod_builder_addv(builder, args);
++	va_end(args);
++
++	return res;
++}
++
++#define spa_pod_builder_add_object(b,type,id,...)				\
++({										\
++	struct spa_pod_frame _f;						\
++	spa_pod_builder_push_object(b, &_f, type, id);				\
++	spa_pod_builder_add(b, ##__VA_ARGS__, 0);				\
++	spa_pod_builder_pop(b, &_f);						\
++})
++
++#define spa_pod_builder_add_struct(b,...)					\
++({										\
++	struct spa_pod_frame _f;						\
++	spa_pod_builder_push_struct(b, &_f);					\
++	spa_pod_builder_add(b, ##__VA_ARGS__, NULL);				\
++	spa_pod_builder_pop(b, &_f);						\
++})
++
++#define spa_pod_builder_add_sequence(b,unit,...)				\
++({										\
++	struct spa_pod_frame _f;						\
++	spa_pod_builder_push_sequence(b, &_f, unit);				\
++	spa_pod_builder_add(b, ##__VA_ARGS__, 0, 0);				\
++	spa_pod_builder_pop(b, &_f);						\
++})
++
++/** Copy a pod structure */
++static inline struct spa_pod *
++spa_pod_copy(const struct spa_pod *pod)
++{
++	size_t size;
++	struct spa_pod *c;
++
++	size = SPA_POD_SIZE(pod);
++	if ((c = (struct spa_pod *) malloc(size)) == NULL)
++		return NULL;
++	return (struct spa_pod *) memcpy(c, pod, size);
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_POD_BUILDER_H */
+diff --git a/third_party/pipewire/spa/pod/command.h b/third_party/pipewire/spa/pod/command.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/command.h
+@@ -0,0 +1,61 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_COMMAND_H
++#define SPA_COMMAND_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/pod/pod.h>
++
++struct spa_command_body {
++	struct spa_pod_object_body body;
++};
++
++struct spa_command {
++	struct spa_pod		pod;
++	struct spa_command_body body;
++};
++
++#define SPA_COMMAND_TYPE(cmd)		((cmd)->body.body.type)
++#define SPA_COMMAND_ID(cmd,type)	(SPA_COMMAND_TYPE(cmd) == type ? \
++						(cmd)->body.body.id : SPA_ID_INVALID)
++
++#define SPA_COMMAND_INIT_FULL(t,size,type,id,...) (t)			\
++	{ { size, SPA_TYPE_Object },					\
++	  { { type, id }, ##__VA_ARGS__ } }				\
++
++#define SPA_COMMAND_INIT(type,id)					\
++	SPA_COMMAND_INIT_FULL(struct spa_command,			\
++			sizeof(struct spa_command_body), type, id)
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_COMMAND_H */
+diff --git a/third_party/pipewire/spa/pod/compare.h b/third_party/pipewire/spa/pod/compare.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/compare.h
+@@ -0,0 +1,181 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_POD_COMPARE_H
++#define SPA_POD_COMPARE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++#include <errno.h>
++#include <stdint.h>
++#include <stddef.h>
++#include <stdio.h>
++#include <string.h>
++
++#include <spa/param/props.h>
++#include <spa/pod/iter.h>
++#include <spa/pod/builder.h>
++
++static inline int spa_pod_compare_value(uint32_t type, const void *r1, const void *r2, uint32_t size)
++{
++	switch (type) {
++	case SPA_TYPE_None:
++		return 0;
++	case SPA_TYPE_Bool:
++	case SPA_TYPE_Id:
++		return *(uint32_t *) r1 == *(uint32_t *) r2 ? 0 : 1;
++	case SPA_TYPE_Int:
++		return *(int32_t *) r1 - *(int32_t *) r2;
++	case SPA_TYPE_Long:
++		return *(int64_t *) r1 - *(int64_t *) r2;
++	case SPA_TYPE_Float:
++		return *(float *) r1 - *(float *) r2;
++	case SPA_TYPE_Double:
++		return *(double *) r1 - *(double *) r2;
++	case SPA_TYPE_String:
++		return strcmp((char *)r1, (char *)r2);
++	case SPA_TYPE_Bytes:
++		return memcmp((char *)r1, (char *)r2, size);
++	case SPA_TYPE_Rectangle:
++	{
++		const struct spa_rectangle *rec1 = (struct spa_rectangle *) r1,
++		    *rec2 = (struct spa_rectangle *) r2;
++		if (rec1->width == rec2->width && rec1->height == rec2->height)
++			return 0;
++		else if (rec1->width < rec2->width || rec1->height < rec2->height)
++			return -1;
++		else
++			return 1;
++	}
++	case SPA_TYPE_Fraction:
++	{
++		const struct spa_fraction *f1 = (struct spa_fraction *) r1,
++		    *f2 = (struct spa_fraction *) r2;
++		int64_t n1, n2;
++		n1 = ((int64_t) f1->num) * f2->denom;
++		n2 = ((int64_t) f2->num) * f1->denom;
++		if (n1 < n2)
++			return -1;
++		else if (n1 > n2)
++			return 1;
++		else
++			return 0;
++	}
++	default:
++		break;
++	}
++	return 0;
++}
++
++static inline int spa_pod_compare(const struct spa_pod *pod1,
++				  const struct spa_pod *pod2)
++{
++	int res = 0;
++	uint32_t n_vals1, n_vals2;
++	uint32_t choice1, choice2;
++
++        spa_return_val_if_fail(pod1 != NULL, -EINVAL);
++        spa_return_val_if_fail(pod2 != NULL, -EINVAL);
++
++	pod1 = spa_pod_get_values(pod1,  &n_vals1, &choice1);
++	pod2 = spa_pod_get_values(pod2,  &n_vals2, &choice2);
++
++	if (n_vals1 != n_vals2)
++		return -EINVAL;
++
++	if (SPA_POD_TYPE(pod1) != SPA_POD_TYPE(pod2))
++		return -EINVAL;
++
++	switch (SPA_POD_TYPE(pod1)) {
++	case SPA_TYPE_Struct:
++	{
++		const struct spa_pod *p1, *p2;
++		size_t p1s, p2s;
++
++		p1 = (const struct spa_pod*)SPA_POD_BODY_CONST(pod1);
++		p1s = SPA_POD_BODY_SIZE(pod1);
++		p2 = (const struct spa_pod*)SPA_POD_BODY_CONST(pod2);
++		p2s = SPA_POD_BODY_SIZE(pod2);
++
++		while (true) {
++			if (!spa_pod_is_inside(pod1, p1s, p1) ||
++			    !spa_pod_is_inside(pod2, p2s, p2))
++				return -EINVAL;
++
++			if ((res = spa_pod_compare(p1, p2)) != 0)
++				return res;
++
++			p1 = (const struct spa_pod*)spa_pod_next(p1);
++			p2 = (const struct spa_pod*)spa_pod_next(p2);
++		}
++		break;
++	}
++	case SPA_TYPE_Object:
++	{
++		const struct spa_pod_prop *p1, *p2;
++		const struct spa_pod_object *o1, *o2;
++
++		o1 = (const struct spa_pod_object*)pod1;
++		o2 = (const struct spa_pod_object*)pod2;
++
++		p2 = NULL;
++		SPA_POD_OBJECT_FOREACH(o1, p1) {
++			if ((p2 = spa_pod_object_find_prop(o2, p2, p1->key)) == NULL)
++				return 1;
++			if ((res = spa_pod_compare(&p1->value, &p2->value)) != 0)
++				return res;
++		}
++		p1 = NULL;
++		SPA_POD_OBJECT_FOREACH(o2, p2) {
++			if ((p1 = spa_pod_object_find_prop(o1, p1, p2->key)) == NULL)
++				return -1;
++		}
++		break;
++	}
++	case SPA_TYPE_Array:
++	{
++		if (SPA_POD_BODY_SIZE(pod1) != SPA_POD_BODY_SIZE(pod2))
++			return -EINVAL;
++		res = memcmp(SPA_POD_BODY(pod1), SPA_POD_BODY(pod2), SPA_POD_BODY_SIZE(pod2));
++		break;
++	}
++	default:
++		if (SPA_POD_BODY_SIZE(pod1) != SPA_POD_BODY_SIZE(pod2))
++			return -EINVAL;
++		res = spa_pod_compare_value(SPA_POD_TYPE(pod1),
++				SPA_POD_BODY(pod1), SPA_POD_BODY(pod2),
++				SPA_POD_BODY_SIZE(pod1));
++		break;
++	}
++	return res;
++}
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+diff --git a/third_party/pipewire/spa/pod/event.h b/third_party/pipewire/spa/pod/event.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/event.h
+@@ -0,0 +1,59 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_EVENT_H
++#define SPA_EVENT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/pod/pod.h>
++
++struct spa_event_body {
++	struct spa_pod_object_body body;
++};
++
++struct spa_event {
++	struct spa_pod pod;
++	struct spa_event_body body;
++};
++
++#define SPA_EVENT_TYPE(ev)	((ev)->body.body.type)
++#define SPA_EVENT_ID(ev,type)	(SPA_EVENT_TYPE(ev) == type ? \
++					(ev)->body.body.id : SPA_ID_INVALID)
++
++#define SPA_EVENT_INIT_FULL(t,size,type,id,...) (t)			\
++	{ { size, SPA_TYPE_OBJECT },					\
++	  { { type, id }, ##__VA_ARGS__ } }				\
++
++#define SPA_EVENT_INIT(type,id)						\
++	SPA_EVENT_INIT_FULL(struct spa_event,				\
++			sizeof(struct spa_event_body), type, id)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_EVENT_H */
+diff --git a/third_party/pipewire/spa/pod/filter.h b/third_party/pipewire/spa/pod/filter.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/filter.h
+@@ -0,0 +1,395 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#include <errno.h>
++#include <stdint.h>
++#include <stddef.h>
++#include <stdio.h>
++#include <string.h>
++
++#include <spa/param/props.h>
++#include <spa/pod/iter.h>
++#include <spa/pod/builder.h>
++#include <spa/pod/compare.h>
++
++static inline int spa_pod_choice_fix_default(struct spa_pod_choice *choice)
++{
++	void *val, *alt;
++	int i, nvals;
++	uint32_t type, size;
++
++	nvals = SPA_POD_CHOICE_N_VALUES(choice);
++	type = SPA_POD_CHOICE_VALUE_TYPE(choice);
++	size = SPA_POD_CHOICE_VALUE_SIZE(choice);
++	alt = val = SPA_POD_CHOICE_VALUES(choice);
++
++	switch (choice->body.type) {
++	case SPA_CHOICE_None:
++		break;
++	case SPA_CHOICE_Range:
++	case SPA_CHOICE_Step:
++		if (nvals > 1) {
++			alt = SPA_MEMBER(alt, size, void);
++			if (spa_pod_compare_value(type, val, alt, size) < 0)
++				memcpy(val, alt, size);
++		}
++		if (nvals > 2) {
++			alt = SPA_MEMBER(alt, size, void);
++			if (spa_pod_compare_value(type, val, alt, size) > 0)
++				memcpy(val, alt, size);
++		}
++		break;
++	case SPA_CHOICE_Flags:
++	case SPA_CHOICE_Enum:
++	{
++		void *best = NULL;
++
++		for (i = 1; i < nvals; i++) {
++			alt = SPA_MEMBER(alt, size, void);
++			if (spa_pod_compare_value(type, val, alt, size) == 0) {
++				best = alt;
++				break;
++			}
++			if (best == NULL)
++				best = alt;
++		}
++		if (best)
++			memcpy(val, best, size);
++
++		if (nvals <= 1)
++			choice->body.type = SPA_CHOICE_None;
++		break;
++	}
++	}
++	return 0;
++}
++
++static inline int spa_pod_filter_flags_value(struct spa_pod_builder *b,
++		uint32_t type, const void *r1, const void *r2, uint32_t size)
++{
++	switch (type) {
++	case SPA_TYPE_Int:
++	{
++		int32_t val = (*(int32_t *) r1) & (*(int32_t *) r2);
++		if (val == 0)
++			return 0;
++		spa_pod_builder_int(b, val);
++		break;
++	}
++	case SPA_TYPE_Long:
++	{
++		int64_t val = (*(int64_t *) r1) & (*(int64_t *) r2);
++		if (val == 0)
++			return 0;
++		spa_pod_builder_long(b, val);
++		break;
++	}
++	default:
++		return -ENOTSUP;
++	}
++	return 1;
++}
++
++
++static inline int
++spa_pod_filter_prop(struct spa_pod_builder *b,
++	    const struct spa_pod_prop *p1,
++	    const struct spa_pod_prop *p2)
++{
++	const struct spa_pod *v1, *v2;
++	struct spa_pod_choice *nc;
++	uint32_t j, k, nalt1, nalt2;
++	void *alt1, *alt2, *a1, *a2;
++	uint32_t type, size, p1c, p2c;
++	struct spa_pod_frame f;
++
++	v1 = spa_pod_get_values(&p1->value, &nalt1, &p1c);
++	alt1 = SPA_POD_BODY(v1);
++	v2 = spa_pod_get_values(&p2->value, &nalt2, &p2c);
++	alt2 = SPA_POD_BODY(v2);
++
++	type = v1->type;
++	size = v1->size;
++
++	/* incompatible property types */
++	if (type != v2->type || size != v2->size || p1->key != p2->key)
++		return -EINVAL;
++
++	if (p1c == SPA_CHOICE_None || p1c == SPA_CHOICE_Flags) {
++		nalt1 = 1;
++	} else {
++		alt1 = SPA_MEMBER(alt1, size, void);
++		nalt1--;
++	}
++
++	if (p2c == SPA_CHOICE_None || p2c == SPA_CHOICE_Flags) {
++		nalt2 = 1;
++	} else {
++		alt2 = SPA_MEMBER(alt2, size, void);
++		nalt2--;
++	}
++
++	/* start with copying the property */
++	spa_pod_builder_prop(b, p1->key, 0);
++	spa_pod_builder_push_choice(b, &f, 0, 0);
++	nc = (struct spa_pod_choice*)spa_pod_builder_frame(b, &f);
++
++	/* default value */
++	spa_pod_builder_primitive(b, v1);
++
++	if ((p1c == SPA_CHOICE_None && p2c == SPA_CHOICE_None) ||
++	    (p1c == SPA_CHOICE_None && p2c == SPA_CHOICE_Enum) ||
++	    (p1c == SPA_CHOICE_Enum && p2c == SPA_CHOICE_None) ||
++	    (p1c == SPA_CHOICE_Enum && p2c == SPA_CHOICE_Enum)) {
++		int n_copied = 0;
++		/* copy all equal values but don't copy the default value again */
++		for (j = 0, a1 = alt1; j < nalt1; j++, a1 = SPA_MEMBER(a1, size, void)) {
++			for (k = 0, a2 = alt2; k < nalt2; k++, a2 = SPA_MEMBER(a2,size,void)) {
++				if (spa_pod_compare_value(type, a1, a2, size) == 0) {
++					if (p1c == SPA_CHOICE_Enum || j > 0)
++						spa_pod_builder_raw(b, a1, size);
++					n_copied++;
++				}
++			}
++		}
++		if (n_copied == 0)
++			return -EINVAL;
++		nc->body.type = SPA_CHOICE_Enum;
++	}
++
++	if ((p1c == SPA_CHOICE_None && p2c == SPA_CHOICE_Range) ||
++	    (p1c == SPA_CHOICE_Enum && p2c == SPA_CHOICE_Range)) {
++		int n_copied = 0;
++		/* copy all values inside the range */
++		for (j = 0, a1 = alt1, a2 = alt2; j < nalt1; j++, a1 = SPA_MEMBER(a1,size,void)) {
++			if (spa_pod_compare_value(type, a1, a2, size) < 0)
++				continue;
++			if (spa_pod_compare_value(type, a1, SPA_MEMBER(a2,size,void), size) > 0)
++				continue;
++			spa_pod_builder_raw(b, a1, size);
++			n_copied++;
++		}
++		if (n_copied == 0)
++			return -EINVAL;
++		nc->body.type = SPA_CHOICE_Enum;
++	}
++
++	if ((p1c == SPA_CHOICE_None && p2c == SPA_CHOICE_Step) ||
++	    (p1c == SPA_CHOICE_Enum && p2c == SPA_CHOICE_Step)) {
++		return -ENOTSUP;
++	}
++
++	if ((p1c == SPA_CHOICE_Range && p2c == SPA_CHOICE_None) ||
++	    (p1c == SPA_CHOICE_Range && p2c == SPA_CHOICE_Enum)) {
++		int n_copied = 0;
++		/* copy all values inside the range */
++		for (k = 0, a1 = alt1, a2 = alt2; k < nalt2; k++, a2 = SPA_MEMBER(a2,size,void)) {
++			if (spa_pod_compare_value(type, a2, a1, size) < 0)
++				continue;
++			if (spa_pod_compare_value(type, a2, SPA_MEMBER(a1,size,void), size) > 0)
++				continue;
++			spa_pod_builder_raw(b, a2, size);
++			n_copied++;
++		}
++		if (n_copied == 0)
++			return -EINVAL;
++		nc->body.type = SPA_CHOICE_Enum;
++	}
++
++	if ((p1c == SPA_CHOICE_Range && p2c == SPA_CHOICE_Range) ||
++	    (p1c == SPA_CHOICE_Range && p2c == SPA_CHOICE_Step) ||
++	    (p1c == SPA_CHOICE_Step && p2c == SPA_CHOICE_Range) ||
++	    (p1c == SPA_CHOICE_Step && p2c == SPA_CHOICE_Step)) {
++		if (spa_pod_compare_value(type, alt1, alt2, size) < 0)
++			spa_pod_builder_raw(b, alt2, size);
++		else
++			spa_pod_builder_raw(b, alt1, size);
++
++		alt1 = SPA_MEMBER(alt1,size,void);
++		alt2 = SPA_MEMBER(alt2,size,void);
++
++		if (spa_pod_compare_value(type, alt1, alt2, size) < 0)
++			spa_pod_builder_raw(b, alt1, size);
++		else
++			spa_pod_builder_raw(b, alt2, size);
++
++		nc->body.type = SPA_CHOICE_Range;
++	}
++
++	if ((p1c == SPA_CHOICE_None && p2c == SPA_CHOICE_Flags) ||
++	    (p1c == SPA_CHOICE_Flags && p2c == SPA_CHOICE_None) ||
++	    (p1c == SPA_CHOICE_Flags && p2c == SPA_CHOICE_Flags)) {
++		if (spa_pod_filter_flags_value(b, type, alt1, alt2, size) != 1)
++			return -EINVAL;
++		nc->body.type = SPA_CHOICE_Flags;
++	}
++
++	if (p1c == SPA_CHOICE_Range && p2c == SPA_CHOICE_Flags)
++		return -ENOTSUP;
++
++	if (p1c == SPA_CHOICE_Enum && p2c == SPA_CHOICE_Flags)
++		return -ENOTSUP;
++
++	if (p1c == SPA_CHOICE_Step && p2c == SPA_CHOICE_None)
++		return -ENOTSUP;
++	if (p1c == SPA_CHOICE_Step && p2c == SPA_CHOICE_Enum)
++		return -ENOTSUP;
++	if (p1c == SPA_CHOICE_Step && p2c == SPA_CHOICE_Flags)
++		return -ENOTSUP;
++
++	if (p1c == SPA_CHOICE_Flags && p2c == SPA_CHOICE_Range)
++		return -ENOTSUP;
++	if (p1c == SPA_CHOICE_Flags && p2c == SPA_CHOICE_Step)
++		return -ENOTSUP;
++	if (p1c == SPA_CHOICE_Flags && p2c == SPA_CHOICE_Enum)
++		return -ENOTSUP;
++
++	spa_pod_builder_pop(b, &f);
++	spa_pod_choice_fix_default(nc);
++
++	return 0;
++}
++
++static inline int spa_pod_filter_part(struct spa_pod_builder *b,
++	       const struct spa_pod *pod, uint32_t pod_size,
++	       const struct spa_pod *filter, uint32_t filter_size)
++{
++	const struct spa_pod *pp, *pf;
++	int res = 0;
++
++	pf = filter;
++
++	SPA_POD_FOREACH(pod, pod_size, pp) {
++		bool do_copy = false, do_advance = false;
++		uint32_t filter_offset = 0;
++		struct spa_pod_frame f;
++
++		switch (SPA_POD_TYPE(pp)) {
++		case SPA_TYPE_Object:
++			if (pf != NULL) {
++				struct spa_pod_object *op = (struct spa_pod_object *) pp;
++				struct spa_pod_object *of = (struct spa_pod_object *) pf;
++				const struct spa_pod_prop *p1, *p2;
++
++				if (SPA_POD_TYPE(pf) != SPA_POD_TYPE(pp))
++					return -EINVAL;
++
++				spa_pod_builder_push_object(b, &f, op->body.type, op->body.id);
++				p2 = NULL;
++				SPA_POD_OBJECT_FOREACH(op, p1) {
++					p2 = spa_pod_object_find_prop(of, p2, p1->key);
++					if (p2 != NULL)
++						res = spa_pod_filter_prop(b, p1, p2);
++					else
++						spa_pod_builder_raw_padded(b, p1, SPA_POD_PROP_SIZE(p1));
++					if (res < 0)
++						break;
++				}
++				if (res >= 0) {
++					p1 = NULL;
++					SPA_POD_OBJECT_FOREACH(of, p2) {
++						p1 = spa_pod_object_find_prop(op, p1, p2->key);
++						if (p1 != NULL)
++							continue;
++
++						spa_pod_builder_raw_padded(b, p2, SPA_POD_PROP_SIZE(p2));
++					}
++				}
++				spa_pod_builder_pop(b, &f);
++				do_advance = true;
++			}
++			else
++				do_copy = true;
++			break;
++
++		case SPA_TYPE_Struct:
++			if (pf != NULL) {
++				if (SPA_POD_TYPE(pf) != SPA_POD_TYPE(pp))
++					return -EINVAL;
++
++				filter_offset = sizeof(struct spa_pod_struct);
++				spa_pod_builder_push_struct(b, &f);
++				res = spa_pod_filter_part(b,
++					SPA_MEMBER(pp,filter_offset,const struct spa_pod),
++					SPA_POD_SIZE(pp) - filter_offset,
++					SPA_MEMBER(pf,filter_offset,const struct spa_pod),
++					SPA_POD_SIZE(pf) - filter_offset);
++			        spa_pod_builder_pop(b, &f);
++				do_advance = true;
++			}
++			else
++				do_copy = true;
++			break;
++
++		default:
++			if (pf != NULL) {
++				if (SPA_POD_SIZE(pp) != SPA_POD_SIZE(pf))
++					return -EINVAL;
++				if (memcmp(pp, pf, SPA_POD_SIZE(pp)) != 0)
++					return -EINVAL;
++				do_advance = true;
++			}
++			do_copy = true;
++			break;
++		}
++		if (do_copy)
++			spa_pod_builder_raw_padded(b, pp, SPA_POD_SIZE(pp));
++		if (do_advance) {
++			pf = (const struct spa_pod*)spa_pod_next(pf);
++			if (!spa_pod_is_inside(filter, filter_size, pf))
++				pf = NULL;
++		}
++		if (res < 0)
++			break;
++	}
++	return res;
++}
++
++static inline int
++spa_pod_filter(struct spa_pod_builder *b,
++	       struct spa_pod **result,
++	       const struct spa_pod *pod,
++	       const struct spa_pod *filter)
++{
++	int res;
++	struct spa_pod_builder_state state;
++
++        spa_return_val_if_fail(pod != NULL, -EINVAL);
++        spa_return_val_if_fail(b != NULL, -EINVAL);
++
++	spa_pod_builder_get_state(b, &state);
++	if (filter == NULL)
++		res = spa_pod_builder_raw_padded(b, pod, SPA_POD_SIZE(pod));
++	else
++		res = spa_pod_filter_part(b, pod, SPA_POD_SIZE(pod), filter, SPA_POD_SIZE(filter));
++
++	if (res < 0) {
++		spa_pod_builder_reset(b, &state);
++	} else if (result) {
++		*result = (struct spa_pod*)spa_pod_builder_deref(b, state.offset);
++		if (*result == NULL)
++			res = -ENOSPC;
++	}
++	return res;
++}
+diff --git a/third_party/pipewire/spa/pod/iter.h b/third_party/pipewire/spa/pod/iter.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/iter.h
+@@ -0,0 +1,446 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_POD_ITER_H
++#define SPA_POD_ITER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <errno.h>
++#include <sys/types.h>
++
++#include <spa/pod/pod.h>
++
++struct spa_pod_frame {
++	struct spa_pod pod;
++	struct spa_pod_frame *parent;
++	uint32_t offset;
++	uint32_t flags;
++};
++
++static inline bool spa_pod_is_inside(const void *pod, uint32_t size, const void *iter)
++{
++	return SPA_POD_BODY(iter) <= SPA_MEMBER(pod, size, void) &&
++		SPA_MEMBER(iter, SPA_POD_SIZE(iter), void) <= SPA_MEMBER(pod, size, void);
++}
++
++static inline void *spa_pod_next(const void *iter)
++{
++	return SPA_MEMBER(iter, SPA_ROUND_UP_N(SPA_POD_SIZE(iter), 8), void);
++}
++
++static inline struct spa_pod_prop *spa_pod_prop_first(const struct spa_pod_object_body *body)
++{
++	return SPA_MEMBER(body, sizeof(struct spa_pod_object_body), struct spa_pod_prop);
++}
++
++static inline bool spa_pod_prop_is_inside(const struct spa_pod_object_body *body,
++		uint32_t size, const struct spa_pod_prop *iter)
++{
++	return SPA_POD_CONTENTS(struct spa_pod_prop, iter) <= SPA_MEMBER(body, size, void) &&
++		SPA_MEMBER(iter, SPA_POD_PROP_SIZE(iter), void) <= SPA_MEMBER(body, size, void);
++}
++
++static inline struct spa_pod_prop *spa_pod_prop_next(const struct spa_pod_prop *iter)
++{
++	return SPA_MEMBER(iter, SPA_ROUND_UP_N(SPA_POD_PROP_SIZE(iter), 8), struct spa_pod_prop);
++}
++
++static inline struct spa_pod_control *spa_pod_control_first(const struct spa_pod_sequence_body *body)
++{
++	return SPA_MEMBER(body, sizeof(struct spa_pod_sequence_body), struct spa_pod_control);
++}
++
++static inline bool spa_pod_control_is_inside(const struct spa_pod_sequence_body *body,
++		uint32_t size, const struct spa_pod_control *iter)
++{
++	return SPA_POD_CONTENTS(struct spa_pod_control, iter) <= SPA_MEMBER(body, size, void) &&
++		SPA_MEMBER(iter, SPA_POD_CONTROL_SIZE(iter), void) <= SPA_MEMBER(body, size, void);
++}
++
++static inline struct spa_pod_control *spa_pod_control_next(const struct spa_pod_control *iter)
++{
++	return SPA_MEMBER(iter, SPA_ROUND_UP_N(SPA_POD_CONTROL_SIZE(iter), 8), struct spa_pod_control);
++}
++
++#define SPA_POD_ARRAY_BODY_FOREACH(body, _size, iter)							\
++	for ((iter) = (__typeof__(iter))SPA_MEMBER((body), sizeof(struct spa_pod_array_body), void);	\
++	     (iter) < (__typeof__(iter))SPA_MEMBER((body), (_size), void);				\
++	     (iter) = (__typeof__(iter))SPA_MEMBER((iter), (body)->child.size, void))
++
++#define SPA_POD_ARRAY_FOREACH(obj, iter)							\
++	SPA_POD_ARRAY_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
++
++#define SPA_POD_CHOICE_BODY_FOREACH(body, _size, iter)							\
++	for ((iter) = (__typeof__(iter))SPA_MEMBER((body), sizeof(struct spa_pod_choice_body), void);	\
++	     (iter) < (__typeof__(iter))SPA_MEMBER((body), (_size), void);				\
++	     (iter) = (__typeof__(iter))SPA_MEMBER((iter), (body)->child.size, void))
++
++#define SPA_POD_CHOICE_FOREACH(obj, iter)							\
++	SPA_POD_CHOICE_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
++
++#define SPA_POD_FOREACH(pod, size, iter)					\
++	for ((iter) = (pod);							\
++	     spa_pod_is_inside(pod, size, iter);				\
++	     (iter) = (__typeof__(iter))spa_pod_next(iter))
++
++#define SPA_POD_STRUCT_FOREACH(obj, iter)							\
++	SPA_POD_FOREACH(SPA_POD_BODY(obj), SPA_POD_BODY_SIZE(obj), iter)
++
++#define SPA_POD_OBJECT_BODY_FOREACH(body, size, iter)						\
++	for ((iter) = spa_pod_prop_first(body);				\
++	     spa_pod_prop_is_inside(body, size, iter);			\
++	     (iter) = spa_pod_prop_next(iter))
++
++#define SPA_POD_OBJECT_FOREACH(obj, iter)							\
++	SPA_POD_OBJECT_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
++
++#define SPA_POD_SEQUENCE_BODY_FOREACH(body, size, iter)						\
++	for ((iter) = spa_pod_control_first(body);						\
++	     spa_pod_control_is_inside(body, size, iter);						\
++	     (iter) = spa_pod_control_next(iter))
++
++#define SPA_POD_SEQUENCE_FOREACH(seq, iter)							\
++	SPA_POD_SEQUENCE_BODY_FOREACH(&(seq)->body, SPA_POD_BODY_SIZE(seq), iter)
++
++
++static inline void *spa_pod_from_data(void *data, size_t maxsize, off_t offset, size_t size)
++{
++	void *pod;
++	if (size < sizeof(struct spa_pod) || offset + size > maxsize)
++		return NULL;
++	pod = SPA_MEMBER(data, offset, void);
++	if (SPA_POD_SIZE(pod) > size)
++		return NULL;
++	return pod;
++}
++
++static inline int spa_pod_is_none(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_None);
++}
++
++static inline int spa_pod_is_bool(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Bool && SPA_POD_BODY_SIZE(pod) >= sizeof(int32_t));
++}
++
++static inline int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
++{
++	if (!spa_pod_is_bool(pod))
++		return -EINVAL;
++	*value = !!SPA_POD_VALUE(struct spa_pod_bool, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_id(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Id && SPA_POD_BODY_SIZE(pod) >= sizeof(uint32_t));
++}
++
++static inline int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
++{
++	if (!spa_pod_is_id(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_id, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_int(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Int && SPA_POD_BODY_SIZE(pod) >= sizeof(int32_t));
++}
++
++static inline int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
++{
++	if (!spa_pod_is_int(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_int, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_long(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Long && SPA_POD_BODY_SIZE(pod) >= sizeof(int64_t));
++}
++
++static inline int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
++{
++	if (!spa_pod_is_long(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_long, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_float(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Float && SPA_POD_BODY_SIZE(pod) >= sizeof(float));
++}
++
++static inline int spa_pod_get_float(const struct spa_pod *pod, float *value)
++{
++	if (!spa_pod_is_float(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_float, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_double(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Double && SPA_POD_BODY_SIZE(pod) >= sizeof(double));
++}
++
++static inline int spa_pod_get_double(const struct spa_pod *pod, double *value)
++{
++	if (!spa_pod_is_double(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_double, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_string(const struct spa_pod *pod)
++{
++	const char *s = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_String &&
++			SPA_POD_BODY_SIZE(pod) > 0 &&
++			s[SPA_POD_BODY_SIZE(pod)-1] == '\0');
++}
++
++static inline int spa_pod_get_string(const struct spa_pod *pod, const char **value)
++{
++	if (!spa_pod_is_string(pod))
++		return -EINVAL;
++	*value = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
++	return 0;
++}
++
++static inline int spa_pod_copy_string(const struct spa_pod *pod, size_t maxlen, char *dest)
++{
++	const char *s = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
++	if (!spa_pod_is_string(pod) || maxlen < 1)
++		return -EINVAL;
++	strncpy(dest, s, maxlen-1);
++	dest[maxlen-1]= '\0';
++	return 0;
++}
++
++static inline int spa_pod_is_bytes(const struct spa_pod *pod)
++{
++	return SPA_POD_TYPE(pod) == SPA_TYPE_Bytes;
++}
++
++static inline int spa_pod_get_bytes(const struct spa_pod *pod, const void **value, uint32_t *len)
++{
++	if (!spa_pod_is_bytes(pod))
++		return -EINVAL;
++	*value = (const void *)SPA_POD_CONTENTS(struct spa_pod_bytes, pod);
++	*len = SPA_POD_BODY_SIZE(pod);
++	return 0;
++}
++
++static inline int spa_pod_is_pointer(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Pointer &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_pointer_body));
++}
++
++static inline int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type, const void **value)
++{
++	if (!spa_pod_is_pointer(pod))
++		return -EINVAL;
++	*type = ((struct spa_pod_pointer*)pod)->body.type;
++	*value = ((struct spa_pod_pointer*)pod)->body.value;
++	return 0;
++}
++
++static inline int spa_pod_is_fd(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Fd &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(int64_t));
++}
++
++static inline int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
++{
++	if (!spa_pod_is_fd(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_fd, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_rectangle(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Rectangle &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_rectangle));
++}
++
++static inline int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rectangle *value)
++{
++	if (!spa_pod_is_rectangle(pod))
++		return -EINVAL;
++	*value = SPA_POD_VALUE(struct spa_pod_rectangle, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_fraction(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Fraction &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_fraction));
++}
++
++static inline int spa_pod_get_fraction(const struct spa_pod *pod, struct spa_fraction *value)
++{
++	spa_return_val_if_fail(spa_pod_is_fraction(pod), -EINVAL);
++	*value = SPA_POD_VALUE(struct spa_pod_fraction, pod);
++	return 0;
++}
++
++static inline int spa_pod_is_bitmap(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Bitmap &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(uint8_t));
++}
++
++static inline int spa_pod_is_array(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Array &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_array_body));
++}
++
++static inline void *spa_pod_get_array(const struct spa_pod *pod, uint32_t *n_values)
++{
++	spa_return_val_if_fail(spa_pod_is_array(pod), NULL);
++	*n_values = SPA_POD_ARRAY_N_VALUES(pod);
++	return SPA_POD_ARRAY_VALUES(pod);
++}
++
++static inline uint32_t spa_pod_copy_array(const struct spa_pod *pod, uint32_t type,
++		void *values, uint32_t max_values)
++{
++	uint32_t n_values;
++	void *v = spa_pod_get_array(pod, &n_values);
++	if (v == NULL || max_values == 0 || SPA_POD_ARRAY_VALUE_TYPE(pod) != type)
++		return 0;
++	n_values = SPA_MIN(n_values, max_values);
++	memcpy(values, v, SPA_POD_ARRAY_VALUE_SIZE(pod) * n_values);
++	return n_values;
++}
++
++static inline int spa_pod_is_choice(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Choice &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_choice_body));
++}
++
++static inline struct spa_pod *spa_pod_get_values(const struct spa_pod *pod, uint32_t *n_vals, uint32_t *choice)
++{
++	if (pod->type == SPA_TYPE_Choice) {
++		*choice = SPA_POD_CHOICE_TYPE(pod);
++		*n_vals = *choice == SPA_CHOICE_None ? 1 : SPA_POD_CHOICE_N_VALUES(pod);
++		return (struct spa_pod*)SPA_POD_CHOICE_CHILD(pod);
++	} else {
++		*n_vals = 1;
++		*choice = SPA_CHOICE_None;
++		return (struct spa_pod*)pod;
++	}
++}
++
++static inline int spa_pod_is_struct(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Struct);
++}
++
++static inline int spa_pod_is_object(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Object &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_object_body));
++}
++
++static inline bool spa_pod_is_object_type(const struct spa_pod *pod, uint32_t type)
++{
++	return (pod && spa_pod_is_object(pod) && SPA_POD_OBJECT_TYPE(pod) == type);
++}
++
++static inline bool spa_pod_is_object_id(const struct spa_pod *pod, uint32_t id)
++{
++	return (pod && spa_pod_is_object(pod) && SPA_POD_OBJECT_ID(pod) == id);
++}
++
++static inline int spa_pod_is_sequence(const struct spa_pod *pod)
++{
++	return (SPA_POD_TYPE(pod) == SPA_TYPE_Sequence &&
++			SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_sequence_body));
++}
++
++static inline const struct spa_pod_prop *spa_pod_object_find_prop(const struct spa_pod_object *pod,
++		const struct spa_pod_prop *start, uint32_t key)
++{
++	const struct spa_pod_prop *first, *res;
++
++	first = spa_pod_prop_first(&pod->body);
++	start = start ? spa_pod_prop_next(start) : first;
++
++	for (res = start; spa_pod_prop_is_inside(&pod->body, pod->pod.size, res);
++	     res = spa_pod_prop_next(res)) {
++		if (res->key == key)
++			return res;
++	}
++	for (res = first; res != start; res = spa_pod_prop_next(res)) {
++		if (res->key == key)
++			return res;
++	}
++	return NULL;
++}
++
++static inline const struct spa_pod_prop *spa_pod_find_prop(const struct spa_pod *pod,
++		const struct spa_pod_prop *start, uint32_t key)
++{
++	if (!spa_pod_is_object(pod))
++		return NULL;
++	return spa_pod_object_find_prop((const struct spa_pod_object *)pod, start, key);
++}
++
++static inline int spa_pod_object_fixate(struct spa_pod_object *pod)
++{
++	struct spa_pod_prop *res;
++	SPA_POD_OBJECT_FOREACH(pod, res) {
++		if (res->value.type == SPA_TYPE_Choice)
++			((struct spa_pod_choice*)&res->value)->body.type = SPA_CHOICE_None;
++	}
++	return 0;
++}
++
++static inline int spa_pod_fixate(struct spa_pod *pod)
++{
++	if (!spa_pod_is_object(pod))
++		return -EINVAL;
++	return spa_pod_object_fixate((struct spa_pod_object *)pod);
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_POD_H */
+diff --git a/third_party/pipewire/spa/pod/parser.h b/third_party/pipewire/spa/pod/parser.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/parser.h
+@@ -0,0 +1,573 @@
++/* Spa
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_POD_PARSER_H
++#define SPA_POD_PARSER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <errno.h>
++#include <stdarg.h>
++
++#include <spa/pod/iter.h>
++#include <spa/pod/vararg.h>
++
++struct spa_pod_parser_state {
++	uint32_t offset;
++	uint32_t flags;
++	struct spa_pod_frame *frame;
++};
++
++struct spa_pod_parser {
++	const void *data;
++	uint32_t size;
++	uint32_t _padding;
++	struct spa_pod_parser_state state;
++};
++
++#define SPA_POD_PARSER_INIT(buffer,size)  (struct spa_pod_parser){ buffer, size, }
++
++static inline void spa_pod_parser_init(struct spa_pod_parser *parser,
++				       const void *data, uint32_t size)
++{
++	*parser = SPA_POD_PARSER_INIT(data, size);
++}
++
++static inline void spa_pod_parser_pod(struct spa_pod_parser *parser,
++				      const struct spa_pod *pod)
++{
++	spa_pod_parser_init(parser, pod, SPA_POD_SIZE(pod));
++}
++
++static inline void
++spa_pod_parser_get_state(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
++{
++	*state = parser->state;
++}
++
++static inline void
++spa_pod_parser_reset(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
++{
++	parser->state = *state;
++}
++
++static inline struct spa_pod *
++spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
++{
++	if (offset + 8 <= size) {
++		struct spa_pod *pod = SPA_MEMBER(parser->data, offset, struct spa_pod);
++		if (offset + SPA_POD_SIZE(pod) <= size)
++			return pod;
++	}
++        return NULL;
++}
++
++static inline struct spa_pod *spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
++{
++	return SPA_MEMBER(parser->data, frame->offset, struct spa_pod);
++}
++
++static inline void spa_pod_parser_push(struct spa_pod_parser *parser,
++		      struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
++{
++	frame->pod = *pod;
++	frame->offset = offset;
++	frame->parent = parser->state.frame;
++	frame->flags = parser->state.flags;
++	parser->state.frame = frame;
++}
++
++static inline struct spa_pod *spa_pod_parser_current(struct spa_pod_parser *parser)
++{
++	struct spa_pod_frame *f = parser->state.frame;
++	uint32_t size = f ? f->offset + SPA_POD_SIZE(&f->pod) : parser->size;
++	return spa_pod_parser_deref(parser, parser->state.offset, size);
++}
++
++static inline void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
++{
++	parser->state.offset += SPA_ROUND_UP_N(SPA_POD_SIZE(pod), 8);
++}
++
++static inline struct spa_pod *spa_pod_parser_next(struct spa_pod_parser *parser)
++{
++	struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod)
++		spa_pod_parser_advance(parser, pod);
++	return pod;
++}
++
++static inline int spa_pod_parser_pop(struct spa_pod_parser *parser,
++		      struct spa_pod_frame *frame)
++{
++	parser->state.frame = frame->parent;
++	parser->state.offset = frame->offset + SPA_ROUND_UP_N(SPA_POD_SIZE(&frame->pod), 8);
++	return 0;
++}
++
++static inline int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_bool(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_id(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_int(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_long(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_float(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_double(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_string(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_bytes(pod, value, len)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_pointer(pod, type, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_fd(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_rectangle(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
++{
++	int res = -EPIPE;
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod != NULL && (res = spa_pod_get_fraction(pod, value)) >= 0)
++		spa_pod_parser_advance(parser, pod);
++	return res;
++}
++
++static inline int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
++{
++	struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod == NULL)
++		return -EPIPE;
++	*value = pod;
++	spa_pod_parser_advance(parser, pod);
++	return 0;
++}
++static inline int spa_pod_parser_push_struct(struct spa_pod_parser *parser,
++		struct spa_pod_frame *frame)
++{
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod == NULL)
++		return -EPIPE;
++	if (!spa_pod_is_struct(pod))
++		return -EINVAL;
++	spa_pod_parser_push(parser, frame, pod, parser->state.offset);
++	parser->state.offset += sizeof(struct spa_pod_struct);
++	return 0;
++}
++
++static inline int spa_pod_parser_push_object(struct spa_pod_parser *parser,
++		struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
++{
++	const struct spa_pod *pod = spa_pod_parser_current(parser);
++	if (pod == NULL)
++		return -EPIPE;
++	if (!spa_pod_is_object(pod))
++		return -EINVAL;
++	if (type != SPA_POD_OBJECT_TYPE(pod))
++		return -EPROTO;
++	if (id != NULL)
++		*id = SPA_POD_OBJECT_ID(pod);
++	spa_pod_parser_push(parser, frame, pod, parser->state.offset);
++	parser->state.offset = parser->size;
++	return 0;
++}
++
++static inline bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
++{
++	if (pod == NULL)
++		return false;
++
++	if (spa_pod_is_choice(pod) &&
++	    SPA_POD_CHOICE_TYPE(pod) == SPA_CHOICE_None &&
++	    spa_pod_parser_can_collect(SPA_POD_CHOICE_CHILD(pod), type))
++		return true;
++
++	switch (type) {
++	case 'P':
++		return true;
++	case 'b':
++		return spa_pod_is_bool(pod);
++	case 'I':
++		return spa_pod_is_id(pod);
++	case 'i':
++		return spa_pod_is_int(pod);
++	case 'l':
++		return spa_pod_is_long(pod);
++	case 'f':
++		return spa_pod_is_float(pod);
++	case 'd':
++		return spa_pod_is_double(pod);
++	case 's':
++		return spa_pod_is_string(pod) || spa_pod_is_none(pod);
++	case 'S':
++		return spa_pod_is_string(pod);
++	case 'y':
++		return spa_pod_is_bytes(pod);
++	case 'R':
++		return spa_pod_is_rectangle(pod);
++	case 'F':
++		return spa_pod_is_fraction(pod);
++	case 'B':
++		return spa_pod_is_bitmap(pod);
++	case 'a':
++		return spa_pod_is_array(pod);
++	case 'p':
++		return spa_pod_is_pointer(pod);
++	case 'h':
++		return spa_pod_is_fd(pod);
++	case 'T':
++		return spa_pod_is_struct(pod) || spa_pod_is_none(pod);
++	case 'O':
++		return spa_pod_is_object(pod) || spa_pod_is_none(pod);
++	case 'V':
++		return spa_pod_is_choice(pod);
++	default:
++		return false;
++	}
++}
++
++#define SPA_POD_PARSER_COLLECT(pod,_type,args)						\
++do {											\
++	switch (_type) {								\
++	case 'b':									\
++		*va_arg(args, bool*) = SPA_POD_VALUE(struct spa_pod_bool, pod);		\
++		break;									\
++	case 'I':									\
++	case 'i':									\
++		*va_arg(args, int32_t*) = SPA_POD_VALUE(struct spa_pod_int, pod);	\
++		break;									\
++	case 'l':									\
++		*va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_long, pod);	\
++		break;									\
++	case 'f':									\
++		*va_arg(args, float*) = SPA_POD_VALUE(struct spa_pod_float, pod);	\
++		break;									\
++	case 'd':									\
++		*va_arg(args, double*) = SPA_POD_VALUE(struct spa_pod_double, pod);	\
++		break;									\
++	case 's':									\
++		*va_arg(args, char**) =							\
++			(pod == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None)		\
++				? NULL							\
++				: (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod));	\
++		break;									\
++	case 'S':									\
++	{										\
++		char *dest = va_arg(args, char*);					\
++		uint32_t maxlen = va_arg(args, uint32_t);				\
++		strncpy(dest, (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod), maxlen-1);	\
++		break;									\
++	}										\
++	case 'y':									\
++		*(va_arg(args, void **)) = SPA_POD_CONTENTS(struct spa_pod_bytes, pod);	\
++		*(va_arg(args, uint32_t *)) = SPA_POD_BODY_SIZE(pod);			\
++		break;									\
++	case 'R':									\
++		*va_arg(args, struct spa_rectangle*) =					\
++				SPA_POD_VALUE(struct spa_pod_rectangle, pod);		\
++		break;									\
++	case 'F':									\
++		*va_arg(args, struct spa_fraction*) =					\
++				SPA_POD_VALUE(struct spa_pod_fraction, pod);		\
++		break;									\
++	case 'B':									\
++		*va_arg(args, uint32_t **) =						\
++			(uint32_t *) SPA_POD_CONTENTS(struct spa_pod_bitmap, pod);	\
++		break;									\
++	case 'a':									\
++		*va_arg(args, uint32_t*) = SPA_POD_ARRAY_VALUE_SIZE(pod);		\
++		*va_arg(args, uint32_t*) = SPA_POD_ARRAY_VALUE_TYPE(pod);		\
++		*va_arg(args, uint32_t*) = SPA_POD_ARRAY_N_VALUES(pod);			\
++		*va_arg(args, void**) = SPA_POD_ARRAY_VALUES(pod);			\
++		break;									\
++	case 'p':									\
++	{										\
++		struct spa_pod_pointer_body *b =					\
++				(struct spa_pod_pointer_body *) SPA_POD_BODY(pod);	\
++		*(va_arg(args, uint32_t *)) = b->type;					\
++		*(va_arg(args, const void **)) = b->value;				\
++		break;									\
++	}										\
++	case 'h':									\
++		*va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_fd, pod);	\
++		break;									\
++	case 'P':									\
++	case 'T':									\
++	case 'O':									\
++	case 'V':									\
++	{										\
++		const struct spa_pod **d = va_arg(args, const struct spa_pod**);	\
++		if (d)									\
++			*d = (pod == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None)	\
++				? NULL : pod);						\
++		break;									\
++	}										\
++	default:									\
++		break;									\
++	}										\
++} while(false)
++
++#define SPA_POD_PARSER_SKIP(_type,args)							\
++do {											\
++	switch (_type) {								\
++	case 'S':									\
++		va_arg(args, char*);							\
++		va_arg(args, uint32_t);							\
++		break;									\
++	case 'a':									\
++		va_arg(args, void*);							\
++		va_arg(args, void*);							\
++		/* fallthrough */							\
++	case 'p':									\
++	case 'y':									\
++		va_arg(args, void*);							\
++		/* fallthrough */							\
++	case 'b':									\
++	case 'I':									\
++	case 'i':									\
++	case 'l':									\
++	case 'f':									\
++	case 'd':									\
++	case 's':									\
++	case 'R':									\
++	case 'F':									\
++	case 'B':									\
++	case 'h':									\
++	case 'V':									\
++	case 'P':									\
++	case 'T':									\
++	case 'O':									\
++		va_arg(args, void*);							\
++		break;									\
++	}										\
++} while(false)
++
++static inline int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
++{
++	struct spa_pod_frame *f = parser->state.frame;
++        uint32_t ftype = f ? f->pod.type : (uint32_t)SPA_TYPE_Struct;
++	const struct spa_pod_prop *prop = NULL;
++	int count = 0;
++
++	do {
++		bool optional;
++		const struct spa_pod *pod = NULL;
++		const char *format;
++
++		if (ftype == SPA_TYPE_Object) {
++			uint32_t key = va_arg(args, uint32_t);
++			const struct spa_pod_object *object;
++
++			if (key == 0)
++				break;
++
++			object = (const struct spa_pod_object *)spa_pod_parser_frame(parser, f);
++			prop = spa_pod_object_find_prop(object, prop, key);
++			pod = prop ? &prop->value : NULL;
++		}
++
++		if ((format = va_arg(args, char *)) == NULL)
++			break;
++
++		if (ftype == SPA_TYPE_Struct)
++			pod = spa_pod_parser_next(parser);
++
++		if ((optional = (*format == '?')))
++			format++;
++
++		if (!spa_pod_parser_can_collect(pod, *format)) {
++			if (!optional) {
++				if (pod == NULL)
++					return -ESRCH;
++				else
++					return -EPROTO;
++			}
++			SPA_POD_PARSER_SKIP(*format, args);
++		} else {
++			if (pod->type == SPA_TYPE_Choice && *format != 'V' &&
++			    SPA_POD_CHOICE_TYPE(pod) == SPA_CHOICE_None)
++				pod = SPA_POD_CHOICE_CHILD(pod);
++
++			SPA_POD_PARSER_COLLECT(pod, *format, args);
++			count++;
++		}
++	} while (true);
++
++	return count;
++}
++
++static inline int spa_pod_parser_get(struct spa_pod_parser *parser, ...)
++{
++	int res;
++	va_list args;
++
++	va_start(args, parser);
++	res = spa_pod_parser_getv(parser, args);
++	va_end(args);
++
++	return res;
++}
++
++#define SPA_POD_OPT_Bool(val)				"?" SPA_POD_Bool(val)
++#define SPA_POD_OPT_Id(val)				"?" SPA_POD_Id(val)
++#define SPA_POD_OPT_Int(val)				"?" SPA_POD_Int(val)
++#define SPA_POD_OPT_Long(val)				"?" SPA_POD_Long(val)
++#define SPA_POD_OPT_Float(val)				"?" SPA_POD_Float(val)
++#define SPA_POD_OPT_Double(val)				"?" SPA_POD_Double(val)
++#define SPA_POD_OPT_String(val)				"?" SPA_POD_String(val)
++#define SPA_POD_OPT_Stringn(val,len)			"?" SPA_POD_Stringn(val,len)
++#define SPA_POD_OPT_Bytes(val,len)			"?" SPA_POD_Bytes(val,len)
++#define SPA_POD_OPT_Rectangle(val)			"?" SPA_POD_Rectangle(val)
++#define SPA_POD_OPT_Fraction(val)			"?" SPA_POD_Fraction(val)
++#define SPA_POD_OPT_Array(csize,ctype,n_vals,vals)	"?" SPA_POD_Array(csize,ctype,n_vals,vals)
++#define SPA_POD_OPT_Pointer(type,val)			"?" SPA_POD_Pointer(type,val)
++#define SPA_POD_OPT_Fd(val)				"?" SPA_POD_Fd(val)
++#define SPA_POD_OPT_Pod(val)				"?" SPA_POD_Pod(val)
++#define SPA_POD_OPT_PodObject(val)			"?" SPA_POD_PodObject(val)
++#define SPA_POD_OPT_PodStruct(val)			"?" SPA_POD_PodStruct(val)
++#define SPA_POD_OPT_PodChoice(val)			"?" SPA_POD_PodChoice(val)
++
++#define spa_pod_parser_get_object(p,type,id,...)				\
++({										\
++	struct spa_pod_frame _f;						\
++	int _res;								\
++	if ((_res = spa_pod_parser_push_object(p, &_f, type, id)) == 0) {	\
++		_res = spa_pod_parser_get(p,##__VA_ARGS__, 0);			\
++		spa_pod_parser_pop(p, &_f);					\
++	}									\
++	_res;									\
++})
++
++#define spa_pod_parser_get_struct(p,...)				\
++({									\
++	struct spa_pod_frame _f;					\
++	int _res;							\
++	if ((_res = spa_pod_parser_push_struct(p, &_f)) == 0) {		\
++		_res = spa_pod_parser_get(p,##__VA_ARGS__, NULL);	\
++		spa_pod_parser_pop(p, &_f);				\
++	}								\
++	_res;							\
++})
++
++#define spa_pod_parse_object(pod,type,id,...)			\
++({								\
++	struct spa_pod_parser _p;				\
++	spa_pod_parser_pod(&_p, pod);				\
++	spa_pod_parser_get_object(&_p,type,id,##__VA_ARGS__);	\
++})
++
++#define spa_pod_parse_struct(pod,...)				\
++({								\
++	struct spa_pod_parser _p;				\
++	spa_pod_parser_pod(&_p, pod);				\
++	spa_pod_parser_get_struct(&_p,##__VA_ARGS__);		\
++})
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_POD_PARSER_H */
+diff --git a/third_party/pipewire/spa/pod/pod.h b/third_party/pipewire/spa/pod/pod.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/pod.h
+@@ -0,0 +1,231 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_POD_H
++#define SPA_POD_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/type.h>
++
++#define SPA_POD_BODY_SIZE(pod)			(((struct spa_pod*)(pod))->size)
++#define SPA_POD_TYPE(pod)			(((struct spa_pod*)(pod))->type)
++#define SPA_POD_SIZE(pod)			(sizeof(struct spa_pod) + SPA_POD_BODY_SIZE(pod))
++#define SPA_POD_CONTENTS_SIZE(type,pod)		(SPA_POD_SIZE(pod)-sizeof(type))
++
++#define SPA_POD_CONTENTS(type,pod)		SPA_MEMBER((pod),sizeof(type),void)
++#define SPA_POD_CONTENTS_CONST(type,pod)	SPA_MEMBER((pod),sizeof(type),const void)
++#define SPA_POD_BODY(pod)			SPA_MEMBER((pod),sizeof(struct spa_pod),void)
++#define SPA_POD_BODY_CONST(pod)			SPA_MEMBER((pod),sizeof(struct spa_pod),const void)
++
++struct spa_pod {
++	uint32_t size;		/* size of the body */
++	uint32_t type;		/* a basic id of enum spa_type */
++};
++
++#define SPA_POD_VALUE(type,pod)			(((type*)pod)->value)
++
++struct spa_pod_bool {
++	struct spa_pod pod;
++	int32_t value;
++	int32_t _padding;
++};
++
++struct spa_pod_id {
++	struct spa_pod pod;
++	uint32_t value;
++	int32_t _padding;
++};
++
++struct spa_pod_int {
++	struct spa_pod pod;
++	int32_t value;
++	int32_t _padding;
++};
++
++struct spa_pod_long {
++	struct spa_pod pod;
++	int64_t value;
++};
++
++struct spa_pod_float {
++	struct spa_pod pod;
++	float value;
++	int32_t _padding;
++};
++
++struct spa_pod_double {
++	struct spa_pod pod;
++	double value;
++};
++
++struct spa_pod_string {
++	struct spa_pod pod;
++	/* value here */
++};
++
++struct spa_pod_bytes {
++	struct spa_pod pod;
++	/* value here */
++};
++
++struct spa_pod_rectangle {
++	struct spa_pod pod;
++	struct spa_rectangle value;
++};
++
++struct spa_pod_fraction {
++	struct spa_pod pod;
++	struct spa_fraction value;
++};
++
++struct spa_pod_bitmap {
++	struct spa_pod pod;
++	/* array of uint8_t follows with the bitmap */
++};
++
++#define SPA_POD_ARRAY_CHILD(arr)	(&((struct spa_pod_array*)(arr))->body.child)
++#define SPA_POD_ARRAY_VALUE_TYPE(arr)	(SPA_POD_TYPE(SPA_POD_ARRAY_CHILD(arr)))
++#define SPA_POD_ARRAY_VALUE_SIZE(arr)	(SPA_POD_BODY_SIZE(SPA_POD_ARRAY_CHILD(arr)))
++#define SPA_POD_ARRAY_N_VALUES(arr)	((SPA_POD_BODY_SIZE(arr) - sizeof(struct spa_pod_array_body)) / SPA_POD_ARRAY_VALUE_SIZE(arr))
++#define SPA_POD_ARRAY_VALUES(arr)	SPA_POD_CONTENTS(struct spa_pod_array, arr)
++
++struct spa_pod_array_body {
++	struct spa_pod child;
++	/* array with elements of child.size follows */
++};
++
++struct spa_pod_array {
++	struct spa_pod pod;
++	struct spa_pod_array_body body;
++};
++
++#define SPA_POD_CHOICE_CHILD(choice)		(&((struct spa_pod_choice*)(choice))->body.child)
++#define SPA_POD_CHOICE_TYPE(choice)		(((struct spa_pod_choice*)(choice))->body.type)
++#define SPA_POD_CHOICE_FLAGS(choice)		(((struct spa_pod_choice*)(choice))->body.flags)
++#define SPA_POD_CHOICE_VALUE_TYPE(choice)	(SPA_POD_TYPE(SPA_POD_CHOICE_CHILD(choice)))
++#define SPA_POD_CHOICE_VALUE_SIZE(choice)	(SPA_POD_BODY_SIZE(SPA_POD_CHOICE_CHILD(choice)))
++#define SPA_POD_CHOICE_N_VALUES(choice)		((SPA_POD_BODY_SIZE(choice) - sizeof(struct spa_pod_choice_body)) / SPA_POD_CHOICE_VALUE_SIZE(choice))
++#define SPA_POD_CHOICE_VALUES(choice)		(SPA_POD_CONTENTS(struct spa_pod_choice, choice))
++
++enum spa_choice_type {
++	SPA_CHOICE_None,		/**< no choice, first value is current */
++	SPA_CHOICE_Range,		/**< range: default, min, max */
++	SPA_CHOICE_Step,		/**< range with step: default, min, max, step */
++	SPA_CHOICE_Enum,		/**< list: default, alternative,...  */
++	SPA_CHOICE_Flags,		/**< flags: default, possible flags,... */
++};
++
++struct spa_pod_choice_body {
++	uint32_t type;			/**< type of choice, one of enum spa_choice_type */
++	uint32_t flags;			/**< extra flags */
++	struct spa_pod child;
++	/* array with elements of child.size follows. Note that there might be more
++	 * elements than required by \a type, which should be ignored. */
++};
++
++struct spa_pod_choice {
++	struct spa_pod pod;
++	struct spa_pod_choice_body body;
++};
++
++struct spa_pod_struct {
++	struct spa_pod pod;
++	/* one or more spa_pod follow */
++};
++
++#define SPA_POD_OBJECT_TYPE(obj)	(((struct spa_pod_object*)(obj))->body.type)
++#define SPA_POD_OBJECT_ID(obj)		(((struct spa_pod_object*)(obj))->body.id)
++
++struct spa_pod_object_body {
++	uint32_t type;		/**< one of enum spa_type */
++	uint32_t id;		/**< id of the object, depends on the object type */
++	/* contents follow, series of spa_pod_prop */
++};
++
++struct spa_pod_object {
++	struct spa_pod pod;
++	struct spa_pod_object_body body;
++};
++
++struct spa_pod_pointer_body {
++	uint32_t type;		/**< pointer id, one of enum spa_type */
++	uint32_t _padding;
++	const void *value;
++};
++
++struct spa_pod_pointer {
++	struct spa_pod pod;
++	struct spa_pod_pointer_body body;
++};
++
++struct spa_pod_fd {
++	struct spa_pod pod;
++	int64_t value;
++};
++
++#define SPA_POD_PROP_SIZE(prop)		(sizeof(struct spa_pod_prop) + (prop)->value.size)
++
++/* props can be inside an object */
++struct spa_pod_prop {
++	uint32_t key;			/**< key of property, list of valid keys depends on the
++					  *  object type */
++#define SPA_POD_PROP_FLAG_READONLY	(1u<<0)		/**< is read-only */
++#define SPA_POD_PROP_FLAG_HARDWARE	(1u<<1)		/**< some sort of hardware parameter */
++	uint32_t flags;			/**< flags for property */
++	struct spa_pod value;
++	/* value follows */
++};
++
++#define SPA_POD_CONTROL_SIZE(ev)	(sizeof(struct spa_pod_control) + (ev)->value.size)
++
++/* controls can be inside a sequence and mark timed values */
++struct spa_pod_control {
++	uint32_t offset;	/**< media offset */
++	uint32_t type;		/**< type of control, enum spa_control_type */
++	struct spa_pod value;	/**< control value, depends on type */
++	/* value contents follow */
++};
++
++struct spa_pod_sequence_body {
++	uint32_t unit;
++	uint32_t pad;
++	/* series of struct spa_pod_control follows */
++};
++
++/** a sequence of timed controls */
++struct spa_pod_sequence {
++	struct spa_pod pod;
++	struct spa_pod_sequence_body body;
++};
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_POD_H */
+diff --git a/third_party/pipewire/spa/pod/vararg.h b/third_party/pipewire/spa/pod/vararg.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/pod/vararg.h
+@@ -0,0 +1,104 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_POD_VARARG_H
++#define SPA_POD_VARARG_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++
++#include <spa/pod/pod.h>
++
++#define SPA_POD_Prop(key,...)				\
++	key, ##__VA_ARGS__
++
++#define SPA_POD_Control(offset,type,...)		\
++	offset, type, ##__VA_ARGS__
++
++#define SPA_CHOICE_RANGE(def,min,max)			3,(def),(min),(max)
++#define SPA_CHOICE_STEP(def,min,max,step)		4,(def),(min),(max),(step)
++#define SPA_CHOICE_ENUM(n_vals,...)			(n_vals),##__VA_ARGS__
++#define SPA_CHOICE_FLAGS(flags)				1, (flags)
++#define SPA_CHOICE_BOOL(def)				3,(def),(def),!(def)
++
++#define SPA_POD_Bool(val)				"b", val
++#define SPA_POD_CHOICE_Bool(def)			"?eb", SPA_CHOICE_BOOL(def)
++
++#define SPA_POD_Id(val)					"I", val
++#define SPA_POD_CHOICE_ENUM_Id(n_vals,...)		"?eI", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++
++#define SPA_POD_Int(val)				"i", val
++#define SPA_POD_CHOICE_ENUM_Int(n_vals,...)		"?ei", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++#define SPA_POD_CHOICE_RANGE_Int(def,min,max)		"?ri", SPA_CHOICE_RANGE(def, min, max)
++#define SPA_POD_CHOICE_STEP_Int(def,min,max,step)	"?si", SPA_CHOICE_STEP(def, min, max, step)
++#define SPA_POD_CHOICE_FLAGS_Int(flags)			"?fi", SPA_CHOICE_FLAGS(flags)
++
++#define SPA_POD_Long(val)				"l", val
++#define SPA_POD_CHOICE_ENUM_Long(n_vals,...)		"?el", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++#define SPA_POD_CHOICE_RANGE_Long(def,min,max)		"?rl", SPA_CHOICE_RANGE(def, min, max)
++#define SPA_POD_CHOICE_STEP_Long(def,min,max,step)	"?sl", SPA_CHOICE_STEP(def, min, max, step)
++#define SPA_POD_CHOICE_FLAGS_Long(flags)		"?fl", SPA_CHOICE_FLAGS(flags)
++
++#define SPA_POD_Float(val)				"f", val
++#define SPA_POD_CHOICE_ENUM_Float(n_vals,...)		"?ef", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++#define SPA_POD_CHOICE_RANGE_Float(def,min,max)		"?rf", SPA_CHOICE_RANGE(def, min, max)
++#define SPA_POD_CHOICE_STEP_Float(def,min,max,step)	"?sf", SPA_CHOICE_STEP(def, min, max, step)
++
++#define SPA_POD_Double(val)				"d", val
++#define SPA_POD_CHOICE_ENUM_Double(n_vals,...)		"?ed", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++#define SPA_POD_CHOICE_RANGE_Double(def,min,max)	"?rd", SPA_CHOICE_RANGE(def, min, max)
++#define SPA_POD_CHOICE_STEP_Double(def,min,max,step)	"?sd", SPA_CHOICE_STEP(def, min, max, step)
++
++#define SPA_POD_String(val)				"s",val
++#define SPA_POD_Stringn(val,len)			"S",val,len
++
++#define SPA_POD_Bytes(val,len)				"y",val,len
++
++#define SPA_POD_Rectangle(val)				"R",val
++#define SPA_POD_CHOICE_ENUM_Rectangle(n_vals,...)	"?eR", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++#define SPA_POD_CHOICE_RANGE_Rectangle(def,min,max)	"?rR", SPA_CHOICE_RANGE((def),(min),(max))
++#define SPA_POD_CHOICE_STEP_Rectangle(def,min,max,step)	"?sR", SPA_CHOICE_STEP((def),(min),(max),(step))
++
++#define SPA_POD_Fraction(val)				"F",val
++#define SPA_POD_CHOICE_ENUM_Fraction(n_vals,...)	"?eF", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
++#define SPA_POD_CHOICE_RANGE_Fraction(def,min,max)	"?rF", SPA_CHOICE_RANGE((def),(min),(max))
++#define SPA_POD_CHOICE_STEP_Fraction(def,min,max,step)	"?sF", SPA_CHOICE_STEP(def, min, max, step)
++
++#define SPA_POD_Array(csize,ctype,n_vals,vals)		"a", csize,ctype,n_vals,vals
++#define SPA_POD_Pointer(type,val)			"p", type,val
++#define SPA_POD_Fd(val)					"h", val
++#define SPA_POD_None()					"P", NULL
++#define SPA_POD_Pod(val)				"P", val
++#define SPA_POD_PodObject(val)				"O", val
++#define SPA_POD_PodStruct(val)				"T", val
++#define SPA_POD_PodChoice(val)				"V", val
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_POD_VARARG_H */
+diff --git a/third_party/pipewire/spa/support/cpu.h b/third_party/pipewire/spa/support/cpu.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/cpu.h
+@@ -0,0 +1,126 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_CPU_H
++#define SPA_CPU_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++/**
++ * The CPU features interface
++ */
++#define SPA_TYPE_INTERFACE_CPU	SPA_TYPE_INFO_INTERFACE_BASE "CPU"
++
++#define SPA_VERSION_CPU		0
++struct spa_cpu { struct spa_interface iface; };
++
++/* x86 specific */
++#define SPA_CPU_FLAG_MMX		(1<<0)	/**< standard MMX */
++#define SPA_CPU_FLAG_MMXEXT		(1<<1)	/**< SSE integer or AMD MMX ext */
++#define SPA_CPU_FLAG_3DNOW		(1<<2)	/**< AMD 3DNOW */
++#define SPA_CPU_FLAG_SSE		(1<<3)	/**< SSE */
++#define SPA_CPU_FLAG_SSE2		(1<<4)	/**< SSE2 */
++#define SPA_CPU_FLAG_3DNOWEXT		(1<<5)	/**< AMD 3DNowExt */
++#define SPA_CPU_FLAG_SSE3		(1<<6)	/**< Prescott SSE3 */
++#define SPA_CPU_FLAG_SSSE3		(1<<7)	/**< Conroe SSSE3 */
++#define SPA_CPU_FLAG_SSE41		(1<<8)	/**< Penryn SSE4.1 */
++#define SPA_CPU_FLAG_SSE42		(1<<9)	/**< Nehalem SSE4.2 */
++#define SPA_CPU_FLAG_AESNI		(1<<10)	/**< Advanced Encryption Standard */
++#define SPA_CPU_FLAG_AVX		(1<<11)	/**< AVX */
++#define SPA_CPU_FLAG_XOP		(1<<12)	/**< Bulldozer XOP */
++#define SPA_CPU_FLAG_FMA4		(1<<13)	/**< Bulldozer FMA4 */
++#define SPA_CPU_FLAG_CMOV		(1<<14)	/**< supports cmov */
++#define SPA_CPU_FLAG_AVX2		(1<<15)	/**< AVX2 */
++#define SPA_CPU_FLAG_FMA3		(1<<16)	/**< Haswell FMA3 */
++#define SPA_CPU_FLAG_BMI1		(1<<17)	/**< Bit Manipulation Instruction Set 1 */
++#define SPA_CPU_FLAG_BMI2		(1<<18)	/**< Bit Manipulation Instruction Set 2 */
++#define SPA_CPU_FLAG_AVX512		(1<<19)	/**< AVX-512 */
++#define SPA_CPU_FLAG_SLOW_UNALIGNED	(1<<20)	/**< unaligned loads/stores are slow */
++
++/* PPC specific */
++#define SPA_CPU_FLAG_ALTIVEC		(1<<0)	/**< standard */
++#define SPA_CPU_FLAG_VSX		(1<<1)	/**< ISA 2.06 */
++#define SPA_CPU_FLAG_POWER8		(1<<2)	/**< ISA 2.07 */
++
++/* ARM specific */
++#define SPA_CPU_FLAG_ARMV5TE		(1 << 0)
++#define SPA_CPU_FLAG_ARMV6		(1 << 1)
++#define SPA_CPU_FLAG_ARMV6T2		(1 << 2)
++#define SPA_CPU_FLAG_VFP		(1 << 3)
++#define SPA_CPU_FLAG_VFPV3		(1 << 4)
++#define SPA_CPU_FLAG_NEON		(1 << 5)
++#define SPA_CPU_FLAG_ARMV8		(1 << 6)
++
++#define SPA_CPU_FORCE_AUTODETECT	((uint32_t)-1)
++/**
++ * methods
++ */
++struct spa_cpu_methods {
++	/** the version of the methods. This can be used to expand this
++	  structure in the future */
++#define SPA_VERSION_CPU_METHODS	0
++	uint32_t version;
++
++	/** get CPU flags */
++	uint32_t (*get_flags) (void *object);
++
++	/** force CPU flags, use SPA_CPU_FORCE_AUTODETECT to autodetect CPU flags */
++	int (*force_flags) (void *object, uint32_t flags);
++
++	/** get number of CPU cores */
++	uint32_t (*get_count) (void *object);
++
++	/** get maximum required alignment of data */
++	uint32_t (*get_max_align) (void *object);
++};
++
++#define spa_cpu_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_cpu *_c = o;						\
++	spa_interface_call_res(&_c->iface,				\
++			struct spa_cpu_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++#define spa_cpu_get_flags(c)		spa_cpu_method(c, get_flags, 0)
++#define spa_cpu_force_flags(c,f)	spa_cpu_method(c, force_flags, 0, f)
++#define spa_cpu_get_count(c)		spa_cpu_method(c, get_count, 0)
++#define spa_cpu_get_max_align(c)	spa_cpu_method(c, get_max_align, 0)
++
++/** keys can be given when initializing the cpu handle */
++#define SPA_KEY_CPU_FORCE		"cpu.force"		/**< force cpu flags */
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_CPU_H */
+diff --git a/third_party/pipewire/spa/support/dbus.h b/third_party/pipewire/spa/support/dbus.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/dbus.h
+@@ -0,0 +1,100 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DBUS_H
++#define SPA_DBUS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/support/loop.h>
++
++#define SPA_TYPE_INTERFACE_DBus		SPA_TYPE_INFO_INTERFACE_BASE "DBus"
++
++#define SPA_VERSION_DBUS		0
++struct spa_dbus { struct spa_interface iface; };
++
++enum spa_dbus_type {
++	SPA_DBUS_TYPE_SESSION,	/**< The login session bus */
++	SPA_DBUS_TYPE_SYSTEM,	/**< The systemwide bus */
++	SPA_DBUS_TYPE_STARTER	/**< The bus that started us, if any */
++};
++
++struct spa_dbus_connection {
++#define SPA_VERSION_DBUS_CONNECTION	0
++        uint32_t version;
++	/**
++	 * Get the DBusConnection from a wrapper
++	 *
++	 * \param conn the spa_dbus_connection wrapper
++	 * \return a pointer of type DBusConnection
++	 */
++	void *(*get) (struct spa_dbus_connection *conn);
++	/**
++	 * Destroy a dbus connection wrapper
++	 *
++	 * \param conn the wrapper to destroy
++	 */
++	void (*destroy) (struct spa_dbus_connection *conn);
++};
++
++#define spa_dbus_connection_get(c)	(c)->get((c))
++#define spa_dbus_connection_destroy(c)	(c)->destroy((c))
++
++struct spa_dbus_methods {
++#define SPA_VERSION_DBUS_METHODS	0
++        uint32_t version;
++
++	/**
++	 * Get a new connection wrapper for the given bus type.
++	 *
++	 * The connection wrapper is completely configured to operate
++	 * in the main context of the handle that manages the spa_dbus
++	 * interface.
++	 *
++	 * \param dbus the dbus manager
++	 * \param type the bus type to wrap
++	 * \param error location for the DBusError
++	 * \return a new dbus connection wrapper or NULL on error
++	 */
++	struct spa_dbus_connection * (*get_connection) (void *object,
++							enum spa_dbus_type type);
++};
++
++static inline struct spa_dbus_connection *
++spa_dbus_get_connection(struct spa_dbus *dbus, enum spa_dbus_type type)
++{
++	struct spa_dbus_connection *res = NULL;
++	spa_interface_call_res(&dbus->iface,
++                        struct spa_dbus_methods, res,
++			get_connection, 0, type);
++	return res;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DBUS_H */
+diff --git a/third_party/pipewire/spa/support/log-impl.h b/third_party/pipewire/spa/support/log-impl.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/log-impl.h
+@@ -0,0 +1,86 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_LOG_IMPL_H
++#define SPA_LOG_IMPL_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdio.h>
++
++#include <spa/utils/type.h>
++#include <spa/support/log.h>
++
++static inline SPA_PRINTF_FUNC(6, 0) void spa_log_impl_logv(void *object,
++				     enum spa_log_level level,
++				     const char *file,
++				     int line,
++				     const char *func,
++				     const char *fmt,
++				     va_list args)
++{
++        char text[512], location[1024];
++        static const char *levels[] = { "-", "E", "W", "I", "D", "T" };
++
++        vsnprintf(text, sizeof(text), fmt, args);
++        snprintf(location, sizeof(location), "[%s][%s:%i %s()] %s\n",
++                levels[level], strrchr(file, '/') + 1, line, func, text);
++        fputs(location, stderr);
++}
++static inline SPA_PRINTF_FUNC(6,7) void spa_log_impl_log(void *object,
++				    enum spa_log_level level,
++				    const char *file,
++				    int line,
++				    const char *func,
++				    const char *fmt, ...)
++{
++	va_list args;
++	va_start(args, fmt);
++	spa_log_impl_logv(object, level, file, line, func, fmt, args);
++	va_end(args);
++}
++
++#define SPA_LOG_IMPL_DEFINE(name)		\
++struct {					\
++	struct spa_log log;			\
++	struct spa_log_methods methods;		\
++} name
++
++#define SPA_LOG_IMPL_INIT(name)				\
++	{ { { SPA_TYPE_INTERFACE_Log, SPA_VERSION_LOG,	\
++	      SPA_CALLBACKS_INIT(&name.methods, &name) },	\
++	    SPA_LOG_LEVEL_INFO,	},			\
++	  { SPA_VERSION_LOG_METHODS,			\
++	    spa_log_impl_log,				\
++	    spa_log_impl_logv,} }
++
++#define SPA_LOG_IMPL(name)			\
++        SPA_LOG_IMPL_DEFINE(name) = SPA_LOG_IMPL_INIT(name)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++#endif /* SPA_LOG_IMPL_H */
+diff --git a/third_party/pipewire/spa/support/log.h b/third_party/pipewire/spa/support/log.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/log.h
+@@ -0,0 +1,179 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_LOG_H
++#define SPA_LOG_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stdarg.h>
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++enum spa_log_level {
++	SPA_LOG_LEVEL_NONE = 0,
++	SPA_LOG_LEVEL_ERROR,
++	SPA_LOG_LEVEL_WARN,
++	SPA_LOG_LEVEL_INFO,
++	SPA_LOG_LEVEL_DEBUG,
++	SPA_LOG_LEVEL_TRACE,
++};
++
++/**
++ * The Log interface
++ */
++#define SPA_TYPE_INTERFACE_Log	SPA_TYPE_INFO_INTERFACE_BASE "Log"
++
++#define SPA_VERSION_LOG		0
++
++struct spa_log {
++	/** the version of this log. This can be used to expand this
++	 * structure in the future */
++	struct spa_interface iface;
++	/**
++	 * Logging level, everything above this level is not logged
++	 */
++	enum spa_log_level level;
++};
++
++struct spa_log_methods {
++#define SPA_VERSION_LOG_METHODS	0
++	uint32_t version;
++	/**
++	 * Log a message with the given log level.
++	 *
++	 * \param log a spa_log
++	 * \param level a spa_log_level
++	 * \param file the file name
++	 * \param line the line number
++	 * \param func the function name
++	 * \param fmt printf style format
++	 * \param ... format arguments
++	 */
++	void (*log) (void *object,
++		     enum spa_log_level level,
++		     const char *file,
++		     int line,
++		     const char *func,
++		     const char *fmt, ...) SPA_PRINTF_FUNC(6, 7);
++
++	/**
++	 * Log a message with the given log level.
++	 *
++	 * \param log a spa_log
++	 * \param level a spa_log_level
++	 * \param file the file name
++	 * \param line the line number
++	 * \param func the function name
++	 * \param fmt printf style format
++	 * \param args format arguments
++	 */
++	void (*logv) (void *object,
++		      enum spa_log_level level,
++		      const char *file,
++		      int line,
++		      const char *func,
++		      const char *fmt,
++		      va_list args) SPA_PRINTF_FUNC(6, 0);
++};
++
++#define spa_log_level_enabled(l,lev) ((l) && (l)->level >= (lev))
++
++#if defined(__USE_ISOC11) || defined(__USE_ISOC99) || \
++    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
++
++#define spa_log_log(l,lev,...)					\
++({								\
++	struct spa_log *_l = l;					\
++	if (SPA_UNLIKELY(spa_log_level_enabled(_l, lev)))	\
++		spa_interface_call(&_l->iface,			\
++			struct spa_log_methods, log, 0, lev,	\
++			__VA_ARGS__);				\
++})
++
++#define spa_log_logv(l,lev,...)					\
++({								\
++	struct spa_log *_l = l;					\
++	if (SPA_UNLIKELY(spa_log_level_enabled(_l, lev)))	\
++		spa_interface_call(&_l->iface,			\
++			struct spa_log_methods, logv, 0, lev,	\
++			__VA_ARGS__);				\
++})
++
++#define spa_log_error(l,...)	spa_log_log(l,SPA_LOG_LEVEL_ERROR,__FILE__,__LINE__,__func__,__VA_ARGS__)
++#define spa_log_warn(l,...)	spa_log_log(l,SPA_LOG_LEVEL_WARN,__FILE__,__LINE__,__func__,__VA_ARGS__)
++#define spa_log_info(l,...)	spa_log_log(l,SPA_LOG_LEVEL_INFO,__FILE__,__LINE__,__func__,__VA_ARGS__)
++#define spa_log_debug(l,...)	spa_log_log(l,SPA_LOG_LEVEL_DEBUG,__FILE__,__LINE__,__func__,__VA_ARGS__)
++#define spa_log_trace(l,...)	spa_log_log(l,SPA_LOG_LEVEL_TRACE,__FILE__,__LINE__,__func__,__VA_ARGS__)
++
++#ifndef FASTPATH
++#define spa_log_trace_fp(l,...)	spa_log_log(l,SPA_LOG_LEVEL_TRACE,__FILE__,__LINE__,__func__,__VA_ARGS__)
++#else
++#define spa_log_trace_fp(l,...)
++#endif
++
++#else
++
++#define SPA_LOG_FUNC(name,lev)							\
++static inline SPA_PRINTF_FUNC(2,3) void spa_log_##name (struct spa_log *l, const char *format, ...)  \
++{										\
++	if (SPA_UNLIKELY(spa_log_level_enabled(l, lev))) {			\
++		va_list varargs;						\
++		va_start (varargs, format);					\
++		spa_interface_call(&l->iface,					\
++			struct spa_log_methods, logv, 0, lev,			\
++			__FILE__,__LINE__,__func__,format,varargs);		\
++		va_end (varargs);						\
++	}									\
++}
++
++SPA_LOG_FUNC(error, SPA_LOG_LEVEL_ERROR)
++SPA_LOG_FUNC(warn, SPA_LOG_LEVEL_WARN)
++SPA_LOG_FUNC(info, SPA_LOG_LEVEL_INFO)
++SPA_LOG_FUNC(debug, SPA_LOG_LEVEL_DEBUG)
++SPA_LOG_FUNC(trace, SPA_LOG_LEVEL_TRACE)
++
++#ifndef FASTPATH
++SPA_LOG_FUNC(trace_fp, SPA_LOG_LEVEL_TRACE)
++#else
++static inline void spa_log_trace_fp (struct spa_log *l, const char *format, ...) { }
++#endif
++
++#endif
++
++/** keys can be given when initializing the logger handle */
++#define SPA_KEY_LOG_LEVEL		"log.level"		/**< the default log level */
++#define SPA_KEY_LOG_COLORS		"log.colors"		/**< enable colors in the logger */
++#define SPA_KEY_LOG_FILE		"log.file"		/**< log to the specified file instead of
++								  *  stderr. */
++#define SPA_KEY_LOG_TIMESTAMP		"log.timestamp"		/**< log timestamps */
++#define SPA_KEY_LOG_LINE		"log.line"		/**< log file and line numbers */
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++#endif /* SPA_LOG_H */
+diff --git a/third_party/pipewire/spa/support/loop.h b/third_party/pipewire/spa/support/loop.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/loop.h
+@@ -0,0 +1,312 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_LOOP_H
++#define SPA_LOOP_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++#include <spa/support/system.h>
++
++#define SPA_TYPE_INTERFACE_Loop		SPA_TYPE_INFO_INTERFACE_BASE "Loop"
++#define SPA_TYPE_INTERFACE_DataLoop	SPA_TYPE_INFO_INTERFACE_BASE "DataLoop"
++#define SPA_VERSION_LOOP		0
++struct spa_loop { struct spa_interface iface; };
++
++#define SPA_TYPE_INTERFACE_LoopControl	SPA_TYPE_INFO_INTERFACE_BASE "LoopControl"
++#define SPA_VERSION_LOOP_CONTROL	0
++struct spa_loop_control { struct spa_interface iface; };
++
++#define SPA_TYPE_INTERFACE_LoopUtils	SPA_TYPE_INFO_INTERFACE_BASE "LoopUtils"
++#define SPA_VERSION_LOOP_UTILS		0
++struct spa_loop_utils { struct spa_interface iface; };
++
++struct spa_source;
++
++typedef void (*spa_source_func_t) (struct spa_source *source);
++
++struct spa_source {
++	struct spa_loop *loop;
++	spa_source_func_t func;
++	void *data;
++	int fd;
++	uint32_t mask;
++	uint32_t rmask;
++};
++
++typedef int (*spa_invoke_func_t) (struct spa_loop *loop,
++				  bool async,
++				  uint32_t seq,
++				  const void *data,
++				  size_t size,
++				  void *user_data);
++
++/**
++ * Register sources and work items to an event loop
++ */
++struct spa_loop_methods {
++	/* the version of this structure. This can be used to expand this
++	 * structure in the future */
++#define SPA_VERSION_LOOP_METHODS	0
++	uint32_t version;
++
++	/** add a source to the loop */
++	int (*add_source) (void *object,
++			   struct spa_source *source);
++
++	/** update the source io mask */
++	int (*update_source) (void *object,
++			struct spa_source *source);
++
++	/** remove a source from the loop */
++	int (*remove_source) (void *object,
++			struct spa_source *source);
++
++	/** invoke a function in the context of this loop */
++	int (*invoke) (void *object,
++		       spa_invoke_func_t func,
++		       uint32_t seq,
++		       const void *data,
++		       size_t size,
++		       bool block,
++		       void *user_data);
++};
++
++#define spa_loop_method(o,method,version,...)				\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_loop *_o = o;					\
++	spa_interface_call_res(&_o->iface,				\
++			struct spa_loop_methods, _res,			\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define spa_loop_add_source(l,...)	spa_loop_method(l,add_source,0,##__VA_ARGS__)
++#define spa_loop_update_source(l,...)	spa_loop_method(l,update_source,0,##__VA_ARGS__)
++#define spa_loop_remove_source(l,...)	spa_loop_method(l,remove_source,0,##__VA_ARGS__)
++#define spa_loop_invoke(l,...)		spa_loop_method(l,invoke,0,##__VA_ARGS__)
++
++
++/** Control hooks. These hooks can't be removed from their
++ *  callbacks and must be removed from a safe place (when the loop
++ *  is not running or when it is locked). */
++struct spa_loop_control_hooks {
++#define SPA_VERSION_LOOP_CONTROL_HOOKS	0
++	uint32_t version;
++	/** Executed right before waiting for events. It is typically used to
++	 * release locks. */
++	void (*before) (void *data);
++	/** Executed right after waiting for events. It is typically used to
++	 * reacquire locks. */
++	void (*after) (void *data);
++};
++
++#define spa_loop_control_hook_before(l)							\
++({											\
++	struct spa_hook_list *_l = l;							\
++	struct spa_hook *_h;								\
++	spa_list_for_each_reverse(_h, &_l->list, link)					\
++		spa_callbacks_call(&_h->cb, struct spa_loop_control_hooks, before, 0);	\
++})
++
++#define spa_loop_control_hook_after(l)							\
++({											\
++	struct spa_hook_list *_l = l;							\
++	struct spa_hook *_h;								\
++	spa_list_for_each(_h, &_l->list, link)						\
++		spa_callbacks_call(&_h->cb, struct spa_loop_control_hooks, after, 0);	\
++})
++
++/**
++ * Control an event loop
++ */
++struct spa_loop_control_methods {
++	/* the version of this structure. This can be used to expand this
++	 * structure in the future */
++#define SPA_VERSION_LOOP_CONTROL_METHODS	0
++	uint32_t version;
++
++	int (*get_fd) (void *object);
++
++	/** Add a hook
++	 * \param ctrl the control to change
++	 * \param hooks the hooks to add
++	 *
++	 * Adds hooks to the loop controlled by \a ctrl.
++	 */
++	void (*add_hook) (void *object,
++			  struct spa_hook *hook,
++			  const struct spa_loop_control_hooks *hooks,
++			  void *data);
++
++	/** Enter a loop
++	 * \param ctrl the control
++	 *
++	 * Start an iteration of the loop. This function should be called
++	 * before calling iterate and is typically used to capture the thread
++	 * that this loop will run in.
++	 */
++	void (*enter) (void *object);
++	/** Leave a loop
++	 * \param ctrl the control
++	 *
++	 * Ends the iteration of a loop. This should be called after calling
++	 * iterate.
++	 */
++	void (*leave) (void *object);
++
++	/** Perform one iteration of the loop.
++	 * \param ctrl the control
++	 * \param timeout an optional timeout in milliseconds.
++	 *	0 for no timeout, -1 for infinite timeout.
++	 *
++	 * This function will block
++	 * up to \a timeout milliseconds and then dispatch the fds with activity.
++	 * The number of dispatched fds is returned.
++	 */
++	int (*iterate) (void *object, int timeout);
++};
++
++#define spa_loop_control_method_v(o,method,version,...)			\
++({									\
++	struct spa_loop_control *_o = o;				\
++	spa_interface_call(&_o->iface,					\
++			struct spa_loop_control_methods,		\
++			method, version, ##__VA_ARGS__);		\
++})
++
++#define spa_loop_control_method_r(o,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_loop_control *_o = o;				\
++	spa_interface_call_res(&_o->iface,				\
++			struct spa_loop_control_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++#define spa_loop_control_get_fd(l)		spa_loop_control_method_r(l,get_fd,0)
++#define spa_loop_control_add_hook(l,...)	spa_loop_control_method_v(l,add_hook,0,__VA_ARGS__)
++#define spa_loop_control_enter(l)		spa_loop_control_method_v(l,enter,0)
++#define spa_loop_control_leave(l)		spa_loop_control_method_v(l,leave,0)
++#define spa_loop_control_iterate(l,...)		spa_loop_control_method_r(l,iterate,0,__VA_ARGS__)
++
++typedef void (*spa_source_io_func_t) (void *data, int fd, uint32_t mask);
++typedef void (*spa_source_idle_func_t) (void *data);
++typedef void (*spa_source_event_func_t) (void *data, uint64_t count);
++typedef void (*spa_source_timer_func_t) (void *data, uint64_t expirations);
++typedef void (*spa_source_signal_func_t) (void *data, int signal_number);
++
++/**
++ * Create sources for an event loop
++ */
++struct spa_loop_utils_methods {
++	/* the version of this structure. This can be used to expand this
++	 * structure in the future */
++#define SPA_VERSION_LOOP_UTILS_METHODS	0
++	uint32_t version;
++
++	struct spa_source *(*add_io) (void *object,
++				      int fd,
++				      uint32_t mask,
++				      bool close,
++				      spa_source_io_func_t func, void *data);
++
++	int (*update_io) (void *object, struct spa_source *source, uint32_t mask);
++
++	struct spa_source *(*add_idle) (void *object,
++					bool enabled,
++					spa_source_idle_func_t func, void *data);
++	int (*enable_idle) (void *object, struct spa_source *source, bool enabled);
++
++	struct spa_source *(*add_event) (void *object,
++					 spa_source_event_func_t func, void *data);
++	int (*signal_event) (void *object, struct spa_source *source);
++
++	struct spa_source *(*add_timer) (void *object,
++					 spa_source_timer_func_t func, void *data);
++	int (*update_timer) (void *object,
++			     struct spa_source *source,
++			     struct timespec *value,
++			     struct timespec *interval,
++			     bool absolute);
++	struct spa_source *(*add_signal) (void *object,
++					  int signal_number,
++					  spa_source_signal_func_t func, void *data);
++
++	/** destroy a source allocated with this interface. This function
++	 * should only be called when the loop is not running or from the
++	 * context of the running loop */
++	void (*destroy_source) (void *object, struct spa_source *source);
++};
++
++#define spa_loop_utils_method_v(o,method,version,...)			\
++({									\
++	struct spa_loop_utils *_o = o;					\
++	spa_interface_call(&_o->iface,					\
++			struct spa_loop_utils_methods,			\
++			method, version, ##__VA_ARGS__);		\
++})
++
++#define spa_loop_utils_method_r(o,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_loop_utils *_o = o;					\
++	spa_interface_call_res(&_o->iface,				\
++			struct spa_loop_utils_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++#define spa_loop_utils_method_s(o,method,version,...)			\
++({									\
++	struct spa_source *_res = NULL;					\
++	struct spa_loop_utils *_o = o;					\
++	spa_interface_call_res(&_o->iface,				\
++			struct spa_loop_utils_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++
++#define spa_loop_utils_add_io(l,...)		spa_loop_utils_method_s(l,add_io,0,__VA_ARGS__)
++#define spa_loop_utils_update_io(l,...)		spa_loop_utils_method_r(l,update_io,0,__VA_ARGS__)
++#define spa_loop_utils_add_idle(l,...)		spa_loop_utils_method_s(l,add_idle,0,__VA_ARGS__)
++#define spa_loop_utils_enable_idle(l,...)	spa_loop_utils_method_r(l,enable_idle,0,__VA_ARGS__)
++#define spa_loop_utils_add_event(l,...)		spa_loop_utils_method_s(l,add_event,0,__VA_ARGS__)
++#define spa_loop_utils_signal_event(l,...)	spa_loop_utils_method_r(l,signal_event,0,__VA_ARGS__)
++#define spa_loop_utils_add_timer(l,...)		spa_loop_utils_method_s(l,add_timer,0,__VA_ARGS__)
++#define spa_loop_utils_update_timer(l,...)	spa_loop_utils_method_r(l,update_timer,0,__VA_ARGS__)
++#define spa_loop_utils_add_signal(l,...)	spa_loop_utils_method_s(l,add_signal,0,__VA_ARGS__)
++#define spa_loop_utils_destroy_source(l,...)	spa_loop_utils_method_v(l,destroy_source,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_LOOP_H */
+diff --git a/third_party/pipewire/spa/support/plugin.h b/third_party/pipewire/spa/support/plugin.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/plugin.h
+@@ -0,0 +1,215 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_PLUGIN_H
++#define SPA_PLUGIN_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/dict.h>
++
++struct spa_handle {
++	/** Version of this struct */
++#define SPA_VERSION_HANDLE	0
++	uint32_t version;
++
++	/**
++	 * Get the interface provided by \a handle with \a type.
++	 *
++	 * \a interface is always a struct spa_interface but depending on
++	 * \a type, the struct might contain other information.
++	 *
++	 * \param handle a spa_handle
++	 * \param type the interface type
++	 * \param interface result to hold the interface.
++	 * \return 0 on success
++	 *         -ENOTSUP when there are no interfaces
++	 *         -EINVAL when handle or info is NULL
++	 */
++	int (*get_interface) (struct spa_handle *handle, const char *type, void **interface);
++	/**
++	 * Clean up the memory of \a handle. After this, \a handle should not be used
++	 * anymore.
++	 *
++	 * \param handle a pointer to memory
++	 * \return 0 on success
++	 */
++	int (*clear) (struct spa_handle *handle);
++};
++
++#define spa_handle_get_interface(h,...)	(h)->get_interface((h),__VA_ARGS__)
++#define spa_handle_clear(h)		(h)->clear((h))
++
++/**
++ * This structure lists the information about available interfaces on
++ * handles.
++ */
++struct spa_interface_info {
++	const char *type;	/*< the type of the interface, can be
++				 *  used to get the interface */
++};
++
++/**
++ * Extra supporting infrastructure passed to the init() function of
++ * a factory. It can be extra information or interfaces such as logging.
++ */
++struct spa_support {
++	const char *type;	/*< the type of the support item */
++	void *data;		/*< specific data for the item */
++};
++
++/** Find a support item of the given type */
++static inline void *spa_support_find(const struct spa_support *support,
++				     uint32_t n_support,
++				     const char *type)
++{
++	uint32_t i;
++	for (i = 0; i < n_support; i++) {
++		if (strcmp(support[i].type, type) == 0)
++			return support[i].data;
++	}
++	return NULL;
++}
++
++#define SPA_SUPPORT_INIT(type,data) (struct spa_support) { (type), (data) }
++
++struct spa_handle_factory {
++	/** The version of this structure */
++#define SPA_VERSION_HANDLE_FACTORY	1
++	uint32_t version;
++	/**
++	 * The name of the factory contains a logical name that describes
++	 * the function of the handle. Other plugins might contain an alternative
++	 * implementation with the same name.
++	 *
++	 * See utils/names.h for the list of standard names.
++	 *
++	 * Examples include:
++	 *
++	 *  api.alsa.pcm.sink: an object to write PCM samples to an alsa PLAYBACK
++	 *			device
++	 *  api.v4l2.source: an object to read from a v4l2 source.
++	 */
++	const char *name;
++	/**
++	 * Extra information about the handles of this factory.
++	 */
++	const struct spa_dict *info;
++	/**
++	 * Get the size of handles from this factory.
++	 *
++	 * \param factory a spa_handle_factory
++	 * \param params extra parameters that determine the size of the
++	 * handle.
++	 */
++	size_t (*get_size) (const struct spa_handle_factory *factory,
++			    const struct spa_dict *params);
++
++	/**
++	 * Initialize an instance of this factory. The caller should allocate
++	 * memory at least size bytes and pass this as \a handle.
++	 *
++	 * \a support can optionally contain extra interfaces or data items that the
++	 * plugin can use such as a logger.
++	 *
++	 * \param factory a spa_handle_factory
++	 * \param handle a pointer to memory
++	 * \param info extra handle specific information, usually obtained
++	 *        from a spa_device. This can be used to configure the handle.
++	 * \param support support items
++	 * \param n_support number of elements in \a support
++	 * \return 0 on success
++	 *	   < 0 errno type error
++	 */
++	int (*init) (const struct spa_handle_factory *factory,
++		     struct spa_handle *handle,
++		     const struct spa_dict *info,
++		     const struct spa_support *support,
++		     uint32_t n_support);
++
++	/**
++	 * spa_handle_factory::enum_interface_info:
++	 * \param factory: a #spa_handle_factory
++	 * \param info: result to hold spa_interface_info.
++	 * \param index: index to keep track of the enumeration, 0 for first item
++	 *
++	 * Enumerate the interface information for \a factory.
++	 *
++	 * \return 1 when an item is available
++	 *	   0 when no more items are available
++	 *	   < 0 errno type error
++	 */
++	int (*enum_interface_info) (const struct spa_handle_factory *factory,
++				    const struct spa_interface_info **info,
++				    uint32_t *index);
++};
++
++#define spa_handle_factory_get_size(h,...)		(h)->get_size((h),__VA_ARGS__)
++#define spa_handle_factory_init(h,...)			(h)->init((h),__VA_ARGS__)
++#define spa_handle_factory_enum_interface_info(h,...)	(h)->enum_interface_info((h),__VA_ARGS__)
++
++/**
++ * The function signature of the entry point in a plugin.
++ *
++ * \param factory a location to hold the factory result
++ * \param index index to keep track of the enumeration
++ * \return 1 on success
++ *         0 when there are no more factories
++ *         -EINVAL when factory is NULL
++ */
++typedef int (*spa_handle_factory_enum_func_t) (const struct spa_handle_factory **factory,
++					       uint32_t *index);
++
++#define SPA_HANDLE_FACTORY_ENUM_FUNC_NAME "spa_handle_factory_enum"
++
++/**
++ * The entry point in a plugin.
++ *
++ * \param factory a location to hold the factory result
++ * \param index index to keep track of the enumeration
++ * \return 1 on success
++ *	   0 when no more items are available
++ *	   < 0 errno type error
++ */
++int spa_handle_factory_enum(const struct spa_handle_factory **factory, uint32_t *index);
++
++
++
++#define SPA_KEY_FACTORY_NAME		"factory.name"		/**< the name of a factory */
++#define SPA_KEY_FACTORY_AUTHOR		"factory.author"	/**< a comma separated list of factory authors */
++#define SPA_KEY_FACTORY_DESCRIPTION	"factory.description"	/**< description of a factory */
++#define SPA_KEY_FACTORY_USAGE		"factory.usage"		/**< usage of a factory */
++
++#define SPA_KEY_LIBRARY_NAME		"library.name"		/**< the name of a library. This is usually
++								  *  the filename of the plugin without the
++								  *  path or the plugin extension. */
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_PLUGIN_H */
+diff --git a/third_party/pipewire/spa/support/system.h b/third_party/pipewire/spa/support/system.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/support/system.h
+@@ -0,0 +1,152 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_SYSTEM_H
++#define SPA_SYSTEM_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++struct itimerspec;
++
++#include <time.h>
++#include <sys/types.h>
++
++#include <spa/utils/defs.h>
++#include <spa/utils/hook.h>
++
++/**
++ * a collection of core system functions
++ */
++#define SPA_TYPE_INTERFACE_System	SPA_TYPE_INFO_INTERFACE_BASE "System"
++#define SPA_TYPE_INTERFACE_DataSystem	SPA_TYPE_INFO_INTERFACE_BASE "DataSystem"
++
++#define SPA_VERSION_SYSTEM		0
++struct spa_system { struct spa_interface iface; };
++
++/* IO events */
++#define SPA_IO_IN	(1 << 0)
++#define SPA_IO_OUT	(1 << 2)
++#define SPA_IO_ERR	(1 << 3)
++#define SPA_IO_HUP	(1 << 4)
++
++/* flags */
++#define SPA_FD_CLOEXEC			(1<<0)
++#define SPA_FD_NONBLOCK			(1<<1)
++#define SPA_FD_EVENT_SEMAPHORE		(1<<2)
++#define SPA_FD_TIMER_ABSTIME		(1<<3)
++#define SPA_FD_TIMER_CANCEL_ON_SET	(1<<4)
++
++struct spa_poll_event {
++	uint32_t events;
++	void *data;
++};
++
++struct spa_system_methods {
++#define SPA_VERSION_SYSTEM_METHODS	0
++	uint32_t version;
++
++	/* read/write/ioctl */
++	ssize_t (*read) (void *object, int fd, void *buf, size_t count);
++	ssize_t (*write) (void *object, int fd, const void *buf, size_t count);
++	int (*ioctl) (void *object, int fd, unsigned long request, ...);
++	int (*close) (void *object, int fd);
++
++	/* clock */
++	int (*clock_gettime) (void *object,
++			int clockid, struct timespec *value);
++	int (*clock_getres) (void *object,
++			int clockid, struct timespec *res);
++
++	/* poll */
++	int (*pollfd_create) (void *object, int flags);
++	int (*pollfd_add) (void *object, int pfd, int fd, uint32_t events, void *data);
++	int (*pollfd_mod) (void *object, int pfd, int fd, uint32_t events, void *data);
++	int (*pollfd_del) (void *object, int pfd, int fd);
++	int (*pollfd_wait) (void *object, int pfd,
++			struct spa_poll_event *ev, int n_ev, int timeout);
++
++	/* timers */
++	int (*timerfd_create) (void *object, int clockid, int flags);
++	int (*timerfd_settime) (void *object,
++			int fd, int flags,
++			const struct itimerspec *new_value,
++			struct itimerspec *old_value);
++	int (*timerfd_gettime) (void *object,
++			int fd, struct itimerspec *curr_value);
++	int (*timerfd_read) (void *object, int fd, uint64_t *expirations);
++
++	/* events */
++	int (*eventfd_create) (void *object, int flags);
++	int (*eventfd_write) (void *object, int fd, uint64_t count);
++	int (*eventfd_read) (void *object, int fd, uint64_t *count);
++
++	/* signals */
++	int (*signalfd_create) (void *object, int signal, int flags);
++	int (*signalfd_read) (void *object, int fd, int *signal);
++};
++
++#define spa_system_method_r(o,method,version,...)			\
++({									\
++	int _res = -ENOTSUP;						\
++	struct spa_system *_o = o;					\
++	spa_interface_call_res(&_o->iface,				\
++			struct spa_system_methods, _res,		\
++			method, version, ##__VA_ARGS__);		\
++	_res;								\
++})
++
++
++#define spa_system_read(s,...)			spa_system_method_r(s,read,0,__VA_ARGS__)
++#define spa_system_write(s,...)			spa_system_method_r(s,write,0,__VA_ARGS__)
++#define spa_system_ioctl(s,...)			spa_system_method_r(s,ioctl,0,__VA_ARGS__)
++#define spa_system_close(s,...)			spa_system_method_r(s,close,0,__VA_ARGS__)
++
++#define spa_system_clock_gettime(s,...)		spa_system_method_r(s,clock_gettime,0,__VA_ARGS__)
++#define spa_system_clock_getres(s,...)		spa_system_method_r(s,clock_getres,0,__VA_ARGS__)
++
++#define spa_system_pollfd_create(s,...)		spa_system_method_r(s,pollfd_create,0,__VA_ARGS__)
++#define spa_system_pollfd_add(s,...)		spa_system_method_r(s,pollfd_add,0,__VA_ARGS__)
++#define spa_system_pollfd_mod(s,...)		spa_system_method_r(s,pollfd_mod,0,__VA_ARGS__)
++#define spa_system_pollfd_del(s,...)		spa_system_method_r(s,pollfd_del,0,__VA_ARGS__)
++#define spa_system_pollfd_wait(s,...)		spa_system_method_r(s,pollfd_wait,0,__VA_ARGS__)
++
++#define spa_system_timerfd_create(s,...)	spa_system_method_r(s,timerfd_create,0,__VA_ARGS__)
++#define spa_system_timerfd_settime(s,...)	spa_system_method_r(s,timerfd_settime,0,__VA_ARGS__)
++#define spa_system_timerfd_gettime(s,...)	spa_system_method_r(s,timerfd_gettime,0,__VA_ARGS__)
++#define spa_system_timerfd_read(s,...)		spa_system_method_r(s,timerfd_read,0,__VA_ARGS__)
++
++#define spa_system_eventfd_create(s,...)	spa_system_method_r(s,eventfd_create,0,__VA_ARGS__)
++#define spa_system_eventfd_write(s,...)		spa_system_method_r(s,eventfd_write,0,__VA_ARGS__)
++#define spa_system_eventfd_read(s,...)		spa_system_method_r(s,eventfd_read,0,__VA_ARGS__)
++
++#define spa_system_signalfd_create(s,...)	spa_system_method_r(s,signalfd_create,0,__VA_ARGS__)
++#define spa_system_signalfd_read(s,...)		spa_system_method_r(s,signalfd_read,0,__VA_ARGS__)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_SYSTEM_H */
+diff --git a/third_party/pipewire/spa/utils/defs.h b/third_party/pipewire/spa/utils/defs.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/defs.h
+@@ -0,0 +1,265 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_UTILS_DEFS_H
++#define SPA_UTILS_DEFS_H
++
++#ifdef __cplusplus
++extern "C" {
++#else
++#include <stdbool.h>
++#endif
++#include <inttypes.h>
++#include <stdlib.h>
++#include <string.h>
++#include <stddef.h>
++#include <stdio.h>
++
++#define SPA_FLAG_MASK(field,mask,flag)	(((field) & (mask)) == (flag))
++#define SPA_FLAG_IS_SET(field,flag)	SPA_FLAG_MASK(field,flag,flag)
++#define SPA_FLAG_SET(field,flag)	((field) |= (flag))
++#define SPA_FLAG_CLEAR(field,flag)	((field) &= ~(flag))
++#define SPA_FLAG_UPDATE(field,flag,val)	((val) ? SPA_FLAG_SET(field,flag) : SPA_FLAG_CLEAR(field,flag))
++
++enum spa_direction {
++	SPA_DIRECTION_INPUT = 0,
++	SPA_DIRECTION_OUTPUT = 1,
++};
++
++#define SPA_DIRECTION_REVERSE(d)	((d) ^ 1)
++
++#define SPA_RECTANGLE(width,height) (struct spa_rectangle){ width, height }
++struct spa_rectangle {
++	uint32_t width;
++	uint32_t height;
++};
++
++#define SPA_POINT(x,y) (struct spa_point){ x, y }
++struct spa_point {
++	int32_t x;
++	int32_t y;
++};
++
++#define SPA_REGION(x,y,width,height) (struct spa_region){ SPA_POINT(x,y), SPA_RECTANGLE(width,height) }
++struct spa_region {
++	struct spa_point position;
++	struct spa_rectangle size;
++};
++
++#define SPA_FRACTION(num,denom) (struct spa_fraction){ num, denom }
++struct spa_fraction {
++	uint32_t num;
++	uint32_t denom;
++};
++
++#define SPA_N_ELEMENTS(arr)  (sizeof(arr) / sizeof((arr)[0]))
++
++#define SPA_MIN(a,b)		\
++({				\
++	__typeof__(a) _a = (a);	\
++	__typeof__(b) _b = (b);	\
++	SPA_LIKELY(_a < _b) ? _a : _b;	\
++})
++#define SPA_MAX(a,b)		\
++({				\
++	__typeof__(a) _a = (a);	\
++	__typeof__(b) _b = (b);	\
++	SPA_LIKELY(_a > _b) ? _a : _b;	\
++})
++#define SPA_CLAMP(v,low,high)				\
++({							\
++	__typeof__(v) _v = (v);				\
++	__typeof__(low) _low = (low);			\
++	__typeof__(high) _high = (high);		\
++	SPA_MIN(SPA_MAX(_v, _low), _high);		\
++})
++
++#define SPA_SWAP(a,b)					\
++({							\
++	__typeof__(a) _t = (a);				\
++	a = b; b = _t;					\
++})
++
++#define SPA_TYPECHECK(type,x)		\
++({	type _dummy;			\
++	typeof(x) _dummy2;		\
++	(void)(&_dummy == &_dummy2);	\
++	x;				\
++})
++
++#define SPA_MEMBER(b,o,t) ((t*)((uint8_t*)(b) + (int)(o)))
++#define SPA_MEMBER_ALIGN(b,o,a,t) SPA_PTR_ALIGN(SPA_MEMBER(b,o,t),a,t)
++
++#define SPA_CONTAINER_OF(p,t,m) (t*)((uint8_t*)p - offsetof (t,m))
++
++#define SPA_PTRDIFF(p1,p2) ((uint8_t*)(p1) - (uint8_t*)(p2))
++
++#define SPA_PTR_TO_INT(p) ((int) ((intptr_t) (p)))
++#define SPA_INT_TO_PTR(u) ((void*) ((intptr_t) (u)))
++
++#define SPA_PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
++#define SPA_UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u)))
++
++#define SPA_TIME_INVALID  ((int64_t)INT64_MIN)
++#define SPA_IDX_INVALID  ((unsigned int)-1)
++#define SPA_ID_INVALID  ((uint32_t)0xffffffff)
++
++#define SPA_NSEC_PER_SEC  (1000000000ll)
++#define SPA_NSEC_PER_MSEC (1000000ll)
++#define SPA_NSEC_PER_USEC (1000ll)
++#define SPA_USEC_PER_SEC  (1000000ll)
++#define SPA_USEC_PER_MSEC (1000ll)
++#define SPA_MSEC_PER_SEC  (1000ll)
++
++#define SPA_TIMESPEC_TO_NSEC(ts) ((ts)->tv_sec * SPA_NSEC_PER_SEC + (ts)->tv_nsec)
++#define SPA_TIMESPEC_TO_USEC(ts) ((ts)->tv_sec * SPA_USEC_PER_SEC + (ts)->tv_nsec / SPA_NSEC_PER_USEC)
++#define SPA_TIMEVAL_TO_NSEC(tv)  ((tv)->tv_sec * SPA_NSEC_PER_SEC + (tv)->tv_usec * SPA_NSEC_PER_USEC)
++#define SPA_TIMEVAL_TO_USEC(tv)  ((tv)->tv_sec * SPA_USEC_PER_SEC + (tv)->tv_usec)
++
++#ifdef __GNUC__
++#define SPA_PRINTF_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
++#define SPA_ALIGNED(align) __attribute__((aligned(align)))
++#define SPA_DEPRECATED __attribute__ ((deprecated))
++#define SPA_EXPORT __attribute__((visibility("default")))
++#define SPA_SENTINEL __attribute__((__sentinel__))
++#define SPA_UNUSED __attribute__ ((unused))
++#else
++#define SPA_PRINTF_FUNC(fmt, arg1)
++#define SPA_ALIGNED(align)
++#define SPA_DEPRECATED
++#define SPA_EXPORT
++#define SPA_SENTINEL
++#define SPA_UNUSED
++#endif
++
++#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
++#define SPA_RESTRICT restrict
++#elif defined(__GNUC__) && __GNUC__ >= 4
++#define SPA_RESTRICT __restrict__
++#else
++#define SPA_RESTRICT
++#endif
++
++#define SPA_ROUND_DOWN_N(num,align)	((num) & ~((align) - 1))
++#define SPA_ROUND_UP_N(num,align)	SPA_ROUND_DOWN_N((num) + ((align) - 1),align)
++
++#define SPA_PTR_ALIGNMENT(p,align)	((intptr_t)(p) & ((align)-1))
++#define SPA_IS_ALIGNED(p,align)		(SPA_PTR_ALIGNMENT(p,align) == 0)
++#define SPA_PTR_ALIGN(p,align,type)	(type*)SPA_ROUND_UP_N((intptr_t)(p), (intptr_t)(align))
++
++#ifndef SPA_LIKELY
++#ifdef __GNUC__
++#define SPA_LIKELY(x) (__builtin_expect(!!(x),1))
++#define SPA_UNLIKELY(x) (__builtin_expect(!!(x),0))
++#else
++#define SPA_LIKELY(x) (x)
++#define SPA_UNLIKELY(x) (x)
++#endif
++#endif
++
++#define SPA_STRINGIFY_1(...)	#__VA_ARGS__
++#define SPA_STRINGIFY(...)	SPA_STRINGIFY_1(__VA_ARGS__)
++
++#define spa_return_if_fail(expr)					\
++	do {								\
++		if (SPA_UNLIKELY(!(expr))) {				\
++			fprintf(stderr, "'%s' failed at %s:%u %s()\n",	\
++				#expr , __FILE__, __LINE__, __func__);	\
++			return;						\
++		}							\
++	} while(false)
++
++#define spa_return_val_if_fail(expr, val)				\
++	do {								\
++		if (SPA_UNLIKELY(!(expr))) {				\
++			fprintf(stderr, "'%s' failed at %s:%u %s()\n",	\
++				#expr , __FILE__, __LINE__, __func__);	\
++			return (val);					\
++		}							\
++	} while(false)
++
++/* spa_assert_se() is an assert which guarantees side effects of x,
++ * i.e. is never optimized away, regardless of NDEBUG or FASTPATH. */
++#define spa_assert_se(expr)						\
++	do {								\
++		if (SPA_UNLIKELY(!(expr))) {				\
++			fprintf(stderr, "'%s' failed at %s:%u %s()\n",	\
++				#expr , __FILE__, __LINE__, __func__);	\
++			abort();					\
++		}							\
++	} while (false)
++
++#define spa_assert(expr)						\
++	do {								\
++		if (SPA_UNLIKELY(!(expr))) {				\
++			fprintf(stderr, "'%s' failed at %s:%u %s()\n",	\
++				#expr , __FILE__, __LINE__, __func__);	\
++			abort();					\
++		}							\
++	} while (false)
++
++#define spa_assert_not_reached()						\
++	do {									\
++		fprintf(stderr, "Code should not be reached at %s:%u %s()\n",	\
++				__FILE__, __LINE__, __func__);			\
++		abort();							\
++	} while (false)
++
++/* Does exactly nothing */
++#define spa_nop() do {} while (false)
++
++#define spa_memzero(x,l) (memset((x), 0, (l)))
++#define spa_zero(x) (spa_memzero(&(x), sizeof(x)))
++
++#ifdef SPA_DEBUG_MEMCPY
++#define spa_memcpy(d,s,n)						\
++({									\
++	fprintf(stderr, "%s:%u %s() memcpy(%p, %p, %zd)\n",		\
++		__FILE__, __LINE__, __func__, (d), (s), (size_t)(n));	\
++	memcpy(d,s,n);							\
++})
++#define spa_memmove(d,s,n)						\
++({									\
++	fprintf(stderr, "%s:%u %s() memmove(%p, %p, %zd)\n",		\
++		__FILE__, __LINE__, __func__, (d), (s), (size_t)(n));	\
++	memmove(d,s,n);							\
++})
++#else
++#define spa_memcpy(d,s,n)	memcpy(d,s,n)
++#define spa_memmove(d,s,n)	memmove(d,s,n)
++#endif
++
++#define spa_aprintf(_fmt, ...)						\
++({									\
++	char *_strp;							\
++	if (asprintf(&(_strp), (_fmt), ## __VA_ARGS__ ) == -1)		\
++		_strp = NULL;						\
++	_strp;								\
++})
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_UTILS_DEFS_H */
+diff --git a/third_party/pipewire/spa/utils/dict.h b/third_party/pipewire/spa/utils/dict.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/dict.h
+@@ -0,0 +1,104 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_DICT_H
++#define SPA_DICT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <string.h>
++
++#include <spa/utils/defs.h>
++
++struct spa_dict_item {
++	const char *key;
++	const char *value;
++};
++
++#define SPA_DICT_ITEM_INIT(key,value) (struct spa_dict_item) { key, value }
++
++struct spa_dict {
++#define SPA_DICT_FLAG_SORTED	(1<<0)		/**< items are sorted */
++	uint32_t flags;
++	uint32_t n_items;
++	const struct spa_dict_item *items;
++};
++
++#define SPA_DICT_INIT(items,n_items) (struct spa_dict) { 0, n_items, items }
++#define SPA_DICT_INIT_ARRAY(items) (struct spa_dict) { 0, SPA_N_ELEMENTS(items), items }
++
++#define spa_dict_for_each(item, dict)				\
++	for ((item) = (dict)->items;				\
++	     (item) < &(dict)->items[(dict)->n_items];		\
++	     (item)++)
++
++static inline int spa_dict_item_compare(const void *i1, const void *i2)
++{
++	const struct spa_dict_item *it1 = (const struct spa_dict_item *)i1,
++	      *it2 = (const struct spa_dict_item *)i2;
++	return strcmp(it1->key, it2->key);
++}
++
++static inline void spa_dict_qsort(struct spa_dict *dict)
++{
++	qsort((void*)dict->items, dict->n_items, sizeof(struct spa_dict_item),
++			spa_dict_item_compare);
++	SPA_FLAG_SET(dict->flags, SPA_DICT_FLAG_SORTED);
++}
++
++static inline const struct spa_dict_item *spa_dict_lookup_item(const struct spa_dict *dict,
++							       const char *key)
++{
++	const struct spa_dict_item *item;
++
++	if (SPA_FLAG_IS_SET(dict->flags, SPA_DICT_FLAG_SORTED)) {
++		struct spa_dict_item k = SPA_DICT_ITEM_INIT(key, NULL);
++		item = (const struct spa_dict_item *)bsearch(&k,
++				(const void *) dict->items, dict->n_items,
++				sizeof(struct spa_dict_item),
++				spa_dict_item_compare);
++		if (item != NULL)
++			return item;
++	} else {
++		spa_dict_for_each(item, dict) {
++			if (!strcmp(item->key, key))
++				return item;
++		}
++	}
++	return NULL;
++}
++
++static inline const char *spa_dict_lookup(const struct spa_dict *dict, const char *key)
++{
++	const struct spa_dict_item *item = spa_dict_lookup_item(dict, key);
++	return item ? item->value : NULL;
++}
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_DICT_H */
+diff --git a/third_party/pipewire/spa/utils/hook.h b/third_party/pipewire/spa/utils/hook.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/hook.h
+@@ -0,0 +1,198 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_HOOK_H
++#define SPA_HOOK_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/list.h>
++
++/** \class spa_hook
++ *
++ * \brief a list of hooks
++ *
++ * The hook list provides a way to keep track of hooks.
++ */
++/** A list of hooks */
++struct spa_hook_list {
++	struct spa_list list;
++};
++
++/** Callbacks, contains the structure with functions and the data passed
++ * to the functions.  The structure should also contain a version field that
++ * is checked. */
++struct spa_callbacks {
++	const void *funcs;
++	void *data;
++};
++
++/** Check if a callback \c has method \m of version \v */
++#define SPA_CALLBACK_CHECK(c,m,v) ((c) && ((v) == 0 || (c)->version > (v)-1) && (c)->m)
++
++#define SPA_CALLBACKS_INIT(_funcs,_data) (struct spa_callbacks){ _funcs, _data, }
++
++struct spa_interface {
++	const char *type;
++	uint32_t version;
++	struct spa_callbacks cb;
++};
++
++#define SPA_INTERFACE_INIT(_type,_version,_funcs,_data) \
++	(struct spa_interface){ _type, _version, SPA_CALLBACKS_INIT(_funcs,_data), }
++
++/** A hook, contains the structure with functions and the data passed
++ * to the functions. */
++struct spa_hook {
++	struct spa_list link;
++	struct spa_callbacks cb;
++	/** callback and data for the hook list */
++	void (*removed) (struct spa_hook *hook);
++	void *priv;
++};
++
++/** Initialize a hook list */
++static inline void spa_hook_list_init(struct spa_hook_list *list)
++{
++	spa_list_init(&list->list);
++}
++
++static inline bool spa_hook_list_is_empty(struct spa_hook_list *list)
++{
++	return spa_list_is_empty(&list->list);
++}
++
++/** Append a hook \memberof spa_hook */
++static inline void spa_hook_list_append(struct spa_hook_list *list,
++					struct spa_hook *hook,
++					const void *funcs, void *data)
++{
++	hook->cb = SPA_CALLBACKS_INIT(funcs, data);
++	spa_list_append(&list->list, &hook->link);
++}
++
++/** Prepend a hook \memberof spa_hook */
++static inline void spa_hook_list_prepend(struct spa_hook_list *list,
++					 struct spa_hook *hook,
++					 const void *funcs, void *data)
++{
++	hook->cb = SPA_CALLBACKS_INIT(funcs, data);
++	spa_list_prepend(&list->list, &hook->link);
++}
++
++/** Remove a hook \memberof spa_hook */
++static inline void spa_hook_remove(struct spa_hook *hook)
++{
++        spa_list_remove(&hook->link);
++	if (hook->removed)
++		hook->removed(hook);
++}
++
++static inline void
++spa_hook_list_isolate(struct spa_hook_list *list,
++		struct spa_hook_list *save,
++		struct spa_hook *hook,
++		const void *funcs, void *data)
++{
++	/* init save list and move hooks to it */
++	spa_hook_list_init(save);
++	spa_list_insert_list(&save->list, &list->list);
++	/* init hooks and add single hook */
++	spa_hook_list_init(list);
++	spa_hook_list_append(list, hook, funcs, data);
++}
++
++static inline void
++spa_hook_list_join(struct spa_hook_list *list,
++		struct spa_hook_list *save)
++{
++	spa_list_insert_list(&list->list, &save->list);
++}
++
++#define spa_callbacks_call(callbacks,type,method,vers,...)			\
++({										\
++	const type *_f = (const type *) (callbacks)->funcs;			\
++	if (SPA_LIKELY(SPA_CALLBACK_CHECK(_f,method,vers)))			\
++		_f->method((callbacks)->data, ## __VA_ARGS__);			\
++})
++
++#define spa_callbacks_call_res(callbacks,type,res,method,vers,...)		\
++({										\
++	const type *_f = (const type *) (callbacks)->funcs;			\
++	if (SPA_LIKELY(SPA_CALLBACK_CHECK(_f,method,vers)))			\
++		res = _f->method((callbacks)->data, ## __VA_ARGS__);		\
++	res;									\
++})
++
++#define spa_interface_call(iface,type,method,vers,...)				\
++	spa_callbacks_call(&(iface)->cb,type,method,vers,##__VA_ARGS__)
++
++#define spa_interface_call_res(iface,type,res,method,vers,...)			\
++	spa_callbacks_call_res(&(iface)->cb,type,res,method,vers,##__VA_ARGS__)
++
++#define spa_hook_list_call_simple(l,type,method,vers,...)			\
++({										\
++	struct spa_hook_list *_l = l;						\
++	struct spa_hook *_h, *_t;						\
++	spa_list_for_each_safe(_h, _t, &_l->list, link)				\
++		spa_callbacks_call(&_h->cb,type,method,vers, ## __VA_ARGS__);	\
++})
++
++/** Call all hooks in a list, starting from the given one and optionally stopping
++ * after calling the first non-NULL function, returns the number of methods
++ * called */
++#define spa_hook_list_do_call(l,start,type,method,vers,once,...)		\
++({										\
++	struct spa_hook_list *list = l;						\
++	struct spa_list *s = start ? (struct spa_list *)start : &list->list;	\
++	struct spa_hook cursor = { 0 }, *ci;					\
++	int count = 0;								\
++	spa_list_cursor_start(cursor, s, link);					\
++	spa_list_for_each_cursor(ci, cursor, &list->list, link) {		\
++		const type *_f = (const type *)ci->cb.funcs;			\
++		if (SPA_LIKELY(SPA_CALLBACK_CHECK(_f,method,vers))) {		\
++			_f->method(ci->cb.data, ## __VA_ARGS__);		\
++			count++;						\
++			if (once)						\
++				break;						\
++		}								\
++	}									\
++	spa_list_cursor_end(cursor, link);					\
++	count;									\
++})
++
++#define spa_hook_list_call(l,t,m,v,...)			spa_hook_list_do_call(l,NULL,t,m,v,false,##__VA_ARGS__)
++#define spa_hook_list_call_once(l,t,m,v,...)		spa_hook_list_do_call(l,NULL,t,m,v,true,##__VA_ARGS__)
++
++#define spa_hook_list_call_start(l,s,t,m,v,...)		spa_hook_list_do_call(l,s,t,m,v,false,##__VA_ARGS__)
++#define spa_hook_list_call_once_start(l,s,t,m,v,...)	spa_hook_list_do_call(l,s,t,m,v,true,##__VA_ARGS__)
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* SPA_HOOK_H */
+diff --git a/third_party/pipewire/spa/utils/keys.h b/third_party/pipewire/spa/utils/keys.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/keys.h
+@@ -0,0 +1,124 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_UTILS_KEYS_H
++#define SPA_UTILS_KEYS_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** for objects */
++#define SPA_KEY_OBJECT_PATH		"object.path"			/**< a unique path to
++									  *  identity the object */
++
++#define SPA_KEY_MEDIA_CLASS		"media.class"			/**< Media class
++									  *  Ex. "Audio/Device",
++									  *  "Video/Source",... */
++#define SPA_KEY_MEDIA_ROLE		"media.role"			/**< Role: Movie, Music, Camera,
++									  *  Screen, Communication, Game,
++									  *  Notification, DSP, Production,
++									  *  Accessibility, Test */
++/** keys for udev api */
++#define SPA_KEY_API_UDEV		"api.udev"			/**< key for the udev api */
++#define SPA_KEY_API_UDEV_MATCH		"api.udev.match"		/**< udev subsystem match */
++
++/** keys for alsa api */
++#define SPA_KEY_API_ALSA		"api.alsa"			/**< key for the alsa api */
++#define SPA_KEY_API_ALSA_PATH		"api.alsa.path"			/**< alsa device path as can be
++									  *  used in snd_pcm_open() and
++									  *  snd_ctl_open(). */
++#define SPA_KEY_API_ALSA_CARD		"api.alsa.card"			/**< alsa card number */
++#define SPA_KEY_API_ALSA_USE_UCM	"api.alsa.use-ucm"		/**< if UCM should be used */
++#define SPA_KEY_API_ALSA_IGNORE_DB	"api.alsa.ignore-dB"		/**< if decibel info should be ignored */
++
++/** info from alsa card_info */
++#define SPA_KEY_API_ALSA_CARD_ID	"api.alsa.card.id"		/**< id from card_info */
++#define SPA_KEY_API_ALSA_CARD_COMPONENTS	\
++					"api.alsa.card.components"	/**< components from card_info */
++#define SPA_KEY_API_ALSA_CARD_DRIVER	"api.alsa.card.driver"		/**< driver from card_info */
++#define SPA_KEY_API_ALSA_CARD_NAME	"api.alsa.card.name"		/**< name from card_info */
++#define SPA_KEY_API_ALSA_CARD_LONGNAME	"api.alsa.card.longname"	/**< longname from card_info */
++#define SPA_KEY_API_ALSA_CARD_MIXERNAME	"api.alsa.card.mixername"	/**< mixername from card_info */
++
++/** info from alsa pcm_info */
++#define SPA_KEY_API_ALSA_PCM_ID		"api.alsa.pcm.id"		/**< id from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_CARD	"api.alsa.pcm.card"		/**< card from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_NAME	"api.alsa.pcm.name"		/**< name from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_SUBNAME	"api.alsa.pcm.subname"		/**< subdevice_name from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_STREAM	"api.alsa.pcm.stream"		/**< stream type from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_CLASS	"api.alsa.pcm.class"		/**< class from pcm_info as string */
++#define SPA_KEY_API_ALSA_PCM_DEVICE	"api.alsa.pcm.device"		/**< device from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_SUBDEVICE	"api.alsa.pcm.subdevice"	/**< subdevice from pcm_info */
++#define SPA_KEY_API_ALSA_PCM_SUBCLASS	"api.alsa.pcm.subclass"		/**< subclass from pcm_info as string */
++#define SPA_KEY_API_ALSA_PCM_SYNC_ID	"api.alsa.pcm.sync-id"		/**< sync id */
++
++/** keys for v4l2 api */
++#define SPA_KEY_API_V4L2		"api.v4l2"			/**< key for the v4l2 api */
++#define SPA_KEY_API_V4L2_PATH		"api.v4l2.path"			/**< v4l2 device path as can be
++									  *  used in open() */
++
++/** keys for libcamera api */
++#define SPA_KEY_API_LIBCAMERA		"api.libcamera"			/**< key for the libcamera api */
++#define SPA_KEY_API_LIBCAMERA_PATH	"api.libcamera.path"	/**< libcamera device path as can be
++									  *  used in open() */
++
++/** info from libcamera_capability */
++#define SPA_KEY_API_LIBCAMERA_CAP_DRIVER	"api.libcamera.cap.driver"	/**< driver from capbility */
++#define SPA_KEY_API_LIBCAMERA_CAP_CARD	"api.libcamera.cap.card"		/**< caps from capability */
++#define SPA_KEY_API_LIBCAMERA_CAP_BUS_INFO	"api.libcamera.cap.bus_info"/**< bus_info from capability */
++#define SPA_KEY_API_LIBCAMERA_CAP_VERSION	"api.libcamera.cap.version"	/**< version from capability as %u.%u.%u */
++#define SPA_KEY_API_LIBCAMERA_CAP_CAPABILITIES	\
++					"api.libcamera.cap.capabilities"	/**< capabilities from capability */
++#define SPA_KEY_API_LIBCAMERA_CAP_DEVICE_CAPS	\
++					"api.libcamera.cap.device-caps"	/**< device_caps from capability */
++/** info from v4l2_capability */
++#define SPA_KEY_API_V4L2_CAP_DRIVER	"api.v4l2.cap.driver"		/**< driver from capbility */
++#define SPA_KEY_API_V4L2_CAP_CARD	"api.v4l2.cap.card"		/**< caps from capability */
++#define SPA_KEY_API_V4L2_CAP_BUS_INFO	"api.v4l2.cap.bus_info"		/**< bus_info from capability */
++#define SPA_KEY_API_V4L2_CAP_VERSION	"api.v4l2.cap.version"		/**< version from capability as %u.%u.%u */
++#define SPA_KEY_API_V4L2_CAP_CAPABILITIES	\
++					"api.v4l2.cap.capabilities"	/**< capabilities from capability */
++#define SPA_KEY_API_V4L2_CAP_DEVICE_CAPS	\
++					"api.v4l2.cap.device-caps"	/**< device_caps from capability */
++
++
++/** keys for bluez5 api */
++#define SPA_KEY_API_BLUEZ5		"api.bluez5"			/**< key for the bluez5 api */
++#define SPA_KEY_API_BLUEZ5_PATH		"api.bluez5.path"		/**< a bluez5 path */
++#define SPA_KEY_API_BLUEZ5_DEVICE	"api.bluez5.device"		/**< an internal bluez5 device */
++#define SPA_KEY_API_BLUEZ5_TRANSPORT	"api.bluez5.transport"		/**< an internal bluez5 transport */
++#define SPA_KEY_API_BLUEZ5_PROFILE	"api.bluez5.profile"		/**< a bluetooth profile */
++#define SPA_KEY_API_BLUEZ5_ADDRESS	"api.bluez5.address"		/**< a bluetooth address */
++
++/** keys for jack api */
++#define SPA_KEY_API_JACK		"api.jack"			/**< key for the JACK api */
++#define SPA_KEY_API_JACK_SERVER		"api.jack.server"		/**< a jack server name */
++#define SPA_KEY_API_JACK_CLIENT		"api.jack.client"		/**< an internal jack client */
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_UTILS_KEYS_H */
+diff --git a/third_party/pipewire/spa/utils/list.h b/third_party/pipewire/spa/utils/list.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/list.h
+@@ -0,0 +1,138 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_LIST_H
++#define SPA_LIST_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++struct spa_list {
++	struct spa_list *next;
++	struct spa_list *prev;
++};
++
++#define SPA_LIST_INIT(list) (struct spa_list){ list, list };
++
++static inline void spa_list_init(struct spa_list *list)
++{
++	*list = SPA_LIST_INIT(list);
++}
++
++#define spa_list_is_empty(l)  ((l)->next == (l))
++
++static inline void spa_list_insert(struct spa_list *list, struct spa_list *elem)
++{
++	elem->prev = list;
++	elem->next = list->next;
++	list->next = elem;
++	elem->next->prev = elem;
++}
++
++static inline void spa_list_insert_list(struct spa_list *list, struct spa_list *other)
++{
++	if (spa_list_is_empty(other))
++		return;
++	other->next->prev = list;
++	other->prev->next = list->next;
++	list->next->prev = other->prev;
++	list->next = other->next;
++}
++
++static inline void spa_list_remove(struct spa_list *elem)
++{
++	elem->prev->next = elem->next;
++	elem->next->prev = elem->prev;
++}
++
++#define spa_list_first(head, type, member)				\
++	SPA_CONTAINER_OF((head)->next, type, member)
++
++#define spa_list_last(head, type, member)				\
++	SPA_CONTAINER_OF((head)->prev, type, member)
++
++#define spa_list_append(list, item)					\
++	spa_list_insert((list)->prev, item)
++
++#define spa_list_prepend(list, item)					\
++	spa_list_insert(list, item)
++
++#define spa_list_is_end(pos, head, member)				\
++	(&(pos)->member == (head))
++
++#define spa_list_next(pos, member)					\
++	SPA_CONTAINER_OF((pos)->member.next, __typeof__(*pos), member)
++
++#define spa_list_prev(pos, member)					\
++	SPA_CONTAINER_OF((pos)->member.prev, __typeof__(*pos), member)
++
++#define spa_list_consume(pos, head, member)				\
++	for (pos = spa_list_first(head, __typeof__(*pos), member);	\
++	     !spa_list_is_empty(head);					\
++	     pos = spa_list_first(head, __typeof__(*pos), member))
++
++#define spa_list_for_each_next(pos, head, curr, member)			\
++	for (pos = spa_list_first(curr, __typeof__(*pos), member);	\
++	     !spa_list_is_end(pos, head, member);			\
++	     pos = spa_list_next(pos, member))
++
++#define spa_list_for_each_prev(pos, head, curr, member)			\
++	for (pos = spa_list_last(curr, __typeof__(*pos), member);	\
++	     !spa_list_is_end(pos, head, member);			\
++	     pos = spa_list_prev(pos, member))
++
++#define spa_list_for_each(pos, head, member)				\
++	spa_list_for_each_next(pos, head, head, member)
++
++#define spa_list_for_each_reverse(pos, head, member)				\
++	spa_list_for_each_prev(pos, head, head, member)
++
++#define spa_list_for_each_safe_next(pos, tmp, head, curr, member)	\
++	for (pos = spa_list_first(curr, __typeof__(*pos), member);	\
++	     tmp = spa_list_next(pos, member),				\
++	     !spa_list_is_end(pos, head, member);			\
++	     pos = tmp)
++
++#define spa_list_for_each_safe(pos, tmp, head, member)			\
++	spa_list_for_each_safe_next(pos, tmp, head, head, member)
++
++#define spa_list_cursor_start(cursor, head, member)                     \
++        spa_list_prepend(head, &(cursor).member)
++
++#define spa_list_for_each_cursor(pos, cursor, head, member)             \
++        for(pos = spa_list_first(&(cursor).member, __typeof__(*(pos)), member); \
++            spa_list_remove(&(pos)->member),                            \
++            spa_list_append(&(cursor).member, &(pos)->member),          \
++            !spa_list_is_end(pos, head, member);                        \
++            pos = spa_list_next(&cursor, member))
++
++#define spa_list_cursor_end(cursor, member)                             \
++        spa_list_remove(&(cursor).member)
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_LIST_H */
+diff --git a/third_party/pipewire/spa/utils/names.h b/third_party/pipewire/spa/utils/names.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/names.h
+@@ -0,0 +1,137 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2019 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_UTILS_NAMES_H
++#define SPA_UTILS_NAMES_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/** for factory names */
++#define SPA_NAME_SUPPORT_CPU		"support.cpu"			/**< A CPU interface */
++#define SPA_NAME_SUPPORT_DBUS		"support.dbus"			/**< A DBUS interface */
++#define SPA_NAME_SUPPORT_LOG		"support.log"			/**< A Log interface */
++#define SPA_NAME_SUPPORT_LOOP		"support.loop"			/**< A Loop/LoopControl/LoopUtils
++									  *  interface */
++#define SPA_NAME_SUPPORT_SYSTEM		"support.system"		/**< A System interface */
++
++#define SPA_NAME_SUPPORT_NODE_DRIVER	"support.node.driver"		/**< A dummy driver node */
++
++/* control mixer */
++#define SPA_NAME_CONTROL_MIXER		"control.mixer"			/**< mixes control streams */
++
++/* audio mixer */
++#define SPA_NAME_AUDIO_MIXER		"audio.mixer"			/**< mixes the raw audio on N input
++									  *  ports together on the output
++									  *  port */
++#define SPA_NAME_AUDIO_MIXER_DSP	"audio.mixer.dsp"		/**< mixes mono audio with fixed input
++									  *  and output buffer sizes. supported
++									  *  formats must include f32 and
++									  *  optionally f64 and s24_32 */
++
++/** audio processing */
++#define SPA_NAME_AUDIO_PROCESS_FORMAT	"audio.process.format"		/**< processes raw audio from one format
++									  *  to another */
++#define SPA_NAME_AUDIO_PROCESS_CHANNELMIX	\
++					"audio.process.channelmix"	/**< mixes raw audio channels and applies
++									  *  volume change. */
++#define SPA_NAME_AUDIO_PROCESS_RESAMPLE		\
++					"audio.process.resample"	/**< resamples raw audio */
++#define SPA_NAME_AUDIO_PROCESS_DEINTERLEAVE	\
++					"audio.process.deinterleave"	/**< deinterleave raw audio channels */
++#define SPA_NAME_AUDIO_PROCESS_INTERLEAVE	\
++					"audio.process.interleave"	/**< interleave raw audio channels */
++
++
++/** audio convert combines some of the audio processing */
++#define SPA_NAME_AUDIO_CONVERT		"audio.convert"			/**< converts raw audio from one format
++									  *  to another. Must include at least
++									  *  format, channelmix and resample
++									  *  processing */
++#define SPA_NAME_AUDIO_ADAPT		"audio.adapt"			/**< combination of a node and an
++									  *  audio.convert. Does clock slaving */
++
++/** video processing */
++#define SPA_NAME_VIDEO_PROCESS_FORMAT	"video.process.format"		/**< processes raw video from one format
++									  *  to another */
++#define SPA_NAME_VIDEO_PROCESS_SCALE	"video.process.scale"		/**< scales raw video */
++
++/** video convert combines some of the video processing */
++#define SPA_NAME_VIDEO_CONVERT		"video.convert"			/**< converts raw video from one format
++									  *  to another. Must include at least
++									  *  format and scaling */
++#define SPA_NAME_VIDEO_ADAPT		"video.adapt"			/**< combination of a node and a
++									  *  video.convert. */
++/** keys for alsa factory names */
++#define SPA_NAME_API_ALSA_ENUM_UDEV	"api.alsa.enum.udev"		/**< an alsa udev Device interface */
++#define SPA_NAME_API_ALSA_PCM_DEVICE	"api.alsa.pcm.device"		/**< an alsa Device interface */
++#define SPA_NAME_API_ALSA_PCM_SOURCE	"api.alsa.pcm.source"		/**< an alsa Node interface for
++									  *  capturing PCM */
++#define SPA_NAME_API_ALSA_PCM_SINK	"api.alsa.pcm.sink"		/**< an alsa Node interface for
++									  *  playback PCM */
++#define SPA_NAME_API_ALSA_SEQ_DEVICE	"api.alsa.seq.device"		/**< an alsa Midi device */
++#define SPA_NAME_API_ALSA_SEQ_SOURCE	"api.alsa.seq.source"		/**< an alsa Node interface for
++									  *  capture of midi */
++#define SPA_NAME_API_ALSA_SEQ_SINK	"api.alsa.seq.sink"		/**< an alsa Node interface for
++									  *  playback of midi */
++#define SPA_NAME_API_ALSA_SEQ_BRIDGE	"api.alsa.seq.bridge"		/**< an alsa Node interface for
++									  *  bridging midi ports */
++#define SPA_NAME_API_ALSA_ACP_DEVICE	"api.alsa.acp.device"		/**< an alsa ACP Device interface */
++
++/** keys for bluez5 factory names */
++#define SPA_NAME_API_BLUEZ5_ENUM_DBUS	"api.bluez5.enum.dbus"		/**< a dbus Device interface */
++#define SPA_NAME_API_BLUEZ5_DEVICE	"api.bluez5.device"		/**< a Device interface */
++#define SPA_NAME_API_BLUEZ5_A2DP_SINK	"api.bluez5.a2dp.sink"		/**< a playback Node interface for A2DP profiles */
++#define SPA_NAME_API_BLUEZ5_A2DP_SOURCE	"api.bluez5.a2dp.source"	/**< a capture Node interface for A2DP profiles */
++#define SPA_NAME_API_BLUEZ5_SCO_SINK	"api.bluez5.sco.sink"		/**< a playback Node interface for HSP/HFP profiles */
++#define SPA_NAME_API_BLUEZ5_SCO_SOURCE	"api.bluez5.sco.source"		/**< a capture Node interface for HSP/HFP profiles */
++
++/** keys for v4l2 factory names */
++#define SPA_NAME_API_V4L2_ENUM_UDEV	"api.v4l2.enum.udev"		/**< a v4l2 udev Device interface */
++#define SPA_NAME_API_V4L2_DEVICE	"api.v4l2.device"		/**< a v4l2 Device interface */
++#define SPA_NAME_API_V4L2_SOURCE	"api.v4l2.source"		/**< a v4l2 Node interface for
++									  *  capturing */
++
++/** keys for libcamera factory names */
++#define SPA_NAME_API_LIBCAMERA_ENUM_CLIENT	"api.libcamera.enum.client"	/**< a libcamera client Device interface */
++#define SPA_NAME_API_LIBCAMERA_DEVICE		"api.libcamera.device"		/**< a libcamera Device interface */
++#define SPA_NAME_API_LIBCAMERA_SOURCE		"api.libcamera.source"		/**< a libcamera Node interface for
++									  *  capturing */
++
++/** keys for jack factory names */
++#define SPA_NAME_API_JACK_DEVICE	"api.jack.device"		/**< a jack device. This is a
++									  *  client connected to a server */
++#define SPA_NAME_API_JACK_SOURCE	"api.jack.source"		/**< a jack source */
++#define SPA_NAME_API_JACK_SINK		"api.jack.sink"			/**< a jack sink */
++
++/** keys for vulkan factory names */
++#define SPA_NAME_API_VULKAN_COMPUTE_SOURCE	\
++					"api.vulkan.compute.source"	/**< a vulkan compute source. */
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_UTILS_NAMES_H */
+diff --git a/third_party/pipewire/spa/utils/result.h b/third_party/pipewire/spa/utils/result.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/result.h
+@@ -0,0 +1,58 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_UTILS_RESULT_H
++#define SPA_UTILS_RESULT_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++#include <spa/utils/list.h>
++
++#define SPA_ASYNC_BIT			(1 << 30)
++#define SPA_ASYNC_MASK			(3 << 30)
++#define SPA_ASYNC_SEQ_MASK		(SPA_ASYNC_BIT - 1)
++
++#define SPA_RESULT_IS_OK(res)		((res) >= 0)
++#define SPA_RESULT_IS_ERROR(res)	((res) < 0)
++#define SPA_RESULT_IS_ASYNC(res)	(((res) & SPA_ASYNC_MASK) == SPA_ASYNC_BIT)
++
++#define SPA_RESULT_ASYNC_SEQ(res)	((res) & SPA_ASYNC_SEQ_MASK)
++#define SPA_RESULT_RETURN_ASYNC(seq)	(SPA_ASYNC_BIT | SPA_RESULT_ASYNC_SEQ(seq))
++
++#define spa_strerror(err)		\
++({					\
++	int _err = -err;		\
++	if (SPA_RESULT_IS_ASYNC(err))	\
++		_err = EINPROGRESS;	\
++	strerror(_err);			\
++})
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* SPA_UTILS_RESULT_H */
+diff --git a/third_party/pipewire/spa/utils/ringbuffer.h b/third_party/pipewire/spa/utils/ringbuffer.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/ringbuffer.h
+@@ -0,0 +1,174 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_RINGBUFFER_H
++#define SPA_RINGBUFFER_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++struct spa_ringbuffer;
++
++#include <string.h>
++
++#include <spa/utils/defs.h>
++
++/**
++ * A ringbuffer type.
++ */
++struct spa_ringbuffer {
++	uint32_t readindex;	/*< the current read index */
++	uint32_t writeindex;	/*< the current write index */
++};
++
++#define SPA_RINGBUFFER_INIT()	(struct spa_ringbuffer) { 0, 0 }
++
++/**
++ * Initialize a spa_ringbuffer with \a size.
++ *
++ * \param rbuf a spa_ringbuffer
++ * \param size the number of elements in the ringbuffer
++ */
++static inline void spa_ringbuffer_init(struct spa_ringbuffer *rbuf)
++{
++	*rbuf = SPA_RINGBUFFER_INIT();
++}
++
++/**
++ * Sets the pointers so that the ringbuffer contains \a size bytes.
++ *
++ * \param rbuf a spa_ringbuffer
++ */
++static inline void spa_ringbuffer_set_avail(struct spa_ringbuffer *rbuf, uint32_t size)
++{
++	rbuf->readindex = 0;
++	rbuf->writeindex = size;
++}
++
++/**
++ * Get the read index and available bytes for reading.
++ *
++ * \param rbuf a  spa_ringbuffer
++ * \param index the value of readindex, should be taken modulo the size of the
++ *         ringbuffer memory to get the offset in the ringbuffer memory
++ * \return number of available bytes to read. values < 0 mean
++ *         there was an underrun. values > rbuf->size means there
++ *         was an overrun.
++ */
++static inline int32_t spa_ringbuffer_get_read_index(struct spa_ringbuffer *rbuf, uint32_t *index)
++{
++	*index = __atomic_load_n(&rbuf->readindex, __ATOMIC_RELAXED);
++	return (int32_t) (__atomic_load_n(&rbuf->writeindex, __ATOMIC_ACQUIRE) - *index);
++}
++
++/**
++ * Read \a len bytes from \a rbuf starting \a offset. \a offset must be taken
++ * modulo \a size and len should be smaller than \a size.
++ *
++ * \param rbuf a #struct spa_ringbuffer
++ * \param buffer memory to read from
++ * \param size the size of \a buffer
++ * \param offset offset in \a buffer to read from
++ * \param data destination memory
++ * \param len number of bytes to read
++ */
++static inline void
++spa_ringbuffer_read_data(struct spa_ringbuffer *rbuf,
++			 const void *buffer, uint32_t size,
++			 uint32_t offset, void *data, uint32_t len)
++{
++	uint32_t l0 = SPA_MIN(len, size - offset), l1 = len - l0;
++	spa_memcpy(data, SPA_MEMBER(buffer, offset, void), l0);
++	if (SPA_UNLIKELY(l1 > 0))
++		spa_memcpy(SPA_MEMBER(data, l0, void), buffer, l1);
++}
++
++/**
++ * Update the read pointer to \a index.
++ *
++ * \param rbuf a spa_ringbuffer
++ * \param index new index
++ */
++static inline void spa_ringbuffer_read_update(struct spa_ringbuffer *rbuf, int32_t index)
++{
++	__atomic_store_n(&rbuf->readindex, index, __ATOMIC_RELEASE);
++}
++
++/**
++ * Get the write index and the number of bytes inside the ringbuffer.
++ *
++ * \param rbuf a  spa_ringbuffer
++ * \param index the value of writeindex, should be taken modulo the size of the
++ *         ringbuffer memory to get the offset in the ringbuffer memory
++ * \return the fill level of \a rbuf. values < 0 mean
++ *         there was an underrun. values > rbuf->size means there
++ *         was an overrun. Subtract from the buffer size to get
++ *         the number of bytes available for writing.
++ */
++static inline int32_t spa_ringbuffer_get_write_index(struct spa_ringbuffer *rbuf, uint32_t *index)
++{
++	*index = __atomic_load_n(&rbuf->writeindex, __ATOMIC_RELAXED);
++	return (int32_t) (*index - __atomic_load_n(&rbuf->readindex, __ATOMIC_ACQUIRE));
++}
++
++/**
++ * Write \a len bytes to \a buffer starting \a offset. \a offset must be taken
++ * modulo \a size and len should be smaller than \a size.
++ *
++ * \param rbuf a spa_ringbuffer
++ * \param buffer memory to write to
++ * \param size the size of \a buffer
++ * \param offset offset in \a buffer to write to
++ * \param data source memory
++ * \param len number of bytes to write
++ */
++static inline void
++spa_ringbuffer_write_data(struct spa_ringbuffer *rbuf,
++			  void *buffer, uint32_t size,
++			  uint32_t offset, const void *data, uint32_t len)
++{
++	uint32_t l0 = SPA_MIN(len, size - offset), l1 = len - l0;
++	spa_memcpy(SPA_MEMBER(buffer, offset, void), data, l0);
++	if (SPA_UNLIKELY(l1 > 0))
++		spa_memcpy(buffer, SPA_MEMBER(data, l0, void), l1);
++}
++
++/**
++ * Update the write pointer to \a index
++ *
++ * \param rbuf a spa_ringbuffer
++ * \param index new index
++ */
++static inline void spa_ringbuffer_write_update(struct spa_ringbuffer *rbuf, int32_t index)
++{
++	__atomic_store_n(&rbuf->writeindex, index, __ATOMIC_RELEASE);
++}
++
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_RINGBUFFER_H */
+diff --git a/third_party/pipewire/spa/utils/type-info.h b/third_party/pipewire/spa/utils/type-info.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/type-info.h
+@@ -0,0 +1,128 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_TYPE_INFO_H
++#define SPA_TYPE_INFO_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++
++#ifndef SPA_TYPE_ROOT
++#define SPA_TYPE_ROOT	spa_types
++#endif
++
++static inline bool spa_type_is_a(const char *type, const char *parent)
++{
++	return type != NULL && parent != NULL && strncmp(type, parent, strlen(parent)) == 0;
++}
++
++#include <spa/utils/type.h>
++
++/* base for parameter object enumerations */
++#define SPA_TYPE_INFO_Direction			SPA_TYPE_INFO_ENUM_BASE "Direction"
++#define SPA_TYPE_INFO_DIRECTION_BASE		SPA_TYPE_INFO_Direction ":"
++
++static const struct spa_type_info spa_type_direction[] = {
++	{ SPA_DIRECTION_INPUT, SPA_TYPE_Int, SPA_TYPE_INFO_DIRECTION_BASE "Input", NULL  },
++	{ SPA_DIRECTION_OUTPUT, SPA_TYPE_Int, SPA_TYPE_INFO_DIRECTION_BASE "Output", NULL  },
++	{ 0, 0, NULL, NULL }
++};
++
++#include <spa/node/type-info.h>
++#include <spa/param/type-info.h>
++#include <spa/control/type-info.h>
++
++/* base for parameter object enumerations */
++#define SPA_TYPE_INFO_Choice			SPA_TYPE_INFO_ENUM_BASE "Choice"
++#define SPA_TYPE_INFO_CHOICE_BASE		SPA_TYPE_INFO_Choice ":"
++
++static const struct spa_type_info spa_type_choice[] = {
++	{ SPA_CHOICE_None, SPA_TYPE_Int, SPA_TYPE_INFO_CHOICE_BASE "None", NULL  },
++	{ SPA_CHOICE_Range, SPA_TYPE_Int, SPA_TYPE_INFO_CHOICE_BASE "Range", NULL  },
++	{ SPA_CHOICE_Step, SPA_TYPE_Int, SPA_TYPE_INFO_CHOICE_BASE "Step", NULL  },
++	{ SPA_CHOICE_Enum, SPA_TYPE_Int, SPA_TYPE_INFO_CHOICE_BASE "Enum", NULL  },
++	{ SPA_CHOICE_Flags, SPA_TYPE_Int, SPA_TYPE_INFO_CHOICE_BASE "Flags", NULL  },
++	{ 0, 0, NULL, NULL }
++};
++
++static const struct spa_type_info spa_types[] = {
++        /* Basic types */
++	{ SPA_TYPE_START, SPA_TYPE_START, SPA_TYPE_INFO_BASE, NULL },
++	{ SPA_TYPE_None, SPA_TYPE_None, SPA_TYPE_INFO_BASE "None", NULL },
++	{ SPA_TYPE_Bool, SPA_TYPE_Bool, SPA_TYPE_INFO_BASE "Bool", NULL },
++	{ SPA_TYPE_Id, SPA_TYPE_Int, SPA_TYPE_INFO_BASE "Id", NULL },
++	{ SPA_TYPE_Int, SPA_TYPE_Int, SPA_TYPE_INFO_BASE "Int", NULL },
++	{ SPA_TYPE_Long, SPA_TYPE_Long, SPA_TYPE_INFO_BASE "Long", NULL },
++	{ SPA_TYPE_Float, SPA_TYPE_Float, SPA_TYPE_INFO_BASE "Float", NULL },
++	{ SPA_TYPE_Double, SPA_TYPE_Double, SPA_TYPE_INFO_BASE "Double", NULL },
++	{ SPA_TYPE_String, SPA_TYPE_String, SPA_TYPE_INFO_BASE "String", NULL },
++	{ SPA_TYPE_Bytes, SPA_TYPE_Bytes, SPA_TYPE_INFO_BASE "Bytes", NULL },
++	{ SPA_TYPE_Rectangle, SPA_TYPE_Rectangle, SPA_TYPE_INFO_BASE "Rectangle", NULL },
++	{ SPA_TYPE_Fraction, SPA_TYPE_Fraction, SPA_TYPE_INFO_BASE "Fraction", NULL },
++	{ SPA_TYPE_Bitmap, SPA_TYPE_Bitmap, SPA_TYPE_INFO_BASE "Bitmap", NULL },
++	{ SPA_TYPE_Array, SPA_TYPE_Array, SPA_TYPE_INFO_BASE "Array", NULL },
++	{ SPA_TYPE_Pod, SPA_TYPE_Pod, SPA_TYPE_INFO_Pod, NULL },
++	{ SPA_TYPE_Struct, SPA_TYPE_Pod, SPA_TYPE_INFO_Struct, NULL },
++	{ SPA_TYPE_Object, SPA_TYPE_Pod, SPA_TYPE_INFO_Object, NULL },
++	{ SPA_TYPE_Sequence, SPA_TYPE_Pod, SPA_TYPE_INFO_POD_BASE "Sequence", NULL },
++	{ SPA_TYPE_Pointer, SPA_TYPE_Pointer, SPA_TYPE_INFO_Pointer, NULL },
++	{ SPA_TYPE_Fd, SPA_TYPE_Fd, SPA_TYPE_INFO_BASE "Fd", NULL },
++	{ SPA_TYPE_Choice, SPA_TYPE_Pod, SPA_TYPE_INFO_POD_BASE "Choice", NULL },
++
++	{ SPA_TYPE_POINTER_START, SPA_TYPE_Pointer, SPA_TYPE_INFO_Pointer, NULL },
++	{ SPA_TYPE_POINTER_Buffer, SPA_TYPE_Pointer, SPA_TYPE_INFO_POINTER_BASE "Buffer", NULL },
++	{ SPA_TYPE_POINTER_Meta, SPA_TYPE_Pointer, SPA_TYPE_INFO_POINTER_BASE "Meta", NULL },
++	{ SPA_TYPE_POINTER_Dict, SPA_TYPE_Pointer, SPA_TYPE_INFO_POINTER_BASE "Dict", NULL },
++
++	{ SPA_TYPE_EVENT_START, SPA_TYPE_Object, SPA_TYPE_INFO_Event, NULL },
++	{ SPA_TYPE_EVENT_Device, SPA_TYPE_Object, SPA_TYPE_INFO_EVENT_BASE "Device", NULL },
++	{ SPA_TYPE_EVENT_Node, SPA_TYPE_Object, SPA_TYPE_INFO_EVENT_BASE "Node", spa_type_node_event },
++
++	{ SPA_TYPE_COMMAND_START, SPA_TYPE_Object, SPA_TYPE_INFO_Command, NULL },
++	{ SPA_TYPE_COMMAND_Device, SPA_TYPE_Object, SPA_TYPE_INFO_COMMAND_BASE "Device", NULL },
++	{ SPA_TYPE_COMMAND_Node, SPA_TYPE_Object, SPA_TYPE_INFO_COMMAND_BASE "Node", spa_type_node_command },
++
++	{ SPA_TYPE_OBJECT_START, SPA_TYPE_Object, SPA_TYPE_INFO_Object, NULL },
++	{ SPA_TYPE_OBJECT_PropInfo, SPA_TYPE_Object, SPA_TYPE_INFO_PropInfo, spa_type_prop_info, },
++	{ SPA_TYPE_OBJECT_Props, SPA_TYPE_Object, SPA_TYPE_INFO_Props, spa_type_props },
++	{ SPA_TYPE_OBJECT_Format, SPA_TYPE_Object, SPA_TYPE_INFO_Format, spa_type_format },
++	{ SPA_TYPE_OBJECT_ParamBuffers, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_Buffers, spa_type_param_buffers, },
++	{ SPA_TYPE_OBJECT_ParamMeta, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_Meta, spa_type_param_meta },
++	{ SPA_TYPE_OBJECT_ParamIO, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_IO, spa_type_param_io },
++	{ SPA_TYPE_OBJECT_ParamProfile, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_Profile, spa_type_param_profile },
++	{ SPA_TYPE_OBJECT_ParamPortConfig, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_PortConfig, spa_type_param_port_config },
++	{ SPA_TYPE_OBJECT_ParamRoute, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_Route, spa_type_param_route },
++	{ SPA_TYPE_OBJECT_Profiler, SPA_TYPE_Object, SPA_TYPE_INFO_Profiler, spa_type_profiler },
++
++	{ 0, 0, NULL, NULL }
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_TYPE_INFO_H */
+diff --git a/third_party/pipewire/spa/utils/type.h b/third_party/pipewire/spa/utils/type.h
+new file mode 100644
+--- /dev/null
++++ b/third_party/pipewire/spa/utils/type.h
+@@ -0,0 +1,138 @@
++/* Simple Plugin API
++ *
++ * Copyright © 2018 Wim Taymans
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the "Software"),
++ * to deal in the Software without restriction, including without limitation
++ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
++ * and/or sell copies of the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice (including the next
++ * paragraph) shall be included in all copies or substantial portions of the
++ * Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
++ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef SPA_TYPE_H
++#define SPA_TYPE_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <spa/utils/defs.h>
++
++enum {
++	/* Basic types */
++	SPA_TYPE_START = 0x00000,
++	SPA_TYPE_None,
++        SPA_TYPE_Bool,
++        SPA_TYPE_Id,
++        SPA_TYPE_Int,
++        SPA_TYPE_Long,
++        SPA_TYPE_Float,
++        SPA_TYPE_Double,
++        SPA_TYPE_String,
++        SPA_TYPE_Bytes,
++        SPA_TYPE_Rectangle,
++        SPA_TYPE_Fraction,
++        SPA_TYPE_Bitmap,
++        SPA_TYPE_Array,
++        SPA_TYPE_Struct,
++        SPA_TYPE_Object,
++        SPA_TYPE_Sequence,
++        SPA_TYPE_Pointer,
++        SPA_TYPE_Fd,
++        SPA_TYPE_Choice,
++        SPA_TYPE_Pod,
++	SPA_TYPE_LAST,				/**< not part of ABI */
++
++	/* Pointers */
++	SPA_TYPE_POINTER_START = 0x10000,
++	SPA_TYPE_POINTER_Buffer,
++	SPA_TYPE_POINTER_Meta,
++	SPA_TYPE_POINTER_Dict,
++	SPA_TYPE_POINTER_LAST,			/**< not part of ABI */
++
++	/* Events */
++	SPA_TYPE_EVENT_START = 0x20000,
++	SPA_TYPE_EVENT_Device,
++	SPA_TYPE_EVENT_Node,
++	SPA_TYPE_EVENT_LAST,			/**< not part of ABI */
++
++	/* Commands */
++	SPA_TYPE_COMMAND_START = 0x30000,
++	SPA_TYPE_COMMAND_Device,
++	SPA_TYPE_COMMAND_Node,
++	SPA_TYPE_COMMAND_LAST,			/**< not part of ABI */
++
++	/* Objects */
++	SPA_TYPE_OBJECT_START = 0x40000,
++	SPA_TYPE_OBJECT_PropInfo,
++	SPA_TYPE_OBJECT_Props,
++	SPA_TYPE_OBJECT_Format,
++	SPA_TYPE_OBJECT_ParamBuffers,
++	SPA_TYPE_OBJECT_ParamMeta,
++	SPA_TYPE_OBJECT_ParamIO,
++	SPA_TYPE_OBJECT_ParamProfile,
++	SPA_TYPE_OBJECT_ParamPortConfig,
++	SPA_TYPE_OBJECT_ParamRoute,
++	SPA_TYPE_OBJECT_Profiler,
++	SPA_TYPE_OBJECT_LAST,			/**< not part of ABI */
++
++	/* vendor extensions */
++	SPA_TYPE_VENDOR_PipeWire	= 0x02000000,
++
++	SPA_TYPE_VENDOR_Other		= 0x7f000000,
++};
++
++#define SPA_TYPE_INFO_BASE			"Spa:"
++
++#define SPA_TYPE_INFO_Flags			SPA_TYPE_INFO_BASE "Flags"
++#define SPA_TYPE_INFO_FLAGS_BASE		SPA_TYPE_INFO_Flags ":"
++
++#define SPA_TYPE_INFO_Enum			SPA_TYPE_INFO_BASE "Enum"
++#define SPA_TYPE_INFO_ENUM_BASE			SPA_TYPE_INFO_Enum ":"
++
++#define SPA_TYPE_INFO_Pod			SPA_TYPE_INFO_BASE "Pod"
++#define SPA_TYPE_INFO_POD_BASE			SPA_TYPE_INFO_Pod ":"
++
++#define SPA_TYPE_INFO_Struct			SPA_TYPE_INFO_POD_BASE "Struct"
++#define SPA_TYPE_INFO_STRUCT_BASE		SPA_TYPE_INFO_Struct ":"
++
++#define SPA_TYPE_INFO_Object			SPA_TYPE_INFO_POD_BASE "Object"
++#define SPA_TYPE_INFO_OBJECT_BASE		SPA_TYPE_INFO_Object ":"
++
++#define SPA_TYPE_INFO_Pointer			SPA_TYPE_INFO_BASE "Pointer"
++#define SPA_TYPE_INFO_POINTER_BASE		SPA_TYPE_INFO_Pointer ":"
++
++#define SPA_TYPE_INFO_Interface			SPA_TYPE_INFO_POINTER_BASE "Interface"
++#define SPA_TYPE_INFO_INTERFACE_BASE		SPA_TYPE_INFO_Interface ":"
++
++#define SPA_TYPE_INFO_Event			SPA_TYPE_INFO_OBJECT_BASE "Event"
++#define SPA_TYPE_INFO_EVENT_BASE		SPA_TYPE_INFO_Event ":"
++
++#define SPA_TYPE_INFO_Command			SPA_TYPE_INFO_OBJECT_BASE "Command"
++#define SPA_TYPE_INFO_COMMAND_BASE		SPA_TYPE_INFO_Command ":"
++
++struct spa_type_info {
++	uint32_t type;
++	uint32_t parent;
++	const char *name;
++	const struct spa_type_info *values;
++};
++
++#ifdef __cplusplus
++}  /* extern "C" */
++#endif
++
++#endif /* SPA_TYPE_H */
+