@@ -1,4 +1,9 @@

 -------------------------------------------------------------------

+Fri Sep 22 17:21:32 UTC 2023 - Bjørn Lie <zaitor@opensuse.org>

+

+- Update to version 0.3.80

+

+-------------------------------------------------------------------

 Wed Aug 30 13:49:39 UTC 2023 - Bjørn Lie <zaitor@opensuse.org>

 - Update to version 0.3.79

​

@@ -7,7 +7,7 @@

 %define soversion 0_2

 Name:           pipewire-aptx

-Version:        0.3.79

+Version:        0.3.80

 Release:        0

 Summary:        PipeWire Bluetooth aptX codec plugin

 License:        MIT

​

@@ -18,6 +18,7 @@

 subprojects/libyaml.wrap

 subprojects/libyaml

 subprojects/libcamera

+subprojects/webrtc-audio-processing

 # Created by https://www.gitignore.io/api/vim

​

@@ -1,3 +1,71 @@

+# PipeWire 0.3.80 (2023-09-14)

+

+This is a bugfix release that is API and ABI compatible with previous

+0.3.x releases.

+

+## Highlights

+  - A new Tag param was added that allows arbitrary metadata to be transported

+    out-of-band in the graph.

+  - Vulkan DMA buf support was merged.

+  - The echo-canceller was ported to webrtc-audio-processing-1.

+  - Fix a regression in locating monitor sources by id in pulse-server.

+  - Mixer io areas updates are now synchronized correctly with the data

+    thread to avoid potential crashes.

+  - Many more bugfixes and improvements.

+

+

+## PipeWire

+  - Handle driver nodes that refuse to change the quantum or rate.

+  - A new Tag param was added that allows arbitrary metadata to be transported

+    out-of-band in the graph.

+

+## Modules

+  - The pipe-tunnel source has been reworked to use a ringbuffer and rate

+    adaption to keep the latency constant. It can now also function as a

+    driver to reduce resampling. (#3478)

+

+## Tools

+  - pw-cat will now place media properties in Tag params.

+  - pw-mon can now filter props and params.

+

+## SPA

+  - ALSA refuses to change quantum and rate when in IRQ mode.

+  - ALSA will now be smarter in selecting the period size for batch devices

+    and will make it depend on the samplerate. (#3444)

+  - Vulkan DMA buf support was merged.

+  - ALSA latency will now be reported in the time domain of the graph.

+  - Add udev based autodetection for compress-offload devices.

+  - The echo-canceller was ported to webrtc-audio-processing-1.

+  - The v4l2 inotify code was rewritten to avoid a use-after-free and by

+    using a separate watch (but same fd) for each device. (#3439)

+  - The tag and latency handling was improved in audioadpter.

+  - Don't use -Ofast on alpha because it can crash on denormalized

+    values. (#3489)

+  - The mixers now synchronize spa_io_buffers updates with the data

+    thread to avoid crashes.

+  - Handle NULL param updates. (#3504)

+

+## Pulse-server

+  - Fix a regression in locating monitor sources by id. (#3476)

+  - Add support for use_system_clock_for_timing in module-pipe-sink.

+  - Add support for checking module arguments.

+  - Avoid some useless change events.

+

+## Bluetooth

+  - Ports are now marked as physical, which makes the bluetooth devices show

+    up as hardware devices in Ardour and other JACK apps. (#3418)

+  - Some fixes for LE audio support (#3479)

+

+## JACK

+  - Also emit unregister notify even when supressed when creating the

+    client.

+  - The notify callbacks now match JACK2 behaviour more.

+  - The mixer io areas are updated and handled safely now to avoid

+    crashes. (#3506)

+

+Older versions:

+

+

 # PipeWire 0.3.79 (2023-08-29)

 This is a quick bugfix release that is API and ABI compatible with previous

@@ -53,9 +121,6 @@

   - Improve property handling, support lists and ranges in addition to

     fixed values. (#3451)

-Older versions:

-

-

 # PipeWire 0.3.78 (2023-08-22)

 This is a small bugfix release that is API and ABI compatible with previous

​

@@ -17,8 +17,8 @@

 ===========

 **pipewire-pulse** starts a PulseAudio-compatible daemon that integrates with

-the PipeWire media server. This daemon is a drop-in replacement for the

-PulseAudio daemon.

+the PipeWire media server, by running a pipewire process through a systemd

+service. This daemon is a drop-in replacement for the PulseAudio daemon.

 OPTIONS

 =======

​

@@ -69,7 +69,7 @@

 of use, a relaxed format may be used where:

  * ``:`` to delimit keys and values can be substuted by ``=`` or a space.

- * ``"`` around keys and string can be omited as long as no special characters are used in the strings.

+ * ``"`` around keys and string can be omitted as long as no special characters are used in the strings.

  * ``,`` to separate objects can be replaced with a whitespace character.

  * ``#`` can be used to start a comment until the line end

​

@@ -155,11 +155,17 @@

 -h | --help

   Show help.

+-b | --batch-mode

+  Run in non-interactive batch mode, similar to top's batch mode.

+

+-n | --iterations=NUMBER

+  Exit after NUMBER of batch iterations. Only used in batch mode.

+

 -r | --remote=NAME

   The name the *remote* instance to monitor. If left unspecified,

   a connection is made to the default PipeWire instance.

---version

+-V | --version

   Show version information.

​

@@ -1,5 +1,5 @@

 project('pipewire', 'c' ,

-  version : '0.3.79',

+  version : '0.3.80',

   license :  'MIT', 'LGPL-2.1-or-later', 'GPL-2.0-only' ,

   meson_version : '>= 0.61.1',

   default_options :  'warning_level=3',

@@ -49,7 +49,9 @@

 pipewire_confdatadir = pipewire_datadir / 'pipewire'

 modules_install_dir = pipewire_libdir / pipewire_name

-if host_machine.system() == 'linux'

+cc = meson.get_compiler('c')

+

+if cc.has_header('features.h') and cc.get_define('__GLIBC__', prefix: '#include <features.h>') != ''

   # glibc ld.so interprets ${LIB} in a library loading path with an

   # appropriate value for the current architecture, typically something

   # like lib, lib64 or lib/x86_64-linux-gnu.

@@ -72,8 +74,6 @@

 pkgconfig = import('pkgconfig')

-cc = meson.get_compiler('c')

-

 common_flags = 

   '-fvisibility=hidden',

   '-fno-strict-aliasing',

@@ -375,8 +375,8 @@

 cdata.set('HAVE_GSTREAMER_DEVICE_PROVIDER', get_option('gstreamer-device-provider').allowed())

-webrtc_dep = dependency('webrtc-audio-processing',

-  version : '>= 0.2', '< 1.0',

+webrtc_dep = dependency('webrtc-audio-processing-1',

+  version : '>= 1.2' ,

   required : get_option('echo-cancel-webrtc'))

 summary({'WebRTC Echo Canceling': webrtc_dep.found()}, bool_yn: true, section: 'Misc dependencies')

 cdata.set('HAVE_WEBRTC', webrtc_dep.found())

​

@@ -247,6 +247,7 @@

    struct spa_io_buffers io;

    struct spa_list mix;

+   uint32_t n_mix;

    struct mix *global_mix;

    struct port *tied;

@@ -526,6 +527,27 @@

 }

+struct io_info {

+   struct mix *mix;

+   void *data;

+};

+

+static int

+do_mix_set_io(struct spa_loop *loop, bool async, uint32_t seq,

+       const void *data, size_t size, void *user_data)

+{

+   struct io_info *info = user_data;

+   info->mix->io = info->data;

+   return 0;

+}

+

+static inline void mix_set_io(struct mix *mix, void *data)

+{

+   struct io_info info = { .mix = mix, .data = data };

+   pw_data_loop_invoke(mix->port->client->loop,

+       do_mix_set_io, SPA_ID_INVALID, NULL, 0, true, &info);

+}

+

 static void init_mix(struct mix *mix, uint32_t mix_id, struct port *port, uint32_t peer_id)

 {

    pw_log_debug("create %p mix:%d peer:%d", port, mix_id, peer_id);

@@ -538,6 +560,8 @@

    spa_list_init(&mix->queue);

    if (mix_id == SPA_ID_INVALID)

        port->global_mix = mix;

+   else if (port->n_mix++ == 0 && port->global_mix != NULL)

+       mix_set_io(port->global_mix, &port->io);

 }

 static struct mix *find_mix_peer(struct client *c, uint32_t peer_id)

 {

@@ -618,10 +642,14 @@

 static void free_mix(struct client *c, struct mix *mix)

 {

+   struct port *port = mix->port;

+

    clear_buffers(c, mix);

    spa_list_remove(&mix->port_link);

    if (mix->id == SPA_ID_INVALID)

-       mix->port->global_mix = NULL;

+       port->global_mix = NULL;

+   else if (--port->n_mix == 0 && port->global_mix != NULL)

+       mix_set_io(port->global_mix, NULL);

    spa_list_remove(&mix->link);

    spa_list_append(&c->free_mix, &mix->link);

 }

@@ -1108,9 +1136,12 @@

        }

        pw_log_debug("%p: skip notify %08x active:%d emit:%d", c, type,

                c->active, emit);

-       if (o != NULL && arg1 == 0 && o->removing) {

-           o->removing = false;

-           free_object(c, o);

+       if (o != NULL) {

+           o->registered = arg1;

+           if (arg1 == 0 && o->removing) {

+               o->removing = false;

+               free_object(c, o);

+           }

        }

        return res;

    }

@@ -1395,6 +1426,7 @@

    void *ptr = NULL;

    struct buffer *b;

    struct spa_data *d;

+   struct spa_io_buffers *io;

    if (frames == 0 || !p->valid)

        return NULL;

@@ -1402,20 +1434,21 @@

    if (SPA_UNLIKELY((mix = p->global_mix) == NULL))

        return NULL;

-   pw_log_trace_fp("%p: port %s %d get buffer %d n_buffers:%d",

-           c, p->object->port.name, p->port_id, frames, mix->n_buffers);

+   pw_log_trace_fp("%p: port %s %d get buffer %d n_buffers:%d io:%p",

+           c, p->object->port.name, p->port_id, frames,

+           mix->n_buffers, mix->io);

-   if (SPA_UNLIKELY(mix->n_buffers == 0))

+   if (SPA_UNLIKELY((io = mix->io) == NULL))

        return NULL;

-   if (p->io.status == SPA_STATUS_HAVE_DATA &&

-       p->io.buffer_id < mix->n_buffers) {

-       b = &mix->buffersp->io.buffer_id;

+   if (io->status == SPA_STATUS_HAVE_DATA &&

+       io->buffer_id < mix->n_buffers) {

+       b = &mix->buffersio->buffer_id;

        d = &b->datas0;

    } else {

-       if (p->io.buffer_id < mix->n_buffers) {

-           reuse_buffer(c, mix, p->io.buffer_id);

-           p->io.buffer_id = SPA_ID_INVALID;

+       if (io->buffer_id < mix->n_buffers) {

+           reuse_buffer(c, mix, io->buffer_id);

+           io->buffer_id = SPA_ID_INVALID;

        }

        if (SPA_UNLIKELY((b = dequeue_buffer(c, mix)) == NULL)) {

            pw_log_warn("port %p: out of buffers", p);

@@ -1426,8 +1459,8 @@

        d->chunk->size = frames * sizeof(float);

        d->chunk->stride = stride;

-       p->io.status = SPA_STATUS_HAVE_DATA;

-       p->io.buffer_id = b->id;

+       io->status = SPA_STATUS_HAVE_DATA;

+       io->buffer_id = b->id;

    }

    ptr = d->data;

    if (buf)

@@ -1469,14 +1502,19 @@

 static void prepare_output(struct port *p, uint32_t frames)

 {

    struct mix *mix;

+   struct spa_io_buffers *io;

    if (SPA_UNLIKELY(p->empty_out || p->tied))

        process_empty(p, frames);

+   if (p->global_mix == NULL || (io = p->global_mix->io) == NULL)

+       return;

+

    spa_list_for_each(mix, &p->mix, port_link) {

        if (SPA_LIKELY(mix->io != NULL))

-           *mix->io = p->io;

+           *mix->io = *io;

    }

+   io->status = SPA_STATUS_NEED_DATA;

 }

 static void complete_process(struct client *c, uint32_t frames)

@@ -1492,7 +1530,6 @@

        if (!p->valid)

            continue;

        prepare_output(p, frames);

-       p->io.status = SPA_STATUS_NEED_DATA;

    }

    pw_array_for_each(item, &c->portsSPA_DIRECTION_INPUT.items) {

                 if (pw_map_item_is_free(item))

@@ -2405,7 +2442,6 @@

    if (param == NULL)

        return 0;

-

    if ((res = spa_latency_parse(param, &info)) < 0)

        return res;

@@ -2685,7 +2721,7 @@

    switch (id) {

    case SPA_IO_Buffers:

-                mix->io = ptr;

+       mix_set_io(mix, ptr);

        break;

    default:

        break;

@@ -2812,6 +2848,9 @@

    mix = find_mix(c, p, mix_id);

+   pw_log_debug("%p: port %p mix:%d peer_id:%u info:%p", c, p, mix_id,

+           peer_id, props);

+

    if (peer_id == SPA_ID_INVALID) {

        if (mix == NULL) {

            res = -ENOENT;

@@ -3110,15 +3149,23 @@

            pw_node_state_as_string(info->state), n->node.is_running);

    if (info->change_mask & PW_NODE_CHANGE_MASK_STATE) {

-       struct object *p;

+       struct object *p, *l;

        spa_list_for_each(p, &c->context.objects, link) {

            if (p->type != INTERFACE_Port || p->removed ||

                p->port.node_id != info->id)

                continue;

            if (n->node.is_running)

                queue_notify(c, NOTIFY_TYPE_PORTREGISTRATION, p, 1, NULL);

-           else

+           else {

+               spa_list_for_each(l, &c->context.objects, link) {

+                   if (l->type != INTERFACE_Link || l->removed ||

+                       (l->port_link.src_serial != p->serial &&

+                        l->port_link.dst_serial != p->serial))

+                       continue;

+                   queue_notify(c, NOTIFY_TYPE_CONNECT, l, 0, NULL);

+               }

                queue_notify(c, NOTIFY_TYPE_PORTREGISTRATION, p, 0, NULL);

+           }

        }

    }

 }

@@ -4141,7 +4188,11 @@

    pw_thread_loop_lock(c->context.loop);

    freeze_callbacks(c);

+   /* reemit buffer_frames */

+   c->buffer_frames = 0;

+

    pw_data_loop_start(c->loop);

+   c->active = true;

    if ((res = do_activate(c)) < 0)

        goto done;

@@ -4149,17 +4200,18 @@

    c->activation->pending_new_pos = true;

    c->activation->pending_sync = true;

-   c->active = true;

-

    spa_list_for_each(o, &c->context.objects, link) {

        if (o->type != INTERFACE_Port || o->port.port == NULL ||

            o->port.port->client != c || !o->port.port->valid)

            continue;

+       o->registered = 0;

        queue_notify(c, NOTIFY_TYPE_PORTREGISTRATION, o, 1, NULL);

    }

 done:

-   if (res < 0)

+   if (res < 0) {

+       c->active = false;

        pw_data_loop_stop(c->loop);

+   }

    pw_log_debug("%p: activate result:%d", c, res);

    thaw_callbacks(c);

​

@@ -53,25 +53,32 @@

 #define spa_debug_log_pod(l,lev,indent,info,pod)               \

 ({                                     \

-   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

+   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

    if (SPA_UNLIKELY(spa_log_level_topic_enabled(c.log, c.topic, c.level))) \

        spa_debugc_pod(&c.ctx, indent, info, pod);          \

 })

 #define spa_debug_log_format(l,lev,indent,info,format)                 \

 ({                                     \

-   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

+   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

    if (SPA_UNLIKELY(spa_log_level_topic_enabled(c.log, c.topic, c.level))) \

        spa_debugc_format(&c.ctx, indent, info, format);        \

 })

 #define spa_debug_log_mem(l,lev,indent,data,len)               \

 ({                                     \

-   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

+   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

    if (SPA_UNLIKELY(spa_log_level_topic_enabled(c.log, c.topic, c.level))) \

        spa_debugc_mem(&c.ctx, indent, data, len);          \

 })

+#define spa_debug_log_dict(l,lev,indent,dict)                  \

+({                                     \

+   struct spa_debug_log_ctx c = SPA_LOG_DEBUG_INIT(l,lev);         \

+   if (SPA_UNLIKELY(spa_log_level_topic_enabled(c.log, c.topic, c.level))) \

+       spa_debugc_dict(&c.ctx, indent, dict);              \

+})

+

 /**

  * \}

  */

​

@@ -16,6 +16,8 @@

 /** node keys */

 #define SPA_KEY_NODE_NAME      "node.name"     /**< a node name */

+#define SPA_KEY_NODE_DESCRIPTION   "node.description"  /**< localized human readable node one-line

+                                 *  description. Ex. "Foobar USB Headset" */

 #define SPA_KEY_NODE_LATENCY       "node.latency"      /**< the requested node latency */

 #define SPA_KEY_NODE_MAX_LATENCY   "node.max-latency"  /**< maximum supported latency */

​

@@ -485,7 +485,9 @@

     *

     * When \a param is NULL, the parameter will be unset.

     *

-    * This function must be called from the main thread.

+    * This function must be called from the main thread. The node muse be paused

+    * or the port SPA_IO_Buffers area is NULL when this function is called with

+    * a param that changes the processing state (like a format change).

     *

     * \param node a struct \ref spa_node

     * \param direction a enum \ref spa_direction

@@ -540,7 +542,8 @@

     * When this function returns async, use the spa_node_sync operation to

     * wait for completion.

     *

-    * This function must be called from the main thread.

+    * This function must be called from the main thread. The node muse be paused

+    * or the port SPA_IO_Buffers area is NULL when this function is called.

     *

     * \param object an object implementing the interface

     * \param direction a port direction

@@ -566,6 +569,11 @@

     *

     * This function must be called from the main thread.

     *

+    * This function can be called when the node is running and the node

+    * must be prepared to handle changes in io areas while running. This

+    * is normally done by synchronizing the port io updates with the

+    * data processing loop.

+    *

     * \param direction a spa_direction

     * \param port_id a port id

     * \param id the id of the io area, the available ids can be

​

@@ -40,6 +40,7 @@

    { SPA_PARAM_Control, SPA_TYPE_Sequence, SPA_TYPE_INFO_PARAM_ID_BASE "Control", NULL },

    { SPA_PARAM_Latency, SPA_TYPE_OBJECT_ParamLatency, SPA_TYPE_INFO_PARAM_ID_BASE "Latency", NULL },

    { SPA_PARAM_ProcessLatency, SPA_TYPE_OBJECT_ParamProcessLatency, SPA_TYPE_INFO_PARAM_ID_BASE "ProcessLatency", NULL },

+   { SPA_PARAM_Tag, SPA_TYPE_OBJECT_ParamTag, SPA_TYPE_INFO_PARAM_ID_BASE "Tag", NULL },

    { 0, 0, NULL, NULL },

 };

​

@@ -39,6 +39,7 @@

    SPA_PARAM_Control,      /**< Control parameter, a SPA_TYPE_Sequence */

    SPA_PARAM_Latency,      /**< latency reporting, a SPA_TYPE_OBJECT_ParamLatency */

    SPA_PARAM_ProcessLatency,   /**< processing latency, a SPA_TYPE_OBJECT_ParamProcessLatency */

+   SPA_PARAM_Tag,          /**< tag reporting, a SPA_TYPE_OBJECT_ParamTag. Since 0.3.79 */

 };

 /** information about a parameter */

​

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

+/* Simple Plugin API */

+/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */

+/* SPDX-License-Identifier: MIT */

+

+#ifndef SPA_PARAM_TAG_TYPES_H

+#define SPA_PARAM_TAG_TYPES_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/**

+ * \addtogroup spa_param

+ * \{

+ */

+

+#include <spa/utils/enum-types.h>

+#include <spa/param/param-types.h>

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

+

+#define SPA_TYPE_INFO_PARAM_Tag        SPA_TYPE_INFO_PARAM_BASE "Tag"

+#define SPA_TYPE_INFO_PARAM_TAG_BASE   SPA_TYPE_INFO_PARAM_Tag ":"

+

+static const struct spa_type_info spa_type_param_tag = {

+   { SPA_PARAM_TAG_START, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_TAG_BASE, spa_type_param, },

+   { SPA_PARAM_TAG_direction, SPA_TYPE_Id, SPA_TYPE_INFO_PARAM_TAG_BASE "direction", spa_type_direction, },

+   { SPA_PARAM_TAG_info, SPA_TYPE_Struct, SPA_TYPE_INFO_PARAM_TAG_BASE "info", NULL, },

+   { 0, 0, NULL, NULL },

+};

+

+/**

+ * \}

+ */

+

+#ifdef __cplusplus

+}  /* extern "C" */

+#endif

+

+#endif /* SPA_PARAM_TAG_TYPES_H */

​

@@ -0,0 +1,143 @@

+/* Simple Plugin API */

+/* SPDX-FileCopyrightText: Copyright © 2023 Wim Taymans */

+/* SPDX-License-Identifier: MIT */

+

+#ifndef SPA_PARAM_TAG_UTILS_H

+#define SPA_PARAM_TAG_UTILS_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/**

+ * \addtogroup spa_param

+ * \{

+ */

+

+#include <float.h>

+

+#include <spa/utils/dict.h>

+#include <spa/pod/builder.h>

+#include <spa/pod/parser.h>

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

+

+static inline int

+spa_tag_compare(const struct spa_pod *a, const struct spa_pod *b)

+{

+   return ((a == b) || (a && b && SPA_POD_SIZE(a) == SPA_POD_SIZE(b) &&

+       memcmp(a, b, SPA_POD_SIZE(b)) == 0)) ? 0 : 1;

+}

+

+static inline int

+spa_tag_parse(const struct spa_pod *tag, struct spa_tag_info *info, void **state)

+{

+   int res;

+   const struct spa_pod_object *obj = (const struct spa_pod_object*)tag;

+   const struct spa_pod_prop *first, *start, *cur;

+

+   spa_zero(*info);

+

+   if ((res = spa_pod_parse_object(tag,

+           SPA_TYPE_OBJECT_ParamTag, NULL,

+           SPA_PARAM_TAG_direction, SPA_POD_Id(&info->direction))) < 0)

+       return res;

+

+        first = spa_pod_prop_first(&obj->body);

+        start = *state ? spa_pod_prop_next((struct spa_pod_prop*)*state) : first;

+

+   res = 0;

+   for (cur = start; spa_pod_prop_is_inside(&obj->body, obj->pod.size, cur);

+        cur = spa_pod_prop_next(cur)) {

+       if (cur->key == SPA_PARAM_TAG_info) {

+           info->info = &cur->value;

+           *state = (void*)cur;

+           return 1;

+       }

+        }

+   return 0;

+}

+

+static inline int

+spa_tag_info_parse(const struct spa_tag_info *info, struct spa_dict *dict, struct spa_dict_item *items)

+{

+   struct spa_pod_parser prs;

+   uint32_t n, n_items;

+   const char *key, *value;

+   struct spa_pod_frame f1;

+

+   spa_pod_parser_pod(&prs, info->info);

+   if (spa_pod_parser_push_struct(&prs, &f0) < 0 ||

+       spa_pod_parser_get_int(&prs, (int32_t*)&n_items) < 0)

+       return -EINVAL;

+

+   if (items == NULL) {

+       dict->n_items = n_items;

+       return 0;

+   }

+   n_items = SPA_MIN(dict->n_items, n_items);

+

+   for (n = 0; n < n_items; n++) {

+       if (spa_pod_parser_get(&prs,

+               SPA_POD_String(&key),

+               SPA_POD_String(&value),

+               NULL) < 0)

+           break;

+       itemsn.key = key;

+       itemsn.value = value;

+   }

+   dict->items = items;

+   spa_pod_parser_pop(&prs, &f0);

+   return 0;

+}

+

+static inline void

+spa_tag_build_start(struct spa_pod_builder *builder, struct spa_pod_frame *f,

+       uint32_t id, enum spa_direction direction)

+{

+   spa_pod_builder_push_object(builder, f, SPA_TYPE_OBJECT_ParamTag, id);

+   spa_pod_builder_add(builder,

+           SPA_PARAM_TAG_direction, SPA_POD_Id(direction),

+           0);

+}

+

+static inline void

+spa_tag_build_add_info(struct spa_pod_builder *builder, const struct spa_pod *info)

+{

+   spa_pod_builder_add(builder,

+           SPA_PARAM_TAG_info, SPA_POD_Pod(info),

+           0);

+}

+

+static inline void

+spa_tag_build_add_dict(struct spa_pod_builder *builder, const struct spa_dict *dict)

+{

+   uint32_t i, n_items;

+   struct spa_pod_frame f;

+

+   n_items = dict ? dict->n_items : 0;

+

+   spa_pod_builder_prop(builder, SPA_PARAM_TAG_info, SPA_POD_PROP_FLAG_HINT_DICT);

+   spa_pod_builder_push_struct(builder, &f);

+   spa_pod_builder_int(builder, n_items);

+        for (i = 0; i < n_items; i++) {

+       spa_pod_builder_string(builder, dict->itemsi.key);

+       spa_pod_builder_string(builder, dict->itemsi.value);

+   }

+        spa_pod_builder_pop(builder, &f);

+}

+

+static inline struct spa_pod *

+spa_tag_build_end(struct spa_pod_builder *builder, struct spa_pod_frame *f)

+{

+   return (struct spa_pod*)spa_pod_builder_pop(builder, f);

+}

+

+/**

+ * \}

+ */

+

+#ifdef __cplusplus

+}  /* extern "C" */

+#endif

+

+#endif /* SPA_PARAM_TAG_UTILS_H */

​

@@ -0,0 +1,46 @@

+/* Simple Plugin API */

+/* SPDX-FileCopyrightText: Copyright © 2023 Wim Taymans */

+/* SPDX-License-Identifier: MIT */

+

+#ifndef SPA_PARAM_TAG_H

+#define SPA_PARAM_TAG_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/**

+ * \addtogroup spa_param

+ * \{

+ */

+

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

+

+/** properties for SPA_TYPE_OBJECT_ParamTag */

+enum spa_param_tag {

+   SPA_PARAM_TAG_START,

+   SPA_PARAM_TAG_direction,        /**< direction, input/output (Id enum spa_direction) */

+   SPA_PARAM_TAG_info,         /**< Struct(

+                         *      Int: n_items

+                         *      (String: key

+                         *       String: value)*

+                         *  ) */

+};

+

+/** helper structure for managing tag objects */

+struct spa_tag_info {

+   enum spa_direction direction;

+   const struct spa_pod *info;

+};

+

+#define SPA_TAG_INFO(dir,...) ((struct spa_tag_info) { .direction = (dir), ## __VA_ARGS__ })

+

+/**

+ * \}

+ */

+

+#ifdef __cplusplus

+}  /* extern "C" */

+#endif

+

+#endif /* SPA_PARAM_TAG_H */

​

@@ -14,5 +14,6 @@

 #include <spa/param/profiler-types.h>

 #include <spa/param/profile-types.h>

 #include <spa/param/route-types.h>

+#include <spa/param/tag-types.h>

 #endif /* SPA_PARAM_TYPE_INFO_H */

​

@@ -90,8 +90,10 @@

 #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 */

-#define SPA_NAME_API_ALSA_COMPRESS_OFFLOAD_SINK    "api.alsa.compress.offload.sink"    /**< an alsa Node interface for

-                                             * compressed audio */

+#define SPA_NAME_API_ALSA_COMPRESS_OFFLOAD_DEVICE  "api.alsa.compress.offload.device"  /**< an alsa Device interface for

+                                                 * compressed audio */

+#define SPA_NAME_API_ALSA_COMPRESS_OFFLOAD_SINK        "api.alsa.compress.offload.sink"    /**< an alsa Node interface for

+                                                 * compressed audio */

 /** keys for bluez5 factory names */

 #define SPA_NAME_API_BLUEZ5_ENUM_DBUS  "api.bluez5.enum.dbus"      /**< a dbus Device interface */

​

@@ -17,23 +17,23 @@

    uint64_t begin;

    unsigned burst;

    unsigned n_printed;

-   unsigned n_missed;

+   unsigned n_suppressed;

 };

 static inline int spa_ratelimit_test(struct spa_ratelimit *r, uint64_t now)

 {

-   unsigned missed = 0;

+   unsigned suppressed = 0;

    if (r->begin + r->interval < now) {

-       missed = r->n_missed;

+       suppressed = r->n_suppressed;

        r->begin = now;

        r->n_printed = 0;

-       r->n_missed = 0;

+       r->n_suppressed = 0;

    } else if (r->n_printed >= r->burst) {

-       r->n_missed++;

+       r->n_suppressed++;

        return -1;

    }

    r->n_printed++;

-   return missed;

+   return suppressed;

 }

 #ifdef __cplusplus

​

@@ -83,6 +83,7 @@

    { SPA_TYPE_OBJECT_Profiler, SPA_TYPE_Object, SPA_TYPE_INFO_Profiler, spa_type_profiler },

    { SPA_TYPE_OBJECT_ParamLatency, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_Latency, spa_type_param_latency },

    { SPA_TYPE_OBJECT_ParamProcessLatency, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_ProcessLatency, spa_type_param_process_latency },

+   { SPA_TYPE_OBJECT_ParamTag, SPA_TYPE_Object, SPA_TYPE_INFO_PARAM_Tag, spa_type_param_tag },

    { 0, 0, NULL, NULL }

 };

​

@@ -78,6 +78,7 @@

    SPA_TYPE_OBJECT_Profiler,

    SPA_TYPE_OBJECT_ParamLatency,

    SPA_TYPE_OBJECT_ParamProcessLatency,

+   SPA_TYPE_OBJECT_ParamTag,

    _SPA_TYPE_OBJECT_LAST,          /**< not part of ABI */

    /* vendor extensions */

​

@@ -13,9 +13,7 @@

 #include <spa/utils/json.h>

 #include <spa/support/plugin.h>

-#include <webrtc/modules/audio_processing/include/audio_processing.h>

-#include <webrtc/modules/interface/module_common_types.h>

-#include <webrtc/system_wrappers/include/trace.h>

+#include <modules/audio_processing/include/audio_processing.h>

 struct impl_data {

    struct spa_handle handle;

@@ -41,53 +39,6 @@

    return default_value;

 }

-

-/*  f0 f1 f2  */

-static int parse_point(struct spa_json *it, float (&f)3)

-{

-   struct spa_json arr;

-   int i, res;

-

-   if (spa_json_enter_array(it, &arr) <= 0)

-       return -EINVAL;

-

-   for (i = 0; i < 3; i++) {

-       if ((res = spa_json_get_float(&arr, &fi)) <= 0)

-           return -EINVAL;

-   }

-   return 0;

-}

-

-/*  point1 point2 ...  */

-static int parse_mic_geometry(struct impl_data *impl, const char *mic_geometry,

-       std::vector<webrtc::Point>& geometry)

-{

-   int res;

-   size_t i;

-   struct spa_json it2;

-

-   spa_json_init(&it0, mic_geometry, strlen(mic_geometry));

-   if (spa_json_enter_array(&it0, &it1) <= 0) {

-       spa_log_error(impl->log, "Error: webrtc.mic-geometry expects an array");

-       return -EINVAL;

-   }

-

-   for (i = 0; i < geometry.size(); i++) {

-       float f3;

-

-       if ((res = parse_point(&it1, f)) < 0) {

-           spa_log_error(impl->log, "Error: can't parse webrtc.mic-geometry points: %d", res);

-           return res;

-       }

-

-       spa_log_info(impl->log, "mic %zd position: (%g %g %g)", i, f0, f1, f2);

-       geometryi.c0 = f0;

-       geometryi.c1 = f1;

-       geometryi.c2 = f2;

-   }

-   return 0;

-}

-

 static int webrtc_init2(void *object, const struct spa_dict *args,

        struct spa_audio_info_raw *rec_info, struct spa_audio_info_raw *out_info,

        struct spa_audio_info_raw *play_info)

@@ -95,69 +46,33 @@

    auto impl = static_cast<struct impl_data*>(object);

    int res;

-   bool extended_filter = webrtc_get_spa_bool(args, "webrtc.extended_filter", true);

-   bool delay_agnostic = webrtc_get_spa_bool(args, "webrtc.delay_agnostic", true);

    bool high_pass_filter = webrtc_get_spa_bool(args, "webrtc.high_pass_filter", true);

    bool noise_suppression = webrtc_get_spa_bool(args, "webrtc.noise_suppression", true);

+   bool transient_suppression = webrtc_get_spa_bool(args, "webrtc.transient_suppression", true);

    bool voice_detection = webrtc_get_spa_bool(args, "webrtc.voice_detection", true);

    // Note: AGC seems to mess up with Agnostic Delay Detection, especially with speech,

    // result in very poor performance, disable by default

    bool gain_control = webrtc_get_spa_bool(args, "webrtc.gain_control", false);

-   // Disable experimental flags by default

-   bool experimental_agc = webrtc_get_spa_bool(args, "webrtc.experimental_agc", false);

-   bool experimental_ns = webrtc_get_spa_bool(args, "webrtc.experimental_ns", false);

-

-   bool beamforming = webrtc_get_spa_bool(args, "webrtc.beamforming", false);

-

    // FIXME: Intelligibility enhancer is not currently supported

    // This filter will modify playback buffer (when calling ProcessReverseStream), but now

    // playback buffer modifications are discarded.

-   webrtc::Config config;

-   config.Set<webrtc::ExtendedFilter>(new webrtc::ExtendedFilter(extended_filter));

-   config.Set<webrtc::DelayAgnostic>(new webrtc::DelayAgnostic(delay_agnostic));

-   config.Set<webrtc::ExperimentalAgc>(new webrtc::ExperimentalAgc(experimental_agc));

-   config.Set<webrtc::ExperimentalNs>(new webrtc::ExperimentalNs(experimental_ns));

-

-   if (beamforming) {

-       std::vector<webrtc::Point> geometry(rec_info->channels);

-       const char *mic_geometry, *target_direction;

-

-       /* The beamformer gives a single mono channel */

-       out_info->channels = 1;

-       out_info->position0 = SPA_AUDIO_CHANNEL_MONO;

-

-       if ((mic_geometry = spa_dict_lookup(args, "webrtc.mic-geometry")) == NULL) {

-           spa_log_error(impl->log, "Error: webrtc.beamforming requires webrtc.mic-geometry");

-           return -EINVAL;

-       }

-

-       if ((res = parse_mic_geometry(impl, mic_geometry, geometry)) < 0)

-           return res;

-

-       if ((target_direction = spa_dict_lookup(args, "webrtc.target-direction")) != NULL) {

-           webrtc::SphericalPointf direction(0.0f, 0.0f, 0.0f);

-           struct spa_json it;

-           float f3;

-

-           spa_json_init(&it, target_direction, strlen(target_direction));

-           if (parse_point(&it, f) < 0) {

-               spa_log_error(impl->log, "Error: can't parse target-direction %s",

-                       target_direction);

-               return -EINVAL;

-           }

-

-           direction.s0 = f0;

-           direction.s1 = f1;

-           direction.s2 = f2;

-

-           config.Set<webrtc::Beamforming>(new webrtc::Beamforming(true, geometry, direction));

-       } else {

-           config.Set<webrtc::Beamforming>(new webrtc::Beamforming(true, geometry));

-       }

-   }

+   webrtc::AudioProcessing::Config config;

+   config.echo_canceller.enabled = true;

+   // FIXME: Example code enables both gain controllers, but that seems sus

+   config.gain_controller1.enabled = gain_control;

+   config.gain_controller1.mode = webrtc::AudioProcessing::Config::GainController1::Mode::kAdaptiveDigital;

+   config.gain_controller1.analog_level_minimum = 0;

+   config.gain_controller1.analog_level_maximum = 255;

+   config.gain_controller2.enabled = gain_control;

+   config.high_pass_filter.enabled = high_pass_filter;

+   config.noise_suppression.enabled = noise_suppression;

+   config.noise_suppression.level = webrtc::AudioProcessing::Config::NoiseSuppression::kHigh;

+   // FIXME: expose pre/postamp gain

+   config.transient_suppression.enabled = transient_suppression;

+   config.voice_detection.enabled = voice_detection;

    webrtc::ProcessingConfig pconfig = {{

        webrtc::StreamConfig(rec_info->rate, rec_info->channels, false), /* input stream */

@@ -166,26 +81,15 @@

        webrtc::StreamConfig(play_info->rate, play_info->channels, false), /* reverse output stream */

    }};

-   auto apm = std::unique_ptr<webrtc::AudioProcessing>(webrtc::AudioProcessing::Create(config));

+   auto apm = std::unique_ptr<webrtc::AudioProcessing>(webrtc::AudioProcessingBuilder().Create());

+

+   apm->ApplyConfig(config);

+

    if ((res = apm->Initialize(pconfig)) != webrtc::AudioProcessing::kNoError) {

        spa_log_error(impl->log, "Error initialising webrtc audio processing module: %d", res);

        return -EINVAL;

    }

-   apm->high_pass_filter()->Enable(high_pass_filter);

-   // Always disable drift compensation since PipeWire will already do

-   // drift compensation on all sinks and sources linked to this echo-canceler

-   apm->echo_cancellation()->enable_drift_compensation(false);

-   apm->echo_cancellation()->Enable(true);

-   // TODO: wire up supression levels to args

-   apm->echo_cancellation()->set_suppression_level(webrtc::EchoCancellation::kHighSuppression);

-   apm->noise_suppression()->set_level(webrtc::NoiseSuppression::kHigh);

-   apm->noise_suppression()->Enable(noise_suppression);

-   apm->voice_detection()->Enable(voice_detection);

-   // TODO: wire up AGC parameters to args

-   apm->gain_control()->set_analog_level_limits(0, 255);

-   apm->gain_control()->set_mode(webrtc::GainControl::kAdaptiveDigital);

-   apm->gain_control()->Enable(gain_control);

    impl->apm = std::move(apm);

    impl->rec_info = *rec_info;

    impl->out_info = *out_info;

​

@@ -83,7 +83,7 @@

 static inline pa_volume_t pa_sw_volume_from_dB(double dB)

 {

-    if (isinf(dB) < 0 || dB <= PA_DECIBEL_MININFTY)

+    if (dB == -INFINITY || dB <= PA_DECIBEL_MININFTY)

         return PA_VOLUME_MUTED;

     return pa_sw_volume_from_linear(pa_volume_dB_to_linear(dB));

 }

​

@@ -0,0 +1,578 @@