From 9dc20765e115a942ecad4dce900aec77b91ec8c1 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sun, 10 Aug 2025 19:31:22 -0400
Subject: [PATCH 01/26] Add stream for control - 1

---
 src/modules/module-filter-chain.c | 40 +++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 6c2f16200..8381e18a1 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1176,6 +1176,10 @@ struct impl {
 	struct spa_hook playback_listener;
 	struct spa_audio_info_raw playback_info;
 
+	struct pw_properties *control_props;
+	struct pw_stream *control;
+	struct spa_hook control_listener;
+
 	struct spa_audio_info_raw info;
 
 	struct spa_io_position *position;
@@ -1219,6 +1223,23 @@ static void capture_process(void *d)
 	}
 }
 
+static void control_process(void *d)
+{
+	struct impl *impl = d;
+	int res;
+	if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
+		pw_log_debug("playback trigger error: %s", spa_strerror(res));
+		while (true) {
+			struct pw_buffer *t;
+			if ((t = pw_stream_dequeue_buffer(impl->control)) == NULL)
+				break;
+			/* playback part is not ready, consume, discard and recycle
+			 * the capture buffers */
+			pw_stream_queue_buffer(impl->control, t);
+		}
+	}
+}
+
 static void playback_process(void *d)
 {
 	struct impl *impl = d;
@@ -1578,6 +1599,15 @@ static const struct pw_stream_events out_stream_events = {
 	.param_changed = playback_param_changed,
 };
 
+static const struct pw_stream_events control_stream_events = {
+	PW_VERSION_STREAM_EVENTS,
+	.destroy = NULL,
+	.process = control_process,
+	.io_changed = NULL,
+	.state_changed = NULL,
+	.param_changed = NULL,
+};
+
 static int setup_streams(struct impl *impl)
 {
 	int res;
@@ -1587,6 +1617,16 @@ static int setup_streams(struct impl *impl)
 	struct spa_pod_dynamic_builder b;
 	struct spa_filter_graph *graph = impl->graph;
 
+	impl->control = pw_stream_new(impl->core,
+			"filter control", impl->capture_props);
+	impl->control_props = NULL;
+	if (impl->control == NULL)
+		return -errno;
+
+	pw_stream_add_listener(impl->control,
+			&impl->control_listener,
+			&control_stream_events, impl);
+
 	impl->capture = pw_stream_new(impl->core,
 			"filter capture", impl->capture_props);
 	impl->capture_props = NULL;

From 61a570149322baef6d3e9de1e7d3fa5eaaa0493a Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Mon, 11 Aug 2025 08:05:44 -0400
Subject: [PATCH 02/26] Add stream for control - 2

---
 src/modules/module-filter-chain.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 8381e18a1..70224caec 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1243,7 +1243,7 @@ static void control_process(void *d)
 static void playback_process(void *d)
 {
 	struct impl *impl = d;
-	struct pw_buffer *in, *out;
+	struct pw_buffer *in, *out, *control;
 	uint32_t i, data_size = 0;
 	int32_t stride = 0;
 	struct spa_data *bd;
@@ -1262,6 +1262,18 @@ static void playback_process(void *d)
 	if (in == NULL)
 		pw_log_debug("%p: out of capture buffers: %m", impl);
 
+	control = NULL;
+	while (true) {
+		struct pw_buffer *t;
+		if ((t = pw_stream_dequeue_buffer(impl->control)) == NULL)
+			break;
+		if (control)
+			pw_stream_queue_buffer(impl->control, control);
+		control = t;
+	}
+	if (control == NULL)
+		pw_log_debug("%p: out of control buffers: %m", impl);
+
 	if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
 		pw_log_debug("%p: out of playback buffers: %m", impl);
 
@@ -1309,6 +1321,8 @@ done:
 		pw_stream_queue_buffer(impl->capture, in);
 	if (out != NULL)
 		pw_stream_queue_buffer(impl->playback, out);
+	if (control != NULL)
+		pw_stream_queue_buffer(impl->control, control);
 }
 
 static int activate_graph(struct impl *impl)

From 1c53fdbfc0b5723510c2301d4b236acbd4087060 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Fri, 15 Aug 2025 19:28:16 -0400
Subject: [PATCH 03/26] first working version

---
 src/modules/module-filter-chain.c | 118 ++++++++++++++++++++++--------
 1 file changed, 89 insertions(+), 29 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 70224caec..9491d628f 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -21,6 +21,9 @@
 
 #include <pipewire/impl.h>
 
+#include "spa/control/control.h"
+#include "spa/param/props.h"
+
 #define NAME "filter-chain"
 
 PW_LOG_TOPIC_STATIC(mod_topic, "mod." NAME);
@@ -1223,27 +1226,78 @@ static void capture_process(void *d)
 	}
 }
 
+static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
+{
+  struct impl *impl = user_data;
+  const struct spa_pod *props = data;
+  if (props == NULL) {
+    fprintf(stdout, "no props\n");
+  }
+
+  //spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_INPUT, props);
+  spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
+
+  /* props was allocated with spa_pod_copy before invoking */
+  return 0;
+}
+
 static void control_process(void *d)
 {
+  fprintf(stdout, "control process\n");
+
 	struct impl *impl = d;
-	int res;
-	if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
-		pw_log_debug("playback trigger error: %s", spa_strerror(res));
-		while (true) {
-			struct pw_buffer *t;
-			if ((t = pw_stream_dequeue_buffer(impl->control)) == NULL)
-				break;
-			/* playback part is not ready, consume, discard and recycle
-			 * the capture buffers */
-			pw_stream_queue_buffer(impl->control, t);
-		}
-	}
+
+  struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
+  /*
+  while (true) {
+    struct pw_buffer *t;
+    if ((t = pw_stream_dequeue_buffer(impl->control)) == NULL)
+      break;
+    if (control)
+      pw_stream_queue_buffer(impl->control, control);
+    control = t;
+  }
+  */
+  if (control == NULL) {
+    fprintf(stdout, "out of control buffers\n");
+    goto done;
+  }
+  fprintf(stdout, "\n\nprocessing buffer\n");
+  if (control->buffer->n_datas > 0) {
+    fprintf(stdout, "creating pod\n");
+    struct spa_pod *pod = spa_pod_from_data(
+      control->buffer->datas[0].data,
+      control->buffer->datas[0].maxsize,
+      control->buffer->datas[0].chunk->offset,
+      control->buffer->datas[0].chunk->size);
+
+    if (spa_pod_is_sequence(pod)) {
+      fprintf(stdout, "processing sequence\n");
+      struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
+
+      struct spa_pod_control *pod_control;
+      SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
+        fprintf(stdout, "processing sequence item\n");
+        if (pod_control->type == SPA_CONTROL_Properties) {
+          fprintf(stdout, "processing properties\n");
+            struct pw_loop *loop = pw_context_get_main_loop(impl->context);
+            pw_loop_invoke(loop, apply_props, 0, &pod_control->value, SPA_POD_SIZE(&pod_control->value), false, impl);
+        } else if (pod_control->type != SPA_CONTROL_OSC) {}
+      }
+    } else {
+      fprintf(stdout, "not a sequence\n");
+    }
+  }
+
+  done:
+    pw_stream_queue_buffer(impl->control, control);
 }
 
 static void playback_process(void *d)
 {
+  pw_log_error("playback process");
 	struct impl *impl = d;
-	struct pw_buffer *in, *out, *control;
+	struct pw_buffer *in, *out;
 	uint32_t i, data_size = 0;
 	int32_t stride = 0;
 	struct spa_data *bd;
@@ -1262,18 +1316,6 @@ static void playback_process(void *d)
 	if (in == NULL)
 		pw_log_debug("%p: out of capture buffers: %m", impl);
 
-	control = NULL;
-	while (true) {
-		struct pw_buffer *t;
-		if ((t = pw_stream_dequeue_buffer(impl->control)) == NULL)
-			break;
-		if (control)
-			pw_stream_queue_buffer(impl->control, control);
-		control = t;
-	}
-	if (control == NULL)
-		pw_log_debug("%p: out of control buffers: %m", impl);
-
 	if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
 		pw_log_debug("%p: out of playback buffers: %m", impl);
 
@@ -1321,8 +1363,6 @@ done:
 		pw_stream_queue_buffer(impl->capture, in);
 	if (out != NULL)
 		pw_stream_queue_buffer(impl->playback, out);
-	if (control != NULL)
-		pw_stream_queue_buffer(impl->control, control);
 }
 
 static int activate_graph(struct impl *impl)
@@ -1632,7 +1672,7 @@ static int setup_streams(struct impl *impl)
 	struct spa_filter_graph *graph = impl->graph;
 
 	impl->control = pw_stream_new(impl->core,
-			"filter control", impl->capture_props);
+			"filter control", impl->control_props);
 	impl->control_props = NULL;
 	if (impl->control == NULL)
 		return -errno;
@@ -1641,6 +1681,24 @@ static int setup_streams(struct impl *impl)
 			&impl->control_listener,
 			&control_stream_events, impl);
 
+  uint8_t buffer[256];
+  struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+  const struct spa_pod *param[1];
+
+  param[0] = spa_pod_builder_add_object(&bt,
+      SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
+      SPA_FORMAT_mediaType,    SPA_POD_Id(SPA_MEDIA_TYPE_application),
+      SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
+  );
+
+  pw_stream_connect(impl->control,
+      PW_DIRECTION_INPUT,
+      PW_ID_ANY,
+      PW_STREAM_FLAG_AUTOCONNECT |
+      PW_STREAM_FLAG_MAP_BUFFERS |
+      PW_STREAM_FLAG_RT_PROCESS,
+      param, 1);
+
 	impl->capture = pw_stream_new(impl->core,
 			"filter capture", impl->capture_props);
 	impl->capture_props = NULL;
@@ -1908,6 +1966,8 @@ static void copy_props(struct impl *impl, struct pw_properties *props, const cha
 SPA_EXPORT
 int pipewire__module_init(struct pw_impl_module *module, const char *args)
 {
+  fprintf(stdout, "module init reached\n");
+
 	struct pw_context *context = pw_impl_module_get_context(module);
 	const struct pw_properties *p;
 	struct pw_properties *props;
@@ -1924,7 +1984,7 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 	if (impl == NULL)
 		return -errno;
 
-	pw_log_debug("module %p: new %s", impl, args);
+	pw_log_debug("module fk1 %p: new %s", impl, args);
 
 	if (args)
 		props = pw_properties_new_string(args);

From 0a6d1ce7ef0902b4b27d9997c86ab4077f2ad83b Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Fri, 15 Aug 2025 19:38:17 -0400
Subject: [PATCH 04/26] cleanup

---
 src/modules/module-filter-chain.c | 34 ++++---------------------------
 1 file changed, 4 insertions(+), 30 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 9491d628f..e68a3fec9 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1228,16 +1228,8 @@ static void capture_process(void *d)
 
 static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
 {
-  struct impl *impl = user_data;
   const struct spa_pod *props = data;
-  if (props == NULL) {
-    fprintf(stdout, "no props\n");
-  }
-
-  //spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_INPUT, props);
   spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
-
-  /* props was allocated with spa_pod_copy before invoking */
   return 0;
 }
 
@@ -1248,23 +1240,9 @@ static void control_process(void *d)
 	struct impl *impl = d;
 
   struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
-  /*
-  while (true) {
-    struct pw_buffer *t;
-    if ((t = pw_stream_dequeue_buffer(impl->control)) == NULL)
-      break;
-    if (control)
-      pw_stream_queue_buffer(impl->control, control);
-    control = t;
-  }
-  */
-  if (control == NULL) {
-    fprintf(stdout, "out of control buffers\n");
+  if (control == NULL)
     goto done;
-  }
-  fprintf(stdout, "\n\nprocessing buffer\n");
   if (control->buffer->n_datas > 0) {
-    fprintf(stdout, "creating pod\n");
     struct spa_pod *pod = spa_pod_from_data(
       control->buffer->datas[0].data,
       control->buffer->datas[0].maxsize,
@@ -1272,20 +1250,16 @@ static void control_process(void *d)
       control->buffer->datas[0].chunk->size);
 
     if (spa_pod_is_sequence(pod)) {
-      fprintf(stdout, "processing sequence\n");
       struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
 
       struct spa_pod_control *pod_control;
       SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
-        fprintf(stdout, "processing sequence item\n");
         if (pod_control->type == SPA_CONTROL_Properties) {
-          fprintf(stdout, "processing properties\n");
             struct pw_loop *loop = pw_context_get_main_loop(impl->context);
-            pw_loop_invoke(loop, apply_props, 0, &pod_control->value, SPA_POD_SIZE(&pod_control->value), false, impl);
-        } else if (pod_control->type != SPA_CONTROL_OSC) {}
+            pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
+              SPA_POD_SIZE(&pod_control->value), false, impl);
+        }
       }
-    } else {
-      fprintf(stdout, "not a sequence\n");
     }
   }
 

From 8e2d02c08c77c82db28a26a03ab278f90eccd687 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Fri, 15 Aug 2025 19:47:53 -0400
Subject: [PATCH 05/26] cleanup

---
 src/modules/module-filter-chain.c | 36 +++++++++++++++++++++++++------
 1 file changed, 29 insertions(+), 7 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index e68a3fec9..ed564583a 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1228,6 +1228,7 @@ static void capture_process(void *d)
 
 static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
 {
+  const struct impl *impl = user_data;
   const struct spa_pod *props = data;
   spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
   return 0;
@@ -1235,8 +1236,6 @@ static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const vo
 
 static void control_process(void *d)
 {
-  fprintf(stdout, "control process\n");
-
 	struct impl *impl = d;
 
   struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
@@ -1269,7 +1268,6 @@ static void control_process(void *d)
 
 static void playback_process(void *d)
 {
-  pw_log_error("playback process");
 	struct impl *impl = d;
 	struct pw_buffer *in, *out;
 	uint32_t i, data_size = 0;
@@ -1627,12 +1625,38 @@ static const struct pw_stream_events out_stream_events = {
 	.param_changed = playback_param_changed,
 };
 
+static void control_destroy(void *d)
+{
+	struct impl *impl = d;
+	spa_hook_remove(&impl->control_listener);
+	impl->control = NULL;
+}
+
+static void control_state_changed(void *data, enum pw_stream_state old,
+    enum pw_stream_state state, const char *error)
+{
+  struct impl *impl = data;
+
+  switch (state) {
+  case PW_STREAM_STATE_PAUSED:
+    pw_stream_flush(impl->control, false);
+    break;
+  case PW_STREAM_STATE_ERROR:
+    pw_log_info("module %p: error: %s", impl, error);
+    break;
+  case PW_STREAM_STATE_STREAMING:
+  default:
+    break;
+  }
+  return;
+}
+
 static const struct pw_stream_events control_stream_events = {
 	PW_VERSION_STREAM_EVENTS,
-	.destroy = NULL,
+	.destroy = control_destroy,
 	.process = control_process,
 	.io_changed = NULL,
-	.state_changed = NULL,
+	.state_changed = control_state_changed,
 	.param_changed = NULL,
 };
 
@@ -1940,8 +1964,6 @@ static void copy_props(struct impl *impl, struct pw_properties *props, const cha
 SPA_EXPORT
 int pipewire__module_init(struct pw_impl_module *module, const char *args)
 {
-  fprintf(stdout, "module init reached\n");
-
 	struct pw_context *context = pw_impl_module_get_context(module);
 	const struct pw_properties *p;
 	struct pw_properties *props;

From 6a154a0be0a6155990293973f0dfb9f577021b4a Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Fri, 15 Aug 2025 19:52:25 -0400
Subject: [PATCH 06/26] cleanup

---
 src/modules/module-filter-chain.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index ed564583a..70d81d1be 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1980,7 +1980,7 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 	if (impl == NULL)
 		return -errno;
 
-	pw_log_debug("module fk1 %p: new %s", impl, args);
+	pw_log_debug("module %p: new %s", impl, args);
 
 	if (args)
 		props = pw_properties_new_string(args);

From 4c65f04337625708879b4766122cee481c2d0335 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Fri, 15 Aug 2025 20:36:26 -0400
Subject: [PATCH 07/26] Attribute in config to enable control port. Disable by
 default

---
 src/modules/module-filter-chain.c | 61 +++++++++++++++++++------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 70d81d1be..85bcccbde 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1182,6 +1182,7 @@ struct impl {
 	struct pw_properties *control_props;
 	struct pw_stream *control;
 	struct spa_hook control_listener;
+  bool control_stream_active;
 
 	struct spa_audio_info_raw info;
 
@@ -1669,33 +1670,35 @@ static int setup_streams(struct impl *impl)
 	struct spa_pod_dynamic_builder b;
 	struct spa_filter_graph *graph = impl->graph;
 
-	impl->control = pw_stream_new(impl->core,
-			"filter control", impl->control_props);
-	impl->control_props = NULL;
-	if (impl->control == NULL)
-		return -errno;
+  if (impl->control_stream_active) {
+    impl->control = pw_stream_new(impl->core,
+        "filter control", impl->control_props);
+    impl->control_props = NULL;
+    if (impl->control == NULL)
+      return -errno;
 
-	pw_stream_add_listener(impl->control,
-			&impl->control_listener,
-			&control_stream_events, impl);
+    pw_stream_add_listener(impl->control,
+        &impl->control_listener,
+        &control_stream_events, impl);
 
-  uint8_t buffer[256];
-  struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
-  const struct spa_pod *param[1];
+    uint8_t buffer[256];
+    struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+    const struct spa_pod *param[1];
 
-  param[0] = spa_pod_builder_add_object(&bt,
-      SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
-      SPA_FORMAT_mediaType,    SPA_POD_Id(SPA_MEDIA_TYPE_application),
-      SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
-  );
+    param[0] = spa_pod_builder_add_object(&bt,
+        SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
+        SPA_FORMAT_mediaType,    SPA_POD_Id(SPA_MEDIA_TYPE_application),
+        SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
+    );
 
-  pw_stream_connect(impl->control,
-      PW_DIRECTION_INPUT,
-      PW_ID_ANY,
-      PW_STREAM_FLAG_AUTOCONNECT |
-      PW_STREAM_FLAG_MAP_BUFFERS |
-      PW_STREAM_FLAG_RT_PROCESS,
-      param, 1);
+    pw_stream_connect(impl->control,
+        PW_DIRECTION_INPUT,
+        PW_ID_ANY,
+        PW_STREAM_FLAG_AUTOCONNECT |
+        PW_STREAM_FLAG_MAP_BUFFERS |
+        PW_STREAM_FLAG_RT_PROCESS,
+        param, 1);
+  }
 
 	impl->capture = pw_stream_new(impl->core,
 			"filter capture", impl->capture_props);
@@ -2119,7 +2122,17 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 			&impl->core_listener,
 			&core_events, impl);
 
-	setup_streams(impl);
+  if (pw_properties_get(props, "controlStream.enabled") == NULL) {
+    impl->control_stream_active = false;
+  } else if (strcmp(pw_properties_get(props, "controlStream.enabled"), "true")
+    == 0) {
+    impl->control_stream_active = true;
+  } else if (strcmp(pw_properties_get(props, "controlStream.enabled"), "false")
+    == 0) {
+    impl->control_stream_active = false;
+  }
+
+  setup_streams(impl);
 
 	pw_impl_module_add_listener(module, &impl->module_listener, &module_events, impl);
 

From 255bf4cdb4fc8953d50adb80e78950ca96a078d0 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sat, 16 Aug 2025 21:10:06 -0400
Subject: [PATCH 08/26] Configure the control stream like the other streams
 using control.props

---
 src/modules/module-filter-chain.c | 1445 ++++++++++++++---------------
 1 file changed, 680 insertions(+), 765 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 85bcccbde..108a6f35b 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1106,38 +1106,26 @@ extern struct spa_handle_factory spa_filter_graph_factory;
  *\endcode
  */
 static const struct spa_dict_item module_props[] = {
-	{ PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
-	{ PW_KEY_MODULE_DESCRIPTION, "Create filter chain streams" },
-	{ PW_KEY_MODULE_USAGE, " ( remote.name=<remote> ) "
-				"( node.latency=<latency as fraction> ) "
-				"( node.description=<description of the nodes> ) "
-				"( audio.rate=<sample rate> ) "
-				"( audio.channels=<number of channels> ) "
-				"( audio.position=<channel map> ) "
-				"filter.graph = [ "
-				"    nodes = [ "
-				"        { "
-				"          type = <ladspa | lv2 | builtin | sofa> "
-				"          name = <name> "
-				"          plugin = <plugin> "
-				"          label = <label> "
-				"          config = { "
-				"             <configkey> = <value> ... "
-				"          } "
-				"          control = { "
-				"             <controlname|controlindex> = <value> ... "
-				"          } "
-				"        } "
-				"    ] "
-				"    links = [ "
-				"        { output = <portname> input = <portname> } ... "
-				"    ] "
-				"    inputs = [ <portname> ... ] "
-				"    outputs = [ <portname> ... ] "
-				"] "
-				"( capture.props=<properties> ) "
-				"( playback.props=<properties> ) " },
-	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
+  {PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>"},
+  {PW_KEY_MODULE_DESCRIPTION, "Create filter chain streams"},
+  {
+    PW_KEY_MODULE_USAGE,
+    " ( remote.name=<remote> ) " "( node.latency=<latency as fraction> ) "
+    "( node.description=<description of the nodes> ) "
+    "( audio.rate=<sample rate> ) " "( audio.channels=<number of channels> ) "
+    "( audio.position=<channel map> ) " "filter.graph = [ " "    nodes = [ "
+    "        { " "          type = <ladspa | lv2 | builtin | sofa> "
+    "          name = <name> " "          plugin = <plugin> "
+    "          label = <label> " "          config = { "
+    "             <configkey> = <value> ... " "          } "
+    "          control = { "
+    "             <controlname|controlindex> = <value> ... " "          } "
+    "        } " "    ] " "    links = [ "
+    "        { output = <portname> input = <portname> } ... " "    ] "
+    "    inputs = [ <portname> ... ] " "    outputs = [ <portname> ... ] " "] "
+    "( capture.props=<properties> ) " "( playback.props=<properties> ) "
+  },
+  {PW_KEY_MODULE_VERSION, PACKAGE_VERSION},
 };
 
 #include <unistd.h>
@@ -1158,989 +1146,916 @@ static const struct spa_dict_item module_props[] = {
 #define DEFAULT_RATE	48000
 
 struct impl {
-	struct pw_context *context;
+  struct pw_context *context;
 
-	struct pw_impl_module *module;
-	struct pw_properties *props;
+  struct pw_impl_module *module;
+  struct pw_properties *props;
 
-	struct spa_hook module_listener;
+  struct spa_hook module_listener;
 
-	struct pw_core *core;
-	struct spa_hook core_proxy_listener;
-	struct spa_hook core_listener;
+  struct pw_core *core;
+  struct spa_hook core_proxy_listener;
+  struct spa_hook core_listener;
 
-	struct pw_properties *capture_props;
-	struct pw_stream *capture;
-	struct spa_hook capture_listener;
-	struct spa_audio_info_raw capture_info;
+  struct pw_properties *capture_props;
+  struct pw_stream *capture;
+  struct spa_hook capture_listener;
+  struct spa_audio_info_raw capture_info;
 
-	struct pw_properties *playback_props;
-	struct pw_stream *playback;
-	struct spa_hook playback_listener;
-	struct spa_audio_info_raw playback_info;
+  struct pw_properties *playback_props;
+  struct pw_stream *playback;
+  struct spa_hook playback_listener;
+  struct spa_audio_info_raw playback_info;
 
-	struct pw_properties *control_props;
-	struct pw_stream *control;
-	struct spa_hook control_listener;
+  struct pw_properties *control_props;
+  struct pw_stream *control;
+  struct spa_hook control_listener;
   bool control_stream_active;
 
-	struct spa_audio_info_raw info;
+  struct spa_audio_info_raw info;
 
-	struct spa_io_position *position;
+  struct spa_io_position *position;
 
-	unsigned int do_disconnect:1;
+  unsigned int do_disconnect : 1;
 
-	long unsigned rate;
+  long unsigned rate;
 
-	struct spa_handle *handle;
-	struct spa_filter_graph *graph;
-	struct spa_hook graph_listener;
-	uint32_t n_inputs;
-	uint32_t n_outputs;
-	bool graph_active;
+  struct spa_handle *handle;
+  struct spa_filter_graph *graph;
+  struct spa_hook graph_listener;
+  uint32_t n_inputs;
+  uint32_t n_outputs;
+  bool graph_active;
 
-	struct spa_latency_info latency[2];
-	struct spa_process_latency_info process_latency;
+  struct spa_latency_info latency[2];
+  struct spa_process_latency_info process_latency;
 };
 
-static void capture_destroy(void *d)
-{
-	struct impl *impl = d;
-	spa_hook_remove(&impl->capture_listener);
-	impl->capture = NULL;
+static void capture_destroy(void *d) {
+  struct impl *impl = d;
+  spa_hook_remove(&impl->capture_listener);
+  impl->capture = NULL;
 }
 
-static void capture_process(void *d)
-{
-	struct impl *impl = d;
-	int res;
-	if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
-		pw_log_debug("playback trigger error: %s", spa_strerror(res));
-		while (true) {
-			struct pw_buffer *t;
-			if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL)
-				break;
-			/* playback part is not ready, consume, discard and recycle
-			 * the capture buffers */
-			pw_stream_queue_buffer(impl->capture, t);
-		}
-	}
+static void capture_process(void *d) {
+  struct impl *impl = d;
+  int res;
+  if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
+    pw_log_debug("playback trigger error: %s", spa_strerror(res));
+    while (true) {
+      struct pw_buffer *t;
+      if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL) break;
+      /* playback part is not ready, consume, discard and recycle
+       * the capture buffers */
+      pw_stream_queue_buffer(impl->capture, t);
+    }
+  }
 }
 
-static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
-{
+static int apply_props(struct spa_loop *loop, bool async, uint32_t seq,
+                       const void *data, size_t size, void *user_data) {
   const struct impl *impl = user_data;
   const struct spa_pod *props = data;
   spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
   return 0;
 }
 
-static void control_process(void *d)
-{
-	struct impl *impl = d;
+static void control_process(void *d) {
+  struct impl *impl = d;
 
   struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
-  if (control == NULL)
-    goto done;
+  if (control == NULL) goto done;
   if (control->buffer->n_datas > 0) {
-    struct spa_pod *pod = spa_pod_from_data(
-      control->buffer->datas[0].data,
-      control->buffer->datas[0].maxsize,
-      control->buffer->datas[0].chunk->offset,
-      control->buffer->datas[0].chunk->size);
+    struct spa_pod *pod = spa_pod_from_data(control->buffer->datas[0].data,
+                                            control->buffer->datas[0].maxsize,
+                                            control->buffer->datas[0].chunk->
+                                            offset,
+                                            control->buffer->datas[0].chunk->
+                                            size);
 
     if (spa_pod_is_sequence(pod)) {
-      struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
+      struct spa_pod_sequence *sequence = (struct spa_pod_sequence*)pod;
 
       struct spa_pod_control *pod_control;
       SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
         if (pod_control->type == SPA_CONTROL_Properties) {
-            struct pw_loop *loop = pw_context_get_main_loop(impl->context);
-            pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
-              SPA_POD_SIZE(&pod_control->value), false, impl);
+          struct pw_loop *loop = pw_context_get_main_loop(impl->context);
+          pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
+                         SPA_POD_SIZE(&pod_control->value), false, impl);
         }
       }
     }
   }
 
-  done:
-    pw_stream_queue_buffer(impl->control, control);
+done:
+  pw_stream_queue_buffer(impl->control, control);
 }
 
-static void playback_process(void *d)
-{
-	struct impl *impl = d;
-	struct pw_buffer *in, *out;
-	uint32_t i, data_size = 0;
-	int32_t stride = 0;
-	struct spa_data *bd;
-	const void *cin[128];
-	void *cout[128];
+static void playback_process(void *d) {
+  struct impl *impl = d;
+  struct pw_buffer *in, *out;
+  uint32_t i, data_size = 0;
+  int32_t stride = 0;
+  struct spa_data *bd;
+  const void *cin[128];
+  void *cout[128];
 
-	in = NULL;
-	while (true) {
-		struct pw_buffer *t;
-		if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL)
-			break;
-		if (in)
-			pw_stream_queue_buffer(impl->capture, in);
-		in = t;
-	}
-	if (in == NULL)
-		pw_log_debug("%p: out of capture buffers: %m", impl);
+  in = NULL;
+  while (true) {
+    struct pw_buffer *t;
+    if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL) break;
+    if (in) pw_stream_queue_buffer(impl->capture, in);
+    in = t;
+  }
+  if (in == NULL)
+    pw_log_debug("%p: out of capture buffers: %m", impl);
 
-	if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
-		pw_log_debug("%p: out of playback buffers: %m", impl);
+  if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
+    pw_log_debug("%p: out of playback buffers: %m", impl);
 
-	if (in == NULL || out == NULL)
-		goto done;
+  if (in == NULL || out == NULL) goto done;
 
-	for (i = 0; i < in->buffer->n_datas; i++) {
-		uint32_t offs, size;
+  for (i = 0; i < in->buffer->n_datas; i++) {
+    uint32_t offs, size;
 
-		bd = &in->buffer->datas[i];
+    bd = &in->buffer->datas[i];
 
-		offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
-		size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
+    offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
+    size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
 
-		cin[i] = SPA_PTROFF(bd->data, offs, void);
+    cin[i] = SPA_PTROFF(bd->data, offs, void);
 
-		data_size = i == 0 ? size : SPA_MIN(data_size, size);
-		stride = SPA_MAX(stride, bd->chunk->stride);
-	}
-	for (; i < impl->n_inputs; i++)
-		cin[i] = NULL;
+    data_size = i == 0 ? size : SPA_MIN(data_size, size);
+    stride = SPA_MAX(stride, bd->chunk->stride);
+  }
+  for (; i < impl->n_inputs; i++) cin[i] = NULL;
 
-	for (i = 0; i < out->buffer->n_datas; i++) {
-		bd = &out->buffer->datas[i];
+  for (i = 0; i < out->buffer->n_datas; i++) {
+    bd = &out->buffer->datas[i];
 
-		data_size = SPA_MIN(data_size, bd->maxsize);
+    data_size = SPA_MIN(data_size, bd->maxsize);
 
-		cout[i] = bd->data;
+    cout[i] = bd->data;
 
-		bd->chunk->offset = 0;
-		bd->chunk->size = data_size;
-		bd->chunk->stride = stride;
-	}
-	for (; i < impl->n_outputs; i++)
-		cout[i] = NULL;
+    bd->chunk->offset = 0;
+    bd->chunk->size = data_size;
+    bd->chunk->stride = stride;
+  }
+  for (; i < impl->n_outputs; i++) cout[i] = NULL;
 
-	pw_log_trace_fp("%p: stride:%d size:%d requested:%"PRIu64" (%"PRIu64")", impl,
-			stride, data_size, out->requested, out->requested * stride);
+  pw_log_trace_fp("%p: stride:%d size:%d requested:%"PRIu64" (%"PRIu64")", impl,
+                  stride, data_size, out->requested, out->requested * stride);
 
-	if (impl->graph_active)
-		spa_filter_graph_process(impl->graph, cin, cout, data_size / sizeof(float));
+  if (impl->graph_active) spa_filter_graph_process(
+    impl->graph, cin, cout, data_size / sizeof(float));
 
 done:
-	if (in != NULL)
-		pw_stream_queue_buffer(impl->capture, in);
-	if (out != NULL)
-		pw_stream_queue_buffer(impl->playback, out);
+  if (in != NULL) pw_stream_queue_buffer(impl->capture, in);
+  if (out != NULL) pw_stream_queue_buffer(impl->playback, out);
 }
 
-static int activate_graph(struct impl *impl)
-{
-	char rate[64];
-	int res;
+static int activate_graph(struct impl *impl) {
+  char rate[64];
+  int res;
 
-	if (impl->graph_active)
-		return 0;
+  if (impl->graph_active) return 0;
 
-	snprintf(rate, sizeof(rate), "%lu", impl->rate);
-	res = spa_filter_graph_activate(impl->graph, &SPA_DICT_ITEMS(
-				SPA_DICT_ITEM(SPA_KEY_AUDIO_RATE, rate)));
+  snprintf(rate, sizeof(rate), "%lu", impl->rate);
+  res = spa_filter_graph_activate(impl->graph,
+                                  &SPA_DICT_ITEMS(
+                                    SPA_DICT_ITEM(SPA_KEY_AUDIO_RATE, rate)));
 
-	if (res >= 0) {
-		struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
-		pw_loop_lock(data_loop);
-		impl->graph_active = true;
-		pw_loop_unlock(data_loop);
-	}
-	return res;
+  if (res >= 0) {
+    struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
+    pw_loop_lock(data_loop);
+    impl->graph_active = true;
+    pw_loop_unlock(data_loop);
+  }
+  return res;
 }
 
-static int deactivate_graph(struct impl *impl)
-{
-	struct pw_loop *data_loop;
+static int deactivate_graph(struct impl *impl) {
+  struct pw_loop *data_loop;
 
-	if (!impl->graph_active)
-		return 0;
+  if (!impl->graph_active) return 0;
 
-	data_loop = pw_stream_get_data_loop(impl->playback);
+  data_loop = pw_stream_get_data_loop(impl->playback);
 
-	pw_loop_lock(data_loop);
-	impl->graph_active = false;
-	pw_loop_unlock(data_loop);
+  pw_loop_lock(data_loop);
+  impl->graph_active = false;
+  pw_loop_unlock(data_loop);
 
-	return spa_filter_graph_deactivate(impl->graph);
+  return spa_filter_graph_deactivate(impl->graph);
 }
 
-static int reset_graph(struct impl *impl)
-{
-	struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
-	int res;
-	bool old_active = impl->graph_active;
+static int reset_graph(struct impl *impl) {
+  struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
+  int res;
+  bool old_active = impl->graph_active;
 
-	pw_loop_lock(data_loop);
-	impl->graph_active = false;
-	pw_loop_unlock(data_loop);
+  pw_loop_lock(data_loop);
+  impl->graph_active = false;
+  pw_loop_unlock(data_loop);
 
-	res = spa_filter_graph_reset(impl->graph);
+  res = spa_filter_graph_reset(impl->graph);
 
-	pw_loop_lock(data_loop);
-	impl->graph_active = old_active;
-	pw_loop_unlock(data_loop);
+  pw_loop_lock(data_loop);
+  impl->graph_active = old_active;
+  pw_loop_unlock(data_loop);
 
-	return res;
+  return res;
 }
 
-static void update_latency(struct impl *impl, enum spa_direction direction, bool process)
-{
-	struct spa_latency_info latency;
-	uint8_t buffer[1024];
-	struct spa_pod_builder b;
-	const struct spa_pod *params[2];
-	uint32_t n_params = 0;
-	struct pw_stream *s = direction == SPA_DIRECTION_OUTPUT ?
-		impl->playback : impl->capture;
+static void update_latency(struct impl *impl, enum spa_direction direction,
+                           bool process) {
+  struct spa_latency_info latency;
+  uint8_t buffer[1024];
+  struct spa_pod_builder b;
+  const struct spa_pod *params[2];
+  uint32_t n_params = 0;
+  struct pw_stream *s = direction == SPA_DIRECTION_OUTPUT
+                          ? impl->playback
+                          : impl->capture;
 
-	spa_pod_builder_init(&b, buffer, sizeof(buffer));
-	latency = impl->latency[direction];
-	spa_process_latency_info_add(&impl->process_latency, &latency);
-	params[n_params++] = spa_latency_build(&b, SPA_PARAM_Latency, &latency);
+  spa_pod_builder_init(&b, buffer, sizeof(buffer));
+  latency = impl->latency[direction];
+  spa_process_latency_info_add(&impl->process_latency, &latency);
+  params[n_params++] = spa_latency_build(&b, SPA_PARAM_Latency, &latency);
 
-	if (process) {
-		params[n_params++] = spa_process_latency_build(&b,
-				SPA_PARAM_ProcessLatency, &impl->process_latency);
-	}
-	pw_stream_update_params(s, params, n_params);
+  if (process) {
+    params[n_params++] = spa_process_latency_build(
+      &b, SPA_PARAM_ProcessLatency, &impl->process_latency);
+  }
+  pw_stream_update_params(s, params, n_params);
 }
 
-static void update_latencies(struct impl *impl, bool process)
-{
-	update_latency(impl, SPA_DIRECTION_INPUT, process);
-	update_latency(impl, SPA_DIRECTION_OUTPUT, process);
+static void update_latencies(struct impl *impl, bool process) {
+  update_latency(impl, SPA_DIRECTION_INPUT, process);
+  update_latency(impl, SPA_DIRECTION_OUTPUT, process);
 }
 
-static void param_latency_changed(struct impl *impl, const struct spa_pod *param,
-		enum spa_direction direction)
-{
-	struct spa_latency_info latency;
+static void param_latency_changed(struct impl *impl,
+                                  const struct spa_pod *param,
+                                  enum spa_direction direction) {
+  struct spa_latency_info latency;
 
-	if (param == NULL || spa_latency_parse(param, &latency) < 0)
-		return;
+  if (param == NULL || spa_latency_parse(param, &latency) < 0) return;
 
-	impl->latency[latency.direction] = latency;
-	update_latency(impl, latency.direction, false);
+  impl->latency[latency.direction] = latency;
+  update_latency(impl, latency.direction, false);
 }
 
-static void param_process_latency_changed(struct impl *impl, const struct spa_pod *param,
-		enum spa_direction direction)
-{
-	struct spa_process_latency_info process_latency;
+static void param_process_latency_changed(struct impl *impl,
+                                          const struct spa_pod *param,
+                                          enum spa_direction direction) {
+  struct spa_process_latency_info process_latency;
 
-	if (param == NULL)
-		spa_zero(process_latency);
-	else if (spa_process_latency_parse(param, &process_latency) < 0)
-		return;
-	if (spa_process_latency_info_compare(&impl->process_latency, &process_latency) == 0)
-		return;
+  if (param == NULL)
+    spa_zero(process_latency);
+  else if (spa_process_latency_parse(param, &process_latency) < 0) return;
+  if (spa_process_latency_info_compare(&impl->process_latency, &process_latency)
+    == 0) return;
 
-	impl->process_latency = process_latency;
-	update_latencies(impl, true);
+  impl->process_latency = process_latency;
+  update_latencies(impl, true);
 }
 
 static void param_tag_changed(struct impl *impl, const struct spa_pod *param,
-		enum spa_direction direction)
-{
-	struct spa_tag_info tag;
-	const struct spa_pod *params[1] = { param };
-	void *state = NULL;
+                              enum spa_direction direction) {
+  struct spa_tag_info tag;
+  const struct spa_pod *params[1] = {param};
+  void *state = NULL;
 
-	if (param == 0 || spa_tag_parse(param, &tag, &state) < 0)
-		return;
+  if (param == 0 || spa_tag_parse(param, &tag, &state) < 0) return;
 
-	if (tag.direction == SPA_DIRECTION_INPUT)
-		pw_stream_update_params(impl->capture, params, 1);
-	else
-		pw_stream_update_params(impl->playback, params, 1);
+  if (tag.direction == SPA_DIRECTION_INPUT) pw_stream_update_params(
+    impl->capture, params, 1);
+  else pw_stream_update_params(impl->playback, params, 1);
 }
 
 static void capture_state_changed(void *data, enum pw_stream_state old,
-		enum pw_stream_state state, const char *error)
-{
-	struct impl *impl = data;
+                                  enum pw_stream_state state,
+                                  const char *error) {
+  struct impl *impl = data;
 
-	switch (state) {
-	case PW_STREAM_STATE_PAUSED:
-		pw_stream_flush(impl->capture, false);
-		break;
-	case PW_STREAM_STATE_UNCONNECTED:
-		pw_log_info("module %p: unconnected", impl);
-		pw_impl_module_schedule_destroy(impl->module);
-		break;
-	case PW_STREAM_STATE_ERROR:
-		pw_log_info("module %p: error: %s", impl, error);
-		break;
-	case PW_STREAM_STATE_STREAMING:
-	default:
-		break;
-	}
-	return;
+  switch (state) {
+  case PW_STREAM_STATE_PAUSED:
+    pw_stream_flush(impl->capture, false);
+    break;
+  case PW_STREAM_STATE_UNCONNECTED: pw_log_info("module %p: unconnected", impl);
+    pw_impl_module_schedule_destroy(impl->module);
+    break;
+  case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl, error);
+    break;
+  case PW_STREAM_STATE_STREAMING: default:
+    break;
+  }
+  return;
 }
 
-static void io_changed(void *data, uint32_t id, void *area, uint32_t size)
-{
-	struct impl *impl = data;
-	switch (id) {
-	case SPA_IO_Position:
-		impl->position = area;
-		break;
-	default:
-		break;
-	}
+static void io_changed(void *data, uint32_t id, void *area, uint32_t size) {
+  struct impl *impl = data;
+  switch (id) {
+  case SPA_IO_Position:
+    impl->position = area;
+    break;
+  default:
+    break;
+  }
 }
 
-static void param_changed(struct impl *impl, uint32_t id, const struct spa_pod *param,
-		enum spa_direction direction, struct pw_stream *stream, struct pw_stream *other)
-{
-	int res;
+static void param_changed(struct impl *impl, uint32_t id,
+                          const struct spa_pod *param,
+                          enum spa_direction direction,
+                          struct pw_stream *stream, struct pw_stream *other) {
+  int res;
 
-	switch (id) {
-	case SPA_PARAM_Format:
-	{
-		struct spa_audio_info_raw info;
-		spa_zero(info);
-		if (param == NULL) {
-			pw_log_info("module %p: filter deactivate", impl);
-			if (direction == SPA_DIRECTION_OUTPUT)
-				deactivate_graph(impl);
-			impl->rate = 0;
-		} else {
-			if ((res = spa_format_audio_raw_parse(param, &info)) < 0)
-				goto error;
-		}
-		impl->info = info;
-		break;
-	}
-	case SPA_PARAM_Props:
-		if (param != NULL)
-			spa_filter_graph_set_props(impl->graph, direction, param);
-		break;
-	case SPA_PARAM_Latency:
-		param_latency_changed(impl, param, direction);
-		break;
-	case SPA_PARAM_ProcessLatency:
-		param_process_latency_changed(impl, param, direction);
-		break;
-	case SPA_PARAM_Tag:
-		param_tag_changed(impl, param, direction);
-		break;
-	}
-	return;
+  switch (id) {
+  case SPA_PARAM_Format:
+    {
+      struct spa_audio_info_raw info;
+      spa_zero(info);
+      if (param == NULL) {
+        pw_log_info("module %p: filter deactivate", impl);
+        if (direction == SPA_DIRECTION_OUTPUT) deactivate_graph(impl);
+        impl->rate = 0;
+      } else {
+        if ((res = spa_format_audio_raw_parse(param, &info)) < 0) goto error;
+      }
+      impl->info = info;
+      break;
+    }
+  case SPA_PARAM_Props:
+    if (param != NULL)
+      spa_filter_graph_set_props(impl->graph, direction, param);
+    break;
+  case SPA_PARAM_Latency:
+    param_latency_changed(impl, param, direction);
+    break;
+  case SPA_PARAM_ProcessLatency:
+    param_process_latency_changed(impl, param, direction);
+    break;
+  case SPA_PARAM_Tag:
+    param_tag_changed(impl, param, direction);
+    break;
+  }
+  return;
 
 error:
-	pw_stream_set_error(direction == SPA_DIRECTION_INPUT ? impl->capture : impl->playback,
-			res, "can't start graph: %s", spa_strerror(res));
+  pw_stream_set_error(
+    direction == SPA_DIRECTION_INPUT ? impl->capture : impl->playback, res,
+    "can't start graph: %s", spa_strerror(res));
 }
 
-static void capture_param_changed(void *data, uint32_t id, const struct spa_pod *param)
-{
-	struct impl *impl = data;
-	param_changed(impl, id, param, SPA_DIRECTION_INPUT, impl->capture, impl->playback);
+static void capture_param_changed(void *data, uint32_t id,
+                                  const struct spa_pod *param) {
+  struct impl *impl = data;
+  param_changed(impl, id, param, SPA_DIRECTION_INPUT, impl->capture,
+                impl->playback);
 }
 
 static const struct pw_stream_events in_stream_events = {
-	PW_VERSION_STREAM_EVENTS,
-	.destroy = capture_destroy,
-	.process = capture_process,
-	.io_changed = io_changed,
-	.state_changed = capture_state_changed,
-	.param_changed = capture_param_changed
+  PW_VERSION_STREAM_EVENTS, .destroy = capture_destroy,
+  .process = capture_process, .io_changed = io_changed,
+  .state_changed = capture_state_changed, .param_changed = capture_param_changed
 };
 
 static void playback_state_changed(void *data, enum pw_stream_state old,
-		enum pw_stream_state state, const char *error)
-{
-	struct impl *impl = data;
-	int res;
+                                   enum pw_stream_state state,
+                                   const char *error) {
+  struct impl *impl = data;
+  int res;
 
-	switch (state) {
-	case PW_STREAM_STATE_PAUSED:
-		pw_stream_flush(impl->playback, false);
-		reset_graph(impl);
-		break;
-	case PW_STREAM_STATE_UNCONNECTED:
-		pw_log_info("module %p: unconnected", impl);
-		pw_impl_module_schedule_destroy(impl->module);
-		break;
-	case PW_STREAM_STATE_ERROR:
-		pw_log_info("module %p: error: %s", impl, error);
-		break;
-	case PW_STREAM_STATE_STREAMING:
-	{
-		uint32_t target = impl->info.rate;
-		if (target == 0)
-			target = impl->position ?
-				impl->position->clock.target_rate.denom : DEFAULT_RATE;
-		if (target == 0) {
-			res = -EINVAL;
-			goto error;
-		}
-		if (impl->rate != target) {
-			impl->rate = target;
-			deactivate_graph(impl);
-		}
-		if ((res = activate_graph(impl)) < 0)
-			goto error;
-		break;
-	}
-	default:
-		break;
-	}
-	return;
+  switch (state) {
+  case PW_STREAM_STATE_PAUSED:
+    pw_stream_flush(impl->playback, false);
+    reset_graph(impl);
+    break;
+  case PW_STREAM_STATE_UNCONNECTED: pw_log_info("module %p: unconnected", impl);
+    pw_impl_module_schedule_destroy(impl->module);
+    break;
+  case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl, error);
+    break;
+  case PW_STREAM_STATE_STREAMING:
+    {
+      uint32_t target = impl->info.rate;
+      if (target == 0)
+        target = impl->position
+                   ? impl->position->clock.target_rate.denom
+                   : DEFAULT_RATE;
+      if (target == 0) {
+        res = -EINVAL;
+        goto error;
+      }
+      if (impl->rate != target) {
+        impl->rate = target;
+        deactivate_graph(impl);
+      }
+      if ((res = activate_graph(impl)) < 0) goto error;
+      break;
+    }
+  default:
+    break;
+  }
+  return;
 error:
-	pw_stream_set_error(impl->capture, res, "can't start graph: %s",
-			spa_strerror(res));
+  pw_stream_set_error(impl->capture, res, "can't start graph: %s",
+                      spa_strerror(res));
 }
 
-static void playback_param_changed(void *data, uint32_t id, const struct spa_pod *param)
-{
-	struct impl *impl = data;
-	param_changed(impl, id, param, SPA_DIRECTION_OUTPUT, impl->playback, impl->capture);
+static void playback_param_changed(void *data, uint32_t id,
+                                   const struct spa_pod *param) {
+  struct impl *impl = data;
+  param_changed(impl, id, param, SPA_DIRECTION_OUTPUT, impl->playback,
+                impl->capture);
 }
 
-static void playback_destroy(void *d)
-{
-	struct impl *impl = d;
-	spa_hook_remove(&impl->playback_listener);
-	impl->playback = NULL;
+static void playback_destroy(void *d) {
+  struct impl *impl = d;
+  spa_hook_remove(&impl->playback_listener);
+  impl->playback = NULL;
 }
 
 static const struct pw_stream_events out_stream_events = {
-	PW_VERSION_STREAM_EVENTS,
-	.destroy = playback_destroy,
-	.process = playback_process,
-	.io_changed = io_changed,
-	.state_changed = playback_state_changed,
-	.param_changed = playback_param_changed,
+  PW_VERSION_STREAM_EVENTS, .destroy = playback_destroy,
+  .process = playback_process, .io_changed = io_changed,
+  .state_changed = playback_state_changed,
+  .param_changed = playback_param_changed,
 };
 
-static void control_destroy(void *d)
-{
-	struct impl *impl = d;
-	spa_hook_remove(&impl->control_listener);
-	impl->control = NULL;
+static void control_destroy(void *d) {
+  struct impl *impl = d;
+  spa_hook_remove(&impl->control_listener);
+  impl->control = NULL;
 }
 
 static void control_state_changed(void *data, enum pw_stream_state old,
-    enum pw_stream_state state, const char *error)
-{
+                                  enum pw_stream_state state,
+                                  const char *error) {
   struct impl *impl = data;
 
   switch (state) {
   case PW_STREAM_STATE_PAUSED:
     pw_stream_flush(impl->control, false);
     break;
-  case PW_STREAM_STATE_ERROR:
-    pw_log_info("module %p: error: %s", impl, error);
+  case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl, error);
     break;
-  case PW_STREAM_STATE_STREAMING:
-  default:
+  case PW_STREAM_STATE_STREAMING: default:
     break;
   }
   return;
 }
 
 static const struct pw_stream_events control_stream_events = {
-	PW_VERSION_STREAM_EVENTS,
-	.destroy = control_destroy,
-	.process = control_process,
-	.io_changed = NULL,
-	.state_changed = control_state_changed,
-	.param_changed = NULL,
+  PW_VERSION_STREAM_EVENTS, .destroy = control_destroy,
+  .process = control_process, .io_changed = NULL,
+  .state_changed = control_state_changed, .param_changed = NULL,
 };
 
-static int setup_streams(struct impl *impl)
-{
-	int res;
-	uint32_t i, n_params, *offs;
-	struct pw_array offsets;
-	const struct spa_pod **params = NULL;
-	struct spa_pod_dynamic_builder b;
-	struct spa_filter_graph *graph = impl->graph;
+static int setup_streams(struct impl *impl) {
+  int res;
+  uint32_t i, n_params, *offs;
+  struct pw_array offsets;
+  const struct spa_pod **params = NULL;
+  struct spa_pod_dynamic_builder b;
+  struct spa_filter_graph *graph = impl->graph;
 
   if (impl->control_stream_active) {
-    impl->control = pw_stream_new(impl->core,
-        "filter control", impl->control_props);
+    impl->control = pw_stream_new(impl->core, "filter control",
+                                  impl->control_props);
     impl->control_props = NULL;
-    if (impl->control == NULL)
-      return -errno;
+    if (impl->control == NULL) return -errno;
 
-    pw_stream_add_listener(impl->control,
-        &impl->control_listener,
-        &control_stream_events, impl);
+    pw_stream_add_listener(impl->control, &impl->control_listener,
+                           &control_stream_events, impl);
 
     uint8_t buffer[256];
     struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
     const struct spa_pod *param[1];
 
-    param[0] = spa_pod_builder_add_object(&bt,
-        SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
-        SPA_FORMAT_mediaType,    SPA_POD_Id(SPA_MEDIA_TYPE_application),
-        SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
-    );
+    param[0] = spa_pod_builder_add_object(&bt, SPA_TYPE_OBJECT_Format,
+                                          SPA_PARAM_EnumFormat,
+                                          SPA_FORMAT_mediaType,
+                                          SPA_POD_Id(SPA_MEDIA_TYPE_application
+                                          ), SPA_FORMAT_mediaSubtype,
+                                          SPA_POD_Id(SPA_MEDIA_SUBTYPE_control));
 
-    pw_stream_connect(impl->control,
-        PW_DIRECTION_INPUT,
-        PW_ID_ANY,
-        PW_STREAM_FLAG_AUTOCONNECT |
-        PW_STREAM_FLAG_MAP_BUFFERS |
-        PW_STREAM_FLAG_RT_PROCESS,
-        param, 1);
+    pw_stream_connect(impl->control, PW_DIRECTION_INPUT, PW_ID_ANY,
+                      PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS |
+                      PW_STREAM_FLAG_RT_PROCESS, param, 1);
   }
 
-	impl->capture = pw_stream_new(impl->core,
-			"filter capture", impl->capture_props);
-	impl->capture_props = NULL;
-	if (impl->capture == NULL)
-		return -errno;
+  impl->capture = pw_stream_new(impl->core, "filter capture",
+                                impl->capture_props);
+  impl->capture_props = NULL;
+  if (impl->capture == NULL) return -errno;
 
-	pw_stream_add_listener(impl->capture,
-			&impl->capture_listener,
-			&in_stream_events, impl);
+  pw_stream_add_listener(impl->capture, &impl->capture_listener,
+                         &in_stream_events, impl);
 
-	impl->playback = pw_stream_new(impl->core,
-			"filter playback", impl->playback_props);
-	impl->playback_props = NULL;
-	if (impl->playback == NULL)
-		return -errno;
+  impl->playback = pw_stream_new(impl->core, "filter playback",
+                                 impl->playback_props);
+  impl->playback_props = NULL;
+  if (impl->playback == NULL) return -errno;
 
-	pw_stream_add_listener(impl->playback,
-			&impl->playback_listener,
-			&out_stream_events, impl);
+  pw_stream_add_listener(impl->playback, &impl->playback_listener,
+                         &out_stream_events, impl);
 
-	spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
-	pw_array_init(&offsets, 512);
+  spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
+  pw_array_init(&offsets, 512);
 
-	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) == NULL) {
-		res = -errno;
-		goto done;
-	}
-	*offs = b.b.state.offset;
-	spa_format_audio_raw_build(&b.b,
-			SPA_PARAM_EnumFormat, &impl->capture_info);
+  if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) == NULL) {
+    res = -errno;
+    goto done;
+  }
+  *offs = b.b.state.offset;
+  spa_format_audio_raw_build(&b.b, SPA_PARAM_EnumFormat, &impl->capture_info);
 
-	for (i = 0;; i++) {
-		uint32_t save = b.b.state.offset;
-		if (spa_filter_graph_enum_prop_info(graph, i, &b.b, NULL) != 1)
-			break;
-		if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
-			*offs = save;
-	}
+  for (i = 0;; i++) {
+    uint32_t save = b.b.state.offset;
+    if (spa_filter_graph_enum_prop_info(graph, i, &b.b, NULL) != 1) break;
+    if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *offs = save;
+  }
 
-	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
-		*offs = b.b.state.offset;
-	spa_filter_graph_get_props(graph, &b.b, NULL);
+  if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *offs = b.b.
+    state.offset;
+  spa_filter_graph_get_props(graph, &b.b, NULL);
 
-	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
-		*offs = b.b.state.offset;
-	spa_process_latency_build(&b.b,
-			SPA_PARAM_ProcessLatency, &impl->process_latency);
+  if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *offs = b.b.
+    state.offset;
+  spa_process_latency_build(&b.b, SPA_PARAM_ProcessLatency,
+                            &impl->process_latency);
 
-	n_params = pw_array_get_len(&offsets, uint32_t);
-	if (n_params == 0) {
-		res = -ENOMEM;
-		goto done;
-	}
-	if ((params = calloc(n_params, sizeof(struct spa_pod*))) == NULL) {
-		res = -errno;
-		goto done;
-	}
+  n_params = pw_array_get_len(&offsets, uint32_t);
+  if (n_params == 0) {
+    res = -ENOMEM;
+    goto done;
+  }
+  if ((params = calloc(n_params, sizeof(struct spa_pod*))) == NULL) {
+    res = -errno;
+    goto done;
+  }
 
-	offs = offsets.data;
-	for (i = 0; i < n_params; i++)
-		params[i] = spa_pod_builder_deref(&b.b, offs[i]);
+  offs = offsets.data;
+  for (i = 0; i < n_params; i++) params[i] = spa_pod_builder_deref(
+    &b.b, offs[i]);
 
-	res = pw_stream_connect(impl->capture,
-			PW_DIRECTION_INPUT,
-			PW_ID_ANY,
-			PW_STREAM_FLAG_AUTOCONNECT |
-			PW_STREAM_FLAG_MAP_BUFFERS |
-			PW_STREAM_FLAG_RT_PROCESS |
-			PW_STREAM_FLAG_ASYNC,
-			params, n_params);
+  res = pw_stream_connect(impl->capture, PW_DIRECTION_INPUT, PW_ID_ANY,
+                          PW_STREAM_FLAG_AUTOCONNECT |
+                          PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS
+                          | PW_STREAM_FLAG_ASYNC, params, n_params);
 
-	spa_pod_dynamic_builder_clean(&b);
-	if (res < 0)
-		goto done;
+  spa_pod_dynamic_builder_clean(&b);
+  if (res < 0) goto done;
 
-	n_params = 0;
-	spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
-	params[n_params++] = spa_format_audio_raw_build(&b.b,
-			SPA_PARAM_EnumFormat, &impl->playback_info);
+  n_params = 0;
+  spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
+  params[n_params++] = spa_format_audio_raw_build(
+    &b.b, SPA_PARAM_EnumFormat, &impl->playback_info);
 
-	res = pw_stream_connect(impl->playback,
-			PW_DIRECTION_OUTPUT,
-			PW_ID_ANY,
-			PW_STREAM_FLAG_AUTOCONNECT |
-			PW_STREAM_FLAG_MAP_BUFFERS |
-			PW_STREAM_FLAG_RT_PROCESS  |
-			PW_STREAM_FLAG_TRIGGER,
-			params, n_params);
-	spa_pod_dynamic_builder_clean(&b);
+  res = pw_stream_connect(impl->playback, PW_DIRECTION_OUTPUT, PW_ID_ANY,
+                          PW_STREAM_FLAG_AUTOCONNECT |
+                          PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS
+                          | PW_STREAM_FLAG_TRIGGER, params, n_params);
+  spa_pod_dynamic_builder_clean(&b);
 
 done:
-	free(params);
-	pw_array_clear(&offsets);
+  free(params);
+  pw_array_clear(&offsets);
 
-	return res < 0 ? res : 0;
+  return res < 0 ? res : 0;
 }
 
-static void copy_position(struct spa_audio_info_raw *dst, const struct spa_audio_info_raw *src)
-{
-	if (SPA_FLAG_IS_SET(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED) &&
-	    !SPA_FLAG_IS_SET(src->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
-		for (uint32_t i = 0; i < src->channels; i++)
-			dst->position[i] = src->position[i];
-		SPA_FLAG_CLEAR(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED);
-	}
+static void copy_position(struct spa_audio_info_raw *dst,
+                          const struct spa_audio_info_raw *src) {
+  if (SPA_FLAG_IS_SET(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED) && !
+    SPA_FLAG_IS_SET(src->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
+    for (uint32_t i = 0; i < src->channels; i++) dst->position[i] = src->
+      position[i];
+    SPA_FLAG_CLEAR(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED);
+  }
 }
 
-static void graph_info(void *object, const struct spa_filter_graph_info *info)
-{
-	struct impl *impl = object;
-	struct spa_dict *props = info->props;
-	uint32_t i;
+static void graph_info(void *object, const struct spa_filter_graph_info *info) {
+  struct impl *impl = object;
+  struct spa_dict *props = info->props;
+  uint32_t i;
 
-	if (impl->capture_info.channels == 0)
-		impl->capture_info.channels = info->n_inputs;
-	if (impl->playback_info.channels == 0)
-		impl->playback_info.channels = info->n_outputs;
+  if (impl->capture_info.channels == 0) impl->capture_info.channels = info->
+    n_inputs;
+  if (impl->playback_info.channels == 0) impl->playback_info.channels = info->
+    n_outputs;
 
-	impl->n_inputs = info->n_inputs;
-	impl->n_outputs = info->n_outputs;
+  impl->n_inputs = info->n_inputs;
+  impl->n_outputs = info->n_outputs;
 
-	if (impl->capture_info.channels == impl->playback_info.channels) {
-		copy_position(&impl->capture_info, &impl->playback_info);
-		copy_position(&impl->playback_info, &impl->capture_info);
-	}
-	for (i = 0; props && i < props->n_items; i++) {
-		const char *k = props->items[i].key;
-		const char *s = props->items[i].value;
-		pw_log_info("%s %s", k, s);
-		if (spa_streq(k, "latency")) {
-			double latency;
-			if (spa_atod(s, &latency)) {
-				if (impl->process_latency.rate != (int32_t)latency) {
-					impl->process_latency.rate = (int32_t)latency;
-					update_latencies(impl, true);
-				}
-			}
-		}
-	}
+  if (impl->capture_info.channels == impl->playback_info.channels) {
+    copy_position(&impl->capture_info, &impl->playback_info);
+    copy_position(&impl->playback_info, &impl->capture_info);
+  }
+  for (i = 0; props && i < props->n_items; i++) {
+    const char *k = props->items[i].key;
+    const char *s = props->items[i].value;
+    pw_log_info("%s %s", k, s);
+    if (spa_streq(k, "latency")) {
+      double latency;
+      if (spa_atod(s, &latency)) {
+        if (impl->process_latency.rate != (int32_t)latency) {
+          impl->process_latency.rate = (int32_t)latency;
+          update_latencies(impl, true);
+        }
+      }
+    }
+  }
 }
 
-static void graph_apply_props(void *object, enum spa_direction direction, const struct spa_pod *props)
-{
-	struct impl *impl = object;
-	pw_stream_set_param(direction == SPA_DIRECTION_INPUT ?
-			impl->capture : impl->playback,
-			SPA_PARAM_Props, props);
+static void graph_apply_props(void *object, enum spa_direction direction,
+                              const struct spa_pod *props) {
+  struct impl *impl = object;
+  pw_stream_set_param(
+    direction == SPA_DIRECTION_INPUT ? impl->capture : impl->playback,
+    SPA_PARAM_Props, props);
 }
 
-static void graph_props_changed(void *object, enum spa_direction direction)
-{
-	struct impl *impl = object;
-	struct spa_filter_graph *graph = impl->graph;
-	uint8_t buffer[1024];
-	struct spa_pod_dynamic_builder b;
-	const struct spa_pod *params[1];
+static void graph_props_changed(void *object, enum spa_direction direction) {
+  struct impl *impl = object;
+  struct spa_filter_graph *graph = impl->graph;
+  uint8_t buffer[1024];
+  struct spa_pod_dynamic_builder b;
+  const struct spa_pod *params[1];
 
-	spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
-	spa_filter_graph_get_props(graph, &b.b, (struct spa_pod **)&params[0]);
+  spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
+  spa_filter_graph_get_props(graph, &b.b, (struct spa_pod**)&params[0]);
 
-	pw_stream_update_params(impl->capture, params, 1);
-	spa_pod_dynamic_builder_clean(&b);
+  pw_stream_update_params(impl->capture, params, 1);
+  spa_pod_dynamic_builder_clean(&b);
 }
 
 struct spa_filter_graph_events graph_events = {
-	SPA_VERSION_FILTER_GRAPH_EVENTS,
-	.info = graph_info,
-	.apply_props = graph_apply_props,
-	.props_changed = graph_props_changed,
+  SPA_VERSION_FILTER_GRAPH_EVENTS, .info = graph_info,
+  .apply_props = graph_apply_props, .props_changed = graph_props_changed,
 };
 
-static void core_error(void *data, uint32_t id, int seq, int res, const char *message)
-{
-	struct impl *impl = data;
+static void core_error(void *data, uint32_t id, int seq, int res,
+                       const char *message) {
+  struct impl *impl = data;
 
-	if (res == -ENOENT) {
-		pw_log_info("message id:%u seq:%d res:%d (%s): %s",
-				id, seq, res, spa_strerror(res), message);
-	} else {
-		pw_log_warn("error id:%u seq:%d res:%d (%s): %s",
-				id, seq, res, spa_strerror(res), message);
-	}
+  if (res == -ENOENT) {
+    pw_log_info("message id:%u seq:%d res:%d (%s): %s", id, seq, res,
+                spa_strerror(res), message);
+  } else {
+    pw_log_warn("error id:%u seq:%d res:%d (%s): %s", id, seq, res,
+                spa_strerror(res), message);
+  }
 
-	if (id == PW_ID_CORE && res == -EPIPE)
-		pw_impl_module_schedule_destroy(impl->module);
+  if (id == PW_ID_CORE && res == -EPIPE) pw_impl_module_schedule_destroy(
+    impl->module);
 }
 
 static const struct pw_core_events core_events = {
-	PW_VERSION_CORE_EVENTS,
-	.error = core_error,
+  PW_VERSION_CORE_EVENTS, .error = core_error,
 };
 
-static void core_destroy(void *d)
-{
-	struct impl *impl = d;
-	spa_hook_remove(&impl->core_listener);
-	impl->core = NULL;
-	pw_impl_module_schedule_destroy(impl->module);
+static void core_destroy(void *d) {
+  struct impl *impl = d;
+  spa_hook_remove(&impl->core_listener);
+  impl->core = NULL;
+  pw_impl_module_schedule_destroy(impl->module);
 }
 
 static const struct pw_proxy_events core_proxy_events = {
-	.destroy = core_destroy,
+  .destroy = core_destroy,
 };
 
-static void impl_destroy(struct impl *impl)
-{
-	/* disconnect both streams before destroying any of them */
-	if (impl->capture)
-		pw_stream_disconnect(impl->capture);
-	if (impl->playback)
-		pw_stream_disconnect(impl->playback);
+static void impl_destroy(struct impl *impl) {
+  /* disconnect both streams before destroying any of them */
+  if (impl->capture) pw_stream_disconnect(impl->capture);
+  if (impl->playback) pw_stream_disconnect(impl->playback);
 
-	if (impl->capture)
-		pw_stream_destroy(impl->capture);
-	if (impl->playback)
-		pw_stream_destroy(impl->playback);
+  if (impl->capture) pw_stream_destroy(impl->capture);
+  if (impl->playback) pw_stream_destroy(impl->playback);
 
-	if (impl->core && impl->do_disconnect)
-		pw_core_disconnect(impl->core);
+  if (impl->core && impl->do_disconnect) pw_core_disconnect(impl->core);
 
-	if (impl->handle)
-		pw_unload_spa_handle(impl->handle);
+  if (impl->handle) pw_unload_spa_handle(impl->handle);
 
-	pw_properties_free(impl->capture_props);
-	pw_properties_free(impl->playback_props);
+  pw_properties_free(impl->capture_props);
+  pw_properties_free(impl->playback_props);
 
-	pw_properties_free(impl->props);
-	free(impl);
+  pw_properties_free(impl->props);
+  free(impl);
 }
 
-static void module_destroy(void *data)
-{
-	struct impl *impl = data;
-	spa_hook_remove(&impl->module_listener);
-	impl_destroy(impl);
+static void module_destroy(void *data) {
+  struct impl *impl = data;
+  spa_hook_remove(&impl->module_listener);
+  impl_destroy(impl);
 }
 
 static const struct pw_impl_module_events module_events = {
-	PW_VERSION_IMPL_MODULE_EVENTS,
-	.destroy = module_destroy,
+  PW_VERSION_IMPL_MODULE_EVENTS, .destroy = module_destroy,
 };
 
-static void parse_audio_info(struct pw_properties *props, struct spa_audio_info_raw *info)
-{
-	spa_audio_info_raw_init_dict_keys(info,
-			&SPA_DICT_ITEMS(
-				 SPA_DICT_ITEM(SPA_KEY_AUDIO_FORMAT, "F32P")),
-			&props->dict,
-			SPA_KEY_AUDIO_RATE,
-			SPA_KEY_AUDIO_CHANNELS,
-			SPA_KEY_AUDIO_POSITION, NULL);
+static void parse_audio_info(struct pw_properties *props,
+                             struct spa_audio_info_raw *info) {
+  spa_audio_info_raw_init_dict_keys(
+    info, &SPA_DICT_ITEMS(SPA_DICT_ITEM(SPA_KEY_AUDIO_FORMAT, "F32P")),
+    &props->dict, SPA_KEY_AUDIO_RATE, SPA_KEY_AUDIO_CHANNELS,
+    SPA_KEY_AUDIO_POSITION, NULL);
 }
 
-static void copy_props(struct impl *impl, struct pw_properties *props, const char *key)
-{
-	const char *str;
-	if ((str = pw_properties_get(props, key)) != NULL) {
-		if (pw_properties_get(impl->capture_props, key) == NULL)
-			pw_properties_set(impl->capture_props, key, str);
-		if (pw_properties_get(impl->playback_props, key) == NULL)
-			pw_properties_set(impl->playback_props, key, str);
-	}
+static void copy_props(struct impl *impl, struct pw_properties *props,
+                       const char *key) {
+  const char *str;
+  if ((str = pw_properties_get(props, key)) != NULL) {
+    if (pw_properties_get(impl->capture_props, key) == NULL) pw_properties_set(
+      impl->capture_props, key, str);
+    if (pw_properties_get(impl->playback_props, key) == NULL) pw_properties_set(
+      impl->playback_props, key, str);
+  }
 }
 
-SPA_EXPORT
-int pipewire__module_init(struct pw_impl_module *module, const char *args)
-{
-	struct pw_context *context = pw_impl_module_get_context(module);
-	const struct pw_properties *p;
-	struct pw_properties *props;
-	struct impl *impl;
-	uint32_t id = pw_global_get_id(pw_impl_module_get_global(module));
-	uint32_t pid = getpid();
-	const char *str;
-	int res;
-	void *iface = NULL;
+SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
+                                     const char *args) {
+  struct pw_context *context = pw_impl_module_get_context(module);
+  const struct pw_properties *p;
+  struct pw_properties *props;
+  struct impl *impl;
+  uint32_t id = pw_global_get_id(pw_impl_module_get_global(module));
+  uint32_t pid = getpid();
+  const char *str;
+  int res;
+  void *iface = NULL;
 
-	PW_LOG_TOPIC_INIT(mod_topic);
+  PW_LOG_TOPIC_INIT(mod_topic);
 
-	impl = calloc(1, sizeof(struct impl));
-	if (impl == NULL)
-		return -errno;
+  impl = calloc(1, sizeof(struct impl));
+  if (impl == NULL) return -errno;
 
-	pw_log_debug("module %p: new %s", impl, args);
+  pw_log_debug("module %p: new %s", impl, args);
 
-	if (args)
-		props = pw_properties_new_string(args);
-	else
-		props = pw_properties_new(NULL, NULL);
+  if (args) props = pw_properties_new_string(args);
+  else props = pw_properties_new(NULL, NULL);
 
-	if (props == NULL) {
-		res = -errno;
-		pw_log_error( "can't create properties: %m");
-		goto error;
-	}
-	impl->props = props;
+  if (props == NULL) {
+    res = -errno;
+    pw_log_error("can't create properties: %m");
+    goto error;
+  }
+  impl->props = props;
 
-	impl->capture_props = pw_properties_new(NULL, NULL);
-	impl->playback_props = pw_properties_new(NULL, NULL);
-	if (impl->capture_props == NULL || impl->playback_props == NULL) {
-		res = -errno;
-		pw_log_error( "can't create properties: %m");
-		goto error;
-	}
+  impl->capture_props = pw_properties_new(NULL, NULL);
+  impl->playback_props = pw_properties_new(NULL, NULL);
+  impl->control_props = pw_properties_new(NULL, NULL);
+  if (impl->capture_props == NULL || impl->playback_props == NULL || impl->
+    control_props == NULL) {
+    res = -errno;
+    pw_log_error("can't create properties: %m");
+    goto error;
+  }
 
-	impl->module = module;
-	impl->context = context;
-	impl->latency[SPA_DIRECTION_INPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_INPUT);
-	impl->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_OUTPUT);
+  impl->module = module;
+  impl->context = context;
+  impl->latency[SPA_DIRECTION_INPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_INPUT);
+  impl->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_OUTPUT);
 
-	if (pw_properties_get(props, PW_KEY_NODE_GROUP) == NULL)
-		pw_properties_setf(props, PW_KEY_NODE_GROUP, "filter-chain-%u-%u", pid, id);
-	if (pw_properties_get(props, PW_KEY_NODE_LINK_GROUP) == NULL)
-		pw_properties_setf(props, PW_KEY_NODE_LINK_GROUP, "filter-chain-%u-%u", pid, id);
-	if (pw_properties_get(props, PW_KEY_NODE_VIRTUAL) == NULL)
-		pw_properties_set(props, PW_KEY_NODE_VIRTUAL, "true");
-	if (pw_properties_get(props, "resample.prefill") == NULL)
-		pw_properties_set(props, "resample.prefill", "true");
-	if (pw_properties_get(props, PW_KEY_NODE_DESCRIPTION) == NULL)
-		pw_properties_setf(props, PW_KEY_NODE_DESCRIPTION, "filter-chain-%u-%u", pid, id);
+  if (pw_properties_get(props, PW_KEY_NODE_GROUP) == NULL) pw_properties_setf(
+    props, PW_KEY_NODE_GROUP, "filter-chain-%u-%u", pid, id);
+  if (pw_properties_get(props, PW_KEY_NODE_LINK_GROUP) == NULL)
+    pw_properties_setf(props, PW_KEY_NODE_LINK_GROUP, "filter-chain-%u-%u", pid,
+                       id);
+  if (pw_properties_get(props, PW_KEY_NODE_VIRTUAL) == NULL) pw_properties_set(
+    props, PW_KEY_NODE_VIRTUAL, "true");
+  if (pw_properties_get(props, "resample.prefill") == NULL) pw_properties_set(
+    props, "resample.prefill", "true");
+  if (pw_properties_get(props, PW_KEY_NODE_DESCRIPTION) == NULL)
+    pw_properties_setf(props, PW_KEY_NODE_DESCRIPTION, "filter-chain-%u-%u",
+                       pid, id);
 
-	if ((str = pw_properties_get(props, "capture.props")) != NULL)
-		pw_properties_update_string(impl->capture_props, str, strlen(str));
-	if ((str = pw_properties_get(props, "playback.props")) != NULL)
-		pw_properties_update_string(impl->playback_props, str, strlen(str));
+  if ((str = pw_properties_get(props, "capture.props")) != NULL)
+    pw_properties_update_string(impl->capture_props, str, strlen(str));
+  if ((str = pw_properties_get(props, "playback.props")) != NULL)
+    pw_properties_update_string(impl->playback_props, str, strlen(str));
+  if ((str = pw_properties_get(props, "control.props")) != NULL)
+    pw_properties_update_string(impl->control_props, str, strlen(str));
 
-	copy_props(impl, props, PW_KEY_AUDIO_RATE);
-	copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
-	copy_props(impl, props, SPA_KEY_AUDIO_POSITION);
-	copy_props(impl, props, PW_KEY_NODE_DESCRIPTION);
-	copy_props(impl, props, PW_KEY_NODE_GROUP);
-	copy_props(impl, props, PW_KEY_NODE_LINK_GROUP);
-	copy_props(impl, props, PW_KEY_NODE_LATENCY);
-	copy_props(impl, props, PW_KEY_NODE_VIRTUAL);
-	copy_props(impl, props, PW_KEY_MEDIA_NAME);
-	copy_props(impl, props, "resample.prefill");
+  copy_props(impl, props, PW_KEY_AUDIO_RATE);
+  copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
+  copy_props(impl, props, SPA_KEY_AUDIO_POSITION);
+  copy_props(impl, props, PW_KEY_NODE_DESCRIPTION);
+  copy_props(impl, props, PW_KEY_NODE_GROUP);
+  copy_props(impl, props, PW_KEY_NODE_LINK_GROUP);
+  copy_props(impl, props, PW_KEY_NODE_LATENCY);
+  copy_props(impl, props, PW_KEY_NODE_VIRTUAL);
+  copy_props(impl, props, PW_KEY_MEDIA_NAME);
+  copy_props(impl, props, "resample.prefill");
 
-	parse_audio_info(impl->capture_props, &impl->capture_info);
-	parse_audio_info(impl->playback_props, &impl->playback_info);
+  parse_audio_info(impl->capture_props, &impl->capture_info);
+  parse_audio_info(impl->playback_props, &impl->playback_info);
 
-	if (!impl->capture_info.rate && !impl->playback_info.rate) {
-		if (pw_properties_get(impl->playback_props, "resample.disable") == NULL)
-			pw_properties_set(impl->playback_props, "resample.disable", "true");
-		if (pw_properties_get(impl->capture_props, "resample.disable") == NULL)
-			pw_properties_set(impl->capture_props, "resample.disable", "true");
-	} else if (impl->capture_info.rate && !impl->playback_info.rate)
-		impl->playback_info.rate = impl->capture_info.rate;
-	else if (impl->playback_info.rate && !impl->capture_info.rate)
-		impl->capture_info.rate = !impl->playback_info.rate;
-	else if (impl->capture_info.rate != impl->playback_info.rate) {
-		pw_log_warn("Both capture and playback rate are set, but"
-			" they are different. Using the highest of two. This behaviour"
-			" is deprecated, please use equal rates in the module config");
-		impl->playback_info.rate = impl->capture_info.rate =
-			SPA_MAX(impl->playback_info.rate, impl->capture_info.rate);
-	}
+  if (!impl->capture_info.rate && !impl->playback_info.rate) {
+    if (pw_properties_get(impl->playback_props, "resample.disable") == NULL)
+      pw_properties_set(impl->playback_props, "resample.disable", "true");
+    if (pw_properties_get(impl->capture_props, "resample.disable") == NULL)
+      pw_properties_set(impl->capture_props, "resample.disable", "true");
+  } else if (impl->capture_info.rate && !impl->playback_info.rate) impl->
+    playback_info.rate = impl->capture_info.rate;
+  else if (impl->playback_info.rate && !impl->capture_info.rate) impl->
+    capture_info.rate = !impl->playback_info.rate;
+  else if (impl->capture_info.rate != impl->playback_info.rate) {
+    pw_log_warn(
+      "Both capture and playback rate are set, but"
+      " they are different. Using the highest of two. This behaviour"
+      " is deprecated, please use equal rates in the module config");
+    impl->playback_info.rate = impl->capture_info.rate = SPA_MAX(
+      impl->playback_info.rate, impl->capture_info.rate);
+  }
 
-	if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
-		pw_properties_setf(props, PW_KEY_NODE_NAME,
-				"filter-chain-%u-%u", pid, id);
-		str = pw_properties_get(props, PW_KEY_NODE_NAME);
-	}
-	if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
-		pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME,
-				"input.%s", str);
-	if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
-		pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME,
-				"output.%s", str);
+  if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
+    pw_properties_setf(props, PW_KEY_NODE_NAME, "filter-chain-%u-%u", pid, id);
+    str = pw_properties_get(props, PW_KEY_NODE_NAME);
+  }
+  if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
+    pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME, "input.%s", str);
+  if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
+    pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME, "output.%s",
+                       str);
 
-	if (pw_properties_get(impl->capture_props, PW_KEY_MEDIA_NAME) == NULL)
-		pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME, "%s input",
-				pw_properties_get(impl->capture_props, PW_KEY_NODE_DESCRIPTION));
-	if (pw_properties_get(impl->playback_props, PW_KEY_MEDIA_NAME) == NULL)
-		pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME, "%s output",
-				pw_properties_get(impl->playback_props, PW_KEY_NODE_DESCRIPTION));
+  if (pw_properties_get(impl->capture_props, PW_KEY_MEDIA_NAME) == NULL)
+    pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME, "%s input",
+                       pw_properties_get(impl->capture_props,
+                                         PW_KEY_NODE_DESCRIPTION));
+  if (pw_properties_get(impl->playback_props, PW_KEY_MEDIA_NAME) == NULL)
+    pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME, "%s output",
+                       pw_properties_get(impl->playback_props,
+                                         PW_KEY_NODE_DESCRIPTION));
 
-	p = pw_context_get_properties(impl->context);
-	pw_properties_set(props, "clock.quantum-limit",
-			pw_properties_get(p, "default.clock.quantum-limit"));
+  p = pw_context_get_properties(impl->context);
+  pw_properties_set(props, "clock.quantum-limit",
+                    pw_properties_get(p, "default.clock.quantum-limit"));
 
-	pw_properties_setf(props, "filter-graph.n_inputs", "%d", impl->capture_info.channels);
-	pw_properties_setf(props, "filter-graph.n_outputs", "%d", impl->playback_info.channels);
+  pw_properties_setf(props, "filter-graph.n_inputs", "%d",
+                     impl->capture_info.channels);
+  pw_properties_setf(props, "filter-graph.n_outputs", "%d",
+                     impl->playback_info.channels);
 
-	pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "filter-graph/libspa-filter-graph");
-	impl->handle = pw_context_load_spa_handle(impl->context, "filter.graph", &props->dict);
-	if (impl->handle == NULL) {
-		res = -errno;
-		goto error;
-	}
+  pw_properties_set(props, SPA_KEY_LIBRARY_NAME,
+                    "filter-graph/libspa-filter-graph");
+  impl->handle = pw_context_load_spa_handle(impl->context, "filter.graph",
+                                            &props->dict);
+  if (impl->handle == NULL) {
+    res = -errno;
+    goto error;
+  }
 
-	res = spa_handle_get_interface(impl->handle, SPA_TYPE_INTERFACE_FilterGraph, &iface);
-	if (res < 0 || iface == NULL)
-		goto error;
+  res = spa_handle_get_interface(impl->handle, SPA_TYPE_INTERFACE_FilterGraph,
+                                 &iface);
+  if (res < 0 || iface == NULL) goto error;
 
-	impl->graph = iface;
+  impl->graph = iface;
 
-	spa_filter_graph_add_listener(impl->graph, &impl->graph_listener,
-			&graph_events, impl);
+  spa_filter_graph_add_listener(impl->graph, &impl->graph_listener,
+                                &graph_events, impl);
 
-	impl->core = pw_context_get_object(impl->context, PW_TYPE_INTERFACE_Core);
-	if (impl->core == NULL) {
-		str = pw_properties_get(props, PW_KEY_REMOTE_NAME);
-		impl->core = pw_context_connect(impl->context,
-				pw_properties_new(
-					PW_KEY_REMOTE_NAME, str,
-					NULL),
-				0);
-		impl->do_disconnect = true;
-	}
-	if (impl->core == NULL) {
-		res = -errno;
-		pw_log_error("can't connect: %m");
-		goto error;
-	}
+  impl->core = pw_context_get_object(impl->context, PW_TYPE_INTERFACE_Core);
+  if (impl->core == NULL) {
+    str = pw_properties_get(props, PW_KEY_REMOTE_NAME);
+    impl->core = pw_context_connect(impl->context,
+                                    pw_properties_new(
+                                      PW_KEY_REMOTE_NAME, str, NULL), 0);
+    impl->do_disconnect = true;
+  }
+  if (impl->core == NULL) {
+    res = -errno;
+    pw_log_error("can't connect: %m");
+    goto error;
+  }
 
-	pw_proxy_add_listener((struct pw_proxy*)impl->core,
-			&impl->core_proxy_listener,
-			&core_proxy_events, impl);
-	pw_core_add_listener(impl->core,
-			&impl->core_listener,
-			&core_events, impl);
+  pw_proxy_add_listener((struct pw_proxy*)impl->core,
+                        &impl->core_proxy_listener, &core_proxy_events, impl);
+  pw_core_add_listener(impl->core, &impl->core_listener, &core_events, impl);
 
-  if (pw_properties_get(props, "controlStream.enabled") == NULL) {
+  if (pw_properties_get(impl->control_props, "enabled") == NULL) {
     impl->control_stream_active = false;
-  } else if (strcmp(pw_properties_get(props, "controlStream.enabled"), "true")
+  } else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "true")
     == 0) {
     impl->control_stream_active = true;
-  } else if (strcmp(pw_properties_get(props, "controlStream.enabled"), "false")
+  } else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "false")
     == 0) {
     impl->control_stream_active = false;
   }
 
   setup_streams(impl);
 
-	pw_impl_module_add_listener(module, &impl->module_listener, &module_events, impl);
+  pw_impl_module_add_listener(module, &impl->module_listener, &module_events,
+                              impl);
 
-	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
+  pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
 
-	return 0;
+  return 0;
 
 error:
-	impl_destroy(impl);
-	return res;
+
+  impl_destroy(impl);
+  return res;
 }

From 5783cf865f47b8c98a295c435db3438693908a3a Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sat, 16 Aug 2025 21:30:43 -0400
Subject: [PATCH 09/26] Apply .editorconfig

---
 src/modules/module-filter-chain.c | 1380 +++++++++++++++--------------
 1 file changed, 719 insertions(+), 661 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 108a6f35b..61afd49ab 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1106,26 +1106,31 @@ extern struct spa_handle_factory spa_filter_graph_factory;
  *\endcode
  */
 static const struct spa_dict_item module_props[] = {
-  {PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>"},
-  {PW_KEY_MODULE_DESCRIPTION, "Create filter chain streams"},
-  {
-    PW_KEY_MODULE_USAGE,
-    " ( remote.name=<remote> ) " "( node.latency=<latency as fraction> ) "
-    "( node.description=<description of the nodes> ) "
-    "( audio.rate=<sample rate> ) " "( audio.channels=<number of channels> ) "
-    "( audio.position=<channel map> ) " "filter.graph = [ " "    nodes = [ "
-    "        { " "          type = <ladspa | lv2 | builtin | sofa> "
-    "          name = <name> " "          plugin = <plugin> "
-    "          label = <label> " "          config = { "
-    "             <configkey> = <value> ... " "          } "
-    "          control = { "
-    "             <controlname|controlindex> = <value> ... " "          } "
-    "        } " "    ] " "    links = [ "
-    "        { output = <portname> input = <portname> } ... " "    ] "
-    "    inputs = [ <portname> ... ] " "    outputs = [ <portname> ... ] " "] "
-    "( capture.props=<properties> ) " "( playback.props=<properties> ) "
-  },
-  {PW_KEY_MODULE_VERSION, PACKAGE_VERSION},
+	{PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>"},
+	{PW_KEY_MODULE_DESCRIPTION, "Create filter chain streams"},
+	{
+		PW_KEY_MODULE_USAGE,
+		" ( remote.name=<remote> ) "
+		"( node.latency=<latency as fraction> ) "
+		"( node.description=<description of the nodes> ) "
+		"( audio.rate=<sample rate> ) "
+		"( audio.channels=<number of channels> ) "
+		"( audio.position=<channel map> ) " "filter.graph = [ "
+		"    nodes = [ " "        { "
+		"          type = <ladspa | lv2 | builtin | sofa> "
+		"          name = <name> " "          plugin = <plugin> "
+		"          label = <label> " "          config = { "
+		"             <configkey> = <value> ... " "          } "
+		"          control = { "
+		"             <controlname|controlindex> = <value> ... "
+		"          } " "        } " "    ] " "    links = [ "
+		"        { output = <portname> input = <portname> } ... "
+		"    ] " "    inputs = [ <portname> ... ] "
+		"    outputs = [ <portname> ... ] " "] "
+		"( capture.props=<properties> ) "
+		"( playback.props=<properties> ) "
+	},
+	{PW_KEY_MODULE_VERSION, PACKAGE_VERSION},
 };
 
 #include <unistd.h>
@@ -1146,916 +1151,969 @@ static const struct spa_dict_item module_props[] = {
 #define DEFAULT_RATE	48000
 
 struct impl {
-  struct pw_context *context;
+	struct pw_context *context;
 
-  struct pw_impl_module *module;
-  struct pw_properties *props;
+	struct pw_impl_module *module;
+	struct pw_properties *props;
 
-  struct spa_hook module_listener;
+	struct spa_hook module_listener;
 
-  struct pw_core *core;
-  struct spa_hook core_proxy_listener;
-  struct spa_hook core_listener;
+	struct pw_core *core;
+	struct spa_hook core_proxy_listener;
+	struct spa_hook core_listener;
 
-  struct pw_properties *capture_props;
-  struct pw_stream *capture;
-  struct spa_hook capture_listener;
-  struct spa_audio_info_raw capture_info;
+	struct pw_properties *capture_props;
+	struct pw_stream *capture;
+	struct spa_hook capture_listener;
+	struct spa_audio_info_raw capture_info;
 
-  struct pw_properties *playback_props;
-  struct pw_stream *playback;
-  struct spa_hook playback_listener;
-  struct spa_audio_info_raw playback_info;
+	struct pw_properties *playback_props;
+	struct pw_stream *playback;
+	struct spa_hook playback_listener;
+	struct spa_audio_info_raw playback_info;
 
-  struct pw_properties *control_props;
-  struct pw_stream *control;
-  struct spa_hook control_listener;
-  bool control_stream_active;
+	struct pw_properties *control_props;
+	struct pw_stream *control;
+	struct spa_hook control_listener;
+	bool control_stream_active;
 
-  struct spa_audio_info_raw info;
+	struct spa_audio_info_raw info;
 
-  struct spa_io_position *position;
+	struct spa_io_position *position;
 
-  unsigned int do_disconnect : 1;
+	unsigned int do_disconnect : 1;
 
-  long unsigned rate;
+	long unsigned rate;
 
-  struct spa_handle *handle;
-  struct spa_filter_graph *graph;
-  struct spa_hook graph_listener;
-  uint32_t n_inputs;
-  uint32_t n_outputs;
-  bool graph_active;
+	struct spa_handle *handle;
+	struct spa_filter_graph *graph;
+	struct spa_hook graph_listener;
+	uint32_t n_inputs;
+	uint32_t n_outputs;
+	bool graph_active;
 
-  struct spa_latency_info latency[2];
-  struct spa_process_latency_info process_latency;
+	struct spa_latency_info latency[2];
+	struct spa_process_latency_info process_latency;
 };
 
 static void capture_destroy(void *d) {
-  struct impl *impl = d;
-  spa_hook_remove(&impl->capture_listener);
-  impl->capture = NULL;
+	struct impl *impl = d;
+	spa_hook_remove(&impl->capture_listener);
+	impl->capture = NULL;
 }
 
 static void capture_process(void *d) {
-  struct impl *impl = d;
-  int res;
-  if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
-    pw_log_debug("playback trigger error: %s", spa_strerror(res));
-    while (true) {
-      struct pw_buffer *t;
-      if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL) break;
-      /* playback part is not ready, consume, discard and recycle
-       * the capture buffers */
-      pw_stream_queue_buffer(impl->capture, t);
-    }
-  }
+	struct impl *impl = d;
+	int res;
+	if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
+		pw_log_debug("playback trigger error: %s", spa_strerror(res));
+		while (true) {
+			struct pw_buffer *t;
+			if ((t = pw_stream_dequeue_buffer(impl->capture)) ==
+				NULL) break;
+			/* playback part is not ready, consume, discard and recycle
+			 * the capture buffers */
+			pw_stream_queue_buffer(impl->capture, t);
+		}
+	}
 }
 
 static int apply_props(struct spa_loop *loop, bool async, uint32_t seq,
                        const void *data, size_t size, void *user_data) {
-  const struct impl *impl = user_data;
-  const struct spa_pod *props = data;
-  spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
-  return 0;
+	const struct impl *impl = user_data;
+	const struct spa_pod *props = data;
+	spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
+	return 0;
 }
 
 static void control_process(void *d) {
-  struct impl *impl = d;
+	struct impl *impl = d;
 
-  struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
-  if (control == NULL) goto done;
-  if (control->buffer->n_datas > 0) {
-    struct spa_pod *pod = spa_pod_from_data(control->buffer->datas[0].data,
-                                            control->buffer->datas[0].maxsize,
-                                            control->buffer->datas[0].chunk->
-                                            offset,
-                                            control->buffer->datas[0].chunk->
-                                            size);
+	struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
+	if (control == NULL) goto done;
+	if (control->buffer->n_datas > 0) {
+		struct spa_pod *pod = spa_pod_from_data(
+			control->buffer->datas[0].data,
+			control->buffer->datas[0].maxsize,
+			control->buffer->datas[0].chunk->offset,
+			control->buffer->datas[0].chunk->size);
 
-    if (spa_pod_is_sequence(pod)) {
-      struct spa_pod_sequence *sequence = (struct spa_pod_sequence*)pod;
+		if (spa_pod_is_sequence(pod)) {
+			struct spa_pod_sequence *sequence = (struct
+				spa_pod_sequence*)pod;
 
-      struct spa_pod_control *pod_control;
-      SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
-        if (pod_control->type == SPA_CONTROL_Properties) {
-          struct pw_loop *loop = pw_context_get_main_loop(impl->context);
-          pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
-                         SPA_POD_SIZE(&pod_control->value), false, impl);
-        }
-      }
-    }
-  }
+			struct spa_pod_control *pod_control;
+			SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
+				if (pod_control->type ==
+					SPA_CONTROL_Properties) {
+					struct pw_loop *loop =
+						pw_context_get_main_loop(
+							impl->context);
+					pw_loop_invoke(
+						loop, apply_props, 0,
+						&pod_control->value,
+						SPA_POD_SIZE(
+							&pod_control->value),
+						false, impl);
+				}
+			}
+		}
+	}
 
 done:
-  pw_stream_queue_buffer(impl->control, control);
+	pw_stream_queue_buffer(impl->control, control);
 }
 
 static void playback_process(void *d) {
-  struct impl *impl = d;
-  struct pw_buffer *in, *out;
-  uint32_t i, data_size = 0;
-  int32_t stride = 0;
-  struct spa_data *bd;
-  const void *cin[128];
-  void *cout[128];
+	struct impl *impl = d;
+	struct pw_buffer *in, *out;
+	uint32_t i, data_size = 0;
+	int32_t stride = 0;
+	struct spa_data *bd;
+	const void *cin[128];
+	void *cout[128];
 
-  in = NULL;
-  while (true) {
-    struct pw_buffer *t;
-    if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL) break;
-    if (in) pw_stream_queue_buffer(impl->capture, in);
-    in = t;
-  }
-  if (in == NULL)
-    pw_log_debug("%p: out of capture buffers: %m", impl);
+	in = NULL;
+	while (true) {
+		struct pw_buffer *t;
+		if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL) break
+			;
+		if (in) pw_stream_queue_buffer(impl->capture, in);
+		in = t;
+	}
+	if (in == NULL)
+		pw_log_debug("%p: out of capture buffers: %m", impl);
 
-  if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
-    pw_log_debug("%p: out of playback buffers: %m", impl);
+	if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
+		pw_log_debug("%p: out of playback buffers: %m", impl);
 
-  if (in == NULL || out == NULL) goto done;
+	if (in == NULL || out == NULL) goto done;
 
-  for (i = 0; i < in->buffer->n_datas; i++) {
-    uint32_t offs, size;
+	for (i = 0; i < in->buffer->n_datas; i++) {
+		uint32_t offs, size;
 
-    bd = &in->buffer->datas[i];
+		bd = &in->buffer->datas[i];
 
-    offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
-    size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
+		offs = SPA_MIN(bd->chunk->offset, bd->maxsize);
+		size = SPA_MIN(bd->chunk->size, bd->maxsize - offs);
 
-    cin[i] = SPA_PTROFF(bd->data, offs, void);
+		cin[i] = SPA_PTROFF(bd->data, offs, void);
 
-    data_size = i == 0 ? size : SPA_MIN(data_size, size);
-    stride = SPA_MAX(stride, bd->chunk->stride);
-  }
-  for (; i < impl->n_inputs; i++) cin[i] = NULL;
+		data_size = i == 0 ? size : SPA_MIN(data_size, size);
+		stride = SPA_MAX(stride, bd->chunk->stride);
+	}
+	for (; i < impl->n_inputs; i++) cin[i] = NULL;
 
-  for (i = 0; i < out->buffer->n_datas; i++) {
-    bd = &out->buffer->datas[i];
+	for (i = 0; i < out->buffer->n_datas; i++) {
+		bd = &out->buffer->datas[i];
 
-    data_size = SPA_MIN(data_size, bd->maxsize);
+		data_size = SPA_MIN(data_size, bd->maxsize);
 
-    cout[i] = bd->data;
+		cout[i] = bd->data;
 
-    bd->chunk->offset = 0;
-    bd->chunk->size = data_size;
-    bd->chunk->stride = stride;
-  }
-  for (; i < impl->n_outputs; i++) cout[i] = NULL;
+		bd->chunk->offset = 0;
+		bd->chunk->size = data_size;
+		bd->chunk->stride = stride;
+	}
+	for (; i < impl->n_outputs; i++) cout[i] = NULL;
 
-  pw_log_trace_fp("%p: stride:%d size:%d requested:%"PRIu64" (%"PRIu64")", impl,
-                  stride, data_size, out->requested, out->requested * stride);
+	pw_log_trace_fp("%p: stride:%d size:%d requested:%"PRIu64" (%"PRIu64")",
+	                impl, stride, data_size, out->requested,
+	                out->requested * stride);
 
-  if (impl->graph_active) spa_filter_graph_process(
-    impl->graph, cin, cout, data_size / sizeof(float));
+	if (impl->graph_active)
+		spa_filter_graph_process(impl->graph, cin, cout,
+		                         data_size / sizeof(float));
 
 done:
-  if (in != NULL) pw_stream_queue_buffer(impl->capture, in);
-  if (out != NULL) pw_stream_queue_buffer(impl->playback, out);
+	if (in != NULL) pw_stream_queue_buffer(impl->capture, in);
+	if (out != NULL) pw_stream_queue_buffer(impl->playback, out);
 }
 
 static int activate_graph(struct impl *impl) {
-  char rate[64];
-  int res;
+	char rate[64];
+	int res;
 
-  if (impl->graph_active) return 0;
+	if (impl->graph_active) return 0;
 
-  snprintf(rate, sizeof(rate), "%lu", impl->rate);
-  res = spa_filter_graph_activate(impl->graph,
-                                  &SPA_DICT_ITEMS(
-                                    SPA_DICT_ITEM(SPA_KEY_AUDIO_RATE, rate)));
+	snprintf(rate, sizeof(rate), "%lu", impl->rate);
+	res = spa_filter_graph_activate(impl->graph,
+	                                &SPA_DICT_ITEMS(
+		                                SPA_DICT_ITEM(SPA_KEY_AUDIO_RATE
+			                                , rate)));
 
-  if (res >= 0) {
-    struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
-    pw_loop_lock(data_loop);
-    impl->graph_active = true;
-    pw_loop_unlock(data_loop);
-  }
-  return res;
+	if (res >= 0) {
+		struct pw_loop *data_loop = pw_stream_get_data_loop(
+			impl->playback);
+		pw_loop_lock(data_loop);
+		impl->graph_active = true;
+		pw_loop_unlock(data_loop);
+	}
+	return res;
 }
 
 static int deactivate_graph(struct impl *impl) {
-  struct pw_loop *data_loop;
+	struct pw_loop *data_loop;
 
-  if (!impl->graph_active) return 0;
+	if (!impl->graph_active) return 0;
 
-  data_loop = pw_stream_get_data_loop(impl->playback);
+	data_loop = pw_stream_get_data_loop(impl->playback);
 
-  pw_loop_lock(data_loop);
-  impl->graph_active = false;
-  pw_loop_unlock(data_loop);
+	pw_loop_lock(data_loop);
+	impl->graph_active = false;
+	pw_loop_unlock(data_loop);
 
-  return spa_filter_graph_deactivate(impl->graph);
+	return spa_filter_graph_deactivate(impl->graph);
 }
 
 static int reset_graph(struct impl *impl) {
-  struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
-  int res;
-  bool old_active = impl->graph_active;
+	struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
+	int res;
+	bool old_active = impl->graph_active;
 
-  pw_loop_lock(data_loop);
-  impl->graph_active = false;
-  pw_loop_unlock(data_loop);
+	pw_loop_lock(data_loop);
+	impl->graph_active = false;
+	pw_loop_unlock(data_loop);
 
-  res = spa_filter_graph_reset(impl->graph);
+	res = spa_filter_graph_reset(impl->graph);
 
-  pw_loop_lock(data_loop);
-  impl->graph_active = old_active;
-  pw_loop_unlock(data_loop);
+	pw_loop_lock(data_loop);
+	impl->graph_active = old_active;
+	pw_loop_unlock(data_loop);
 
-  return res;
+	return res;
 }
 
 static void update_latency(struct impl *impl, enum spa_direction direction,
                            bool process) {
-  struct spa_latency_info latency;
-  uint8_t buffer[1024];
-  struct spa_pod_builder b;
-  const struct spa_pod *params[2];
-  uint32_t n_params = 0;
-  struct pw_stream *s = direction == SPA_DIRECTION_OUTPUT
-                          ? impl->playback
-                          : impl->capture;
+	struct spa_latency_info latency;
+	uint8_t buffer[1024];
+	struct spa_pod_builder b;
+	const struct spa_pod *params[2];
+	uint32_t n_params = 0;
+	struct pw_stream *s = direction == SPA_DIRECTION_OUTPUT
+		                      ? impl->playback
+		                      : impl->capture;
 
-  spa_pod_builder_init(&b, buffer, sizeof(buffer));
-  latency = impl->latency[direction];
-  spa_process_latency_info_add(&impl->process_latency, &latency);
-  params[n_params++] = spa_latency_build(&b, SPA_PARAM_Latency, &latency);
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	latency = impl->latency[direction];
+	spa_process_latency_info_add(&impl->process_latency, &latency);
+	params[n_params++] = spa_latency_build(&b, SPA_PARAM_Latency, &latency);
 
-  if (process) {
-    params[n_params++] = spa_process_latency_build(
-      &b, SPA_PARAM_ProcessLatency, &impl->process_latency);
-  }
-  pw_stream_update_params(s, params, n_params);
+	if (process) {
+		params[n_params++] = spa_process_latency_build(
+			&b, SPA_PARAM_ProcessLatency, &impl->process_latency);
+	}
+	pw_stream_update_params(s, params, n_params);
 }
 
 static void update_latencies(struct impl *impl, bool process) {
-  update_latency(impl, SPA_DIRECTION_INPUT, process);
-  update_latency(impl, SPA_DIRECTION_OUTPUT, process);
+	update_latency(impl, SPA_DIRECTION_INPUT, process);
+	update_latency(impl, SPA_DIRECTION_OUTPUT, process);
 }
 
 static void param_latency_changed(struct impl *impl,
                                   const struct spa_pod *param,
                                   enum spa_direction direction) {
-  struct spa_latency_info latency;
+	struct spa_latency_info latency;
 
-  if (param == NULL || spa_latency_parse(param, &latency) < 0) return;
+	if (param == NULL || spa_latency_parse(param, &latency) < 0) return;
 
-  impl->latency[latency.direction] = latency;
-  update_latency(impl, latency.direction, false);
+	impl->latency[latency.direction] = latency;
+	update_latency(impl, latency.direction, false);
 }
 
 static void param_process_latency_changed(struct impl *impl,
                                           const struct spa_pod *param,
                                           enum spa_direction direction) {
-  struct spa_process_latency_info process_latency;
+	struct spa_process_latency_info process_latency;
 
-  if (param == NULL)
-    spa_zero(process_latency);
-  else if (spa_process_latency_parse(param, &process_latency) < 0) return;
-  if (spa_process_latency_info_compare(&impl->process_latency, &process_latency)
-    == 0) return;
+	if (param == NULL)
+		spa_zero(process_latency);
+	else if (spa_process_latency_parse(param, &process_latency) < 0) return;
+	if (spa_process_latency_info_compare(&impl->process_latency,
+	                                     &process_latency) == 0) return;
 
-  impl->process_latency = process_latency;
-  update_latencies(impl, true);
+	impl->process_latency = process_latency;
+	update_latencies(impl, true);
 }
 
 static void param_tag_changed(struct impl *impl, const struct spa_pod *param,
                               enum spa_direction direction) {
-  struct spa_tag_info tag;
-  const struct spa_pod *params[1] = {param};
-  void *state = NULL;
+	struct spa_tag_info tag;
+	const struct spa_pod *params[1] = {param};
+	void *state = NULL;
 
-  if (param == 0 || spa_tag_parse(param, &tag, &state) < 0) return;
+	if (param == 0 || spa_tag_parse(param, &tag, &state) < 0) return;
 
-  if (tag.direction == SPA_DIRECTION_INPUT) pw_stream_update_params(
-    impl->capture, params, 1);
-  else pw_stream_update_params(impl->playback, params, 1);
+	if (tag.direction == SPA_DIRECTION_INPUT)
+		pw_stream_update_params(impl->capture, params, 1);
+	else pw_stream_update_params(impl->playback, params, 1);
 }
 
 static void capture_state_changed(void *data, enum pw_stream_state old,
                                   enum pw_stream_state state,
                                   const char *error) {
-  struct impl *impl = data;
+	struct impl *impl = data;
 
-  switch (state) {
-  case PW_STREAM_STATE_PAUSED:
-    pw_stream_flush(impl->capture, false);
-    break;
-  case PW_STREAM_STATE_UNCONNECTED: pw_log_info("module %p: unconnected", impl);
-    pw_impl_module_schedule_destroy(impl->module);
-    break;
-  case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl, error);
-    break;
-  case PW_STREAM_STATE_STREAMING: default:
-    break;
-  }
-  return;
+	switch (state) {
+	case PW_STREAM_STATE_PAUSED:
+		pw_stream_flush(impl->capture, false);
+		break;
+	case PW_STREAM_STATE_UNCONNECTED: pw_log_info(
+			"module %p: unconnected", impl);
+		pw_impl_module_schedule_destroy(impl->module);
+		break;
+	case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl,
+	                                        error);
+		break;
+	case PW_STREAM_STATE_STREAMING: default:
+		break;
+	}
+	return;
 }
 
 static void io_changed(void *data, uint32_t id, void *area, uint32_t size) {
-  struct impl *impl = data;
-  switch (id) {
-  case SPA_IO_Position:
-    impl->position = area;
-    break;
-  default:
-    break;
-  }
+	struct impl *impl = data;
+	switch (id) {
+	case SPA_IO_Position:
+		impl->position = area;
+		break;
+	default:
+		break;
+	}
 }
 
 static void param_changed(struct impl *impl, uint32_t id,
                           const struct spa_pod *param,
                           enum spa_direction direction,
                           struct pw_stream *stream, struct pw_stream *other) {
-  int res;
+	int res;
 
-  switch (id) {
-  case SPA_PARAM_Format:
-    {
-      struct spa_audio_info_raw info;
-      spa_zero(info);
-      if (param == NULL) {
-        pw_log_info("module %p: filter deactivate", impl);
-        if (direction == SPA_DIRECTION_OUTPUT) deactivate_graph(impl);
-        impl->rate = 0;
-      } else {
-        if ((res = spa_format_audio_raw_parse(param, &info)) < 0) goto error;
-      }
-      impl->info = info;
-      break;
-    }
-  case SPA_PARAM_Props:
-    if (param != NULL)
-      spa_filter_graph_set_props(impl->graph, direction, param);
-    break;
-  case SPA_PARAM_Latency:
-    param_latency_changed(impl, param, direction);
-    break;
-  case SPA_PARAM_ProcessLatency:
-    param_process_latency_changed(impl, param, direction);
-    break;
-  case SPA_PARAM_Tag:
-    param_tag_changed(impl, param, direction);
-    break;
-  }
-  return;
+	switch (id) {
+	case SPA_PARAM_Format:
+		{
+			struct spa_audio_info_raw info;
+			spa_zero(info);
+			if (param == NULL) {
+				pw_log_info("module %p: filter deactivate",
+				            impl);
+				if (direction == SPA_DIRECTION_OUTPUT)
+					deactivate_graph(impl);
+				impl->rate = 0;
+			} else {
+				if ((res = spa_format_audio_raw_parse(
+					param, &info)) < 0) goto error;
+			}
+			impl->info = info;
+			break;
+		}
+	case SPA_PARAM_Props:
+		if (param != NULL) spa_filter_graph_set_props(
+			impl->graph, direction, param);
+		break;
+	case SPA_PARAM_Latency:
+		param_latency_changed(impl, param, direction);
+		break;
+	case SPA_PARAM_ProcessLatency:
+		param_process_latency_changed(impl, param, direction);
+		break;
+	case SPA_PARAM_Tag:
+		param_tag_changed(impl, param, direction);
+		break;
+	}
+	return;
 
 error:
-  pw_stream_set_error(
-    direction == SPA_DIRECTION_INPUT ? impl->capture : impl->playback, res,
-    "can't start graph: %s", spa_strerror(res));
+	pw_stream_set_error(
+		direction == SPA_DIRECTION_INPUT
+			? impl->capture
+			: impl->playback, res, "can't start graph: %s",
+		spa_strerror(res));
 }
 
 static void capture_param_changed(void *data, uint32_t id,
                                   const struct spa_pod *param) {
-  struct impl *impl = data;
-  param_changed(impl, id, param, SPA_DIRECTION_INPUT, impl->capture,
-                impl->playback);
+	struct impl *impl = data;
+	param_changed(impl, id, param, SPA_DIRECTION_INPUT, impl->capture,
+	              impl->playback);
 }
 
 static const struct pw_stream_events in_stream_events = {
-  PW_VERSION_STREAM_EVENTS, .destroy = capture_destroy,
-  .process = capture_process, .io_changed = io_changed,
-  .state_changed = capture_state_changed, .param_changed = capture_param_changed
+	PW_VERSION_STREAM_EVENTS, .destroy = capture_destroy,
+	.process = capture_process, .io_changed = io_changed,
+	.state_changed = capture_state_changed,
+	.param_changed = capture_param_changed
 };
 
 static void playback_state_changed(void *data, enum pw_stream_state old,
                                    enum pw_stream_state state,
                                    const char *error) {
-  struct impl *impl = data;
-  int res;
+	struct impl *impl = data;
+	int res;
 
-  switch (state) {
-  case PW_STREAM_STATE_PAUSED:
-    pw_stream_flush(impl->playback, false);
-    reset_graph(impl);
-    break;
-  case PW_STREAM_STATE_UNCONNECTED: pw_log_info("module %p: unconnected", impl);
-    pw_impl_module_schedule_destroy(impl->module);
-    break;
-  case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl, error);
-    break;
-  case PW_STREAM_STATE_STREAMING:
-    {
-      uint32_t target = impl->info.rate;
-      if (target == 0)
-        target = impl->position
-                   ? impl->position->clock.target_rate.denom
-                   : DEFAULT_RATE;
-      if (target == 0) {
-        res = -EINVAL;
-        goto error;
-      }
-      if (impl->rate != target) {
-        impl->rate = target;
-        deactivate_graph(impl);
-      }
-      if ((res = activate_graph(impl)) < 0) goto error;
-      break;
-    }
-  default:
-    break;
-  }
-  return;
+	switch (state) {
+	case PW_STREAM_STATE_PAUSED:
+		pw_stream_flush(impl->playback, false);
+		reset_graph(impl);
+		break;
+	case PW_STREAM_STATE_UNCONNECTED: pw_log_info(
+			"module %p: unconnected", impl);
+		pw_impl_module_schedule_destroy(impl->module);
+		break;
+	case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl,
+	                                        error);
+		break;
+	case PW_STREAM_STATE_STREAMING:
+		{
+			uint32_t target = impl->info.rate;
+			if (target == 0)
+				target = impl->position
+					         ? impl->position->clock.
+					         target_rate.denom
+					         : DEFAULT_RATE;
+			if (target == 0) {
+				res = -EINVAL;
+				goto error;
+			}
+			if (impl->rate != target) {
+				impl->rate = target;
+				deactivate_graph(impl);
+			}
+			if ((res = activate_graph(impl)) < 0) goto error;
+			break;
+		}
+	default:
+		break;
+	}
+	return;
 error:
-  pw_stream_set_error(impl->capture, res, "can't start graph: %s",
-                      spa_strerror(res));
+	pw_stream_set_error(impl->capture, res, "can't start graph: %s",
+	                    spa_strerror(res));
 }
 
 static void playback_param_changed(void *data, uint32_t id,
                                    const struct spa_pod *param) {
-  struct impl *impl = data;
-  param_changed(impl, id, param, SPA_DIRECTION_OUTPUT, impl->playback,
-                impl->capture);
+	struct impl *impl = data;
+	param_changed(impl, id, param, SPA_DIRECTION_OUTPUT, impl->playback,
+	              impl->capture);
 }
 
 static void playback_destroy(void *d) {
-  struct impl *impl = d;
-  spa_hook_remove(&impl->playback_listener);
-  impl->playback = NULL;
+	struct impl *impl = d;
+	spa_hook_remove(&impl->playback_listener);
+	impl->playback = NULL;
 }
 
 static const struct pw_stream_events out_stream_events = {
-  PW_VERSION_STREAM_EVENTS, .destroy = playback_destroy,
-  .process = playback_process, .io_changed = io_changed,
-  .state_changed = playback_state_changed,
-  .param_changed = playback_param_changed,
+	PW_VERSION_STREAM_EVENTS, .destroy = playback_destroy,
+	.process = playback_process, .io_changed = io_changed,
+	.state_changed = playback_state_changed,
+	.param_changed = playback_param_changed,
 };
 
 static void control_destroy(void *d) {
-  struct impl *impl = d;
-  spa_hook_remove(&impl->control_listener);
-  impl->control = NULL;
+	struct impl *impl = d;
+	spa_hook_remove(&impl->control_listener);
+	impl->control = NULL;
 }
 
 static void control_state_changed(void *data, enum pw_stream_state old,
                                   enum pw_stream_state state,
                                   const char *error) {
-  struct impl *impl = data;
+	struct impl *impl = data;
 
-  switch (state) {
-  case PW_STREAM_STATE_PAUSED:
-    pw_stream_flush(impl->control, false);
-    break;
-  case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl, error);
-    break;
-  case PW_STREAM_STATE_STREAMING: default:
-    break;
-  }
-  return;
+	switch (state) {
+	case PW_STREAM_STATE_PAUSED:
+		pw_stream_flush(impl->control, false);
+		break;
+	case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl,
+	                                        error);
+		break;
+	case PW_STREAM_STATE_STREAMING: default:
+		break;
+	}
+	return;
 }
 
 static const struct pw_stream_events control_stream_events = {
-  PW_VERSION_STREAM_EVENTS, .destroy = control_destroy,
-  .process = control_process, .io_changed = NULL,
-  .state_changed = control_state_changed, .param_changed = NULL,
+	PW_VERSION_STREAM_EVENTS, .destroy = control_destroy,
+	.process = control_process, .io_changed = NULL,
+	.state_changed = control_state_changed, .param_changed = NULL,
 };
 
 static int setup_streams(struct impl *impl) {
-  int res;
-  uint32_t i, n_params, *offs;
-  struct pw_array offsets;
-  const struct spa_pod **params = NULL;
-  struct spa_pod_dynamic_builder b;
-  struct spa_filter_graph *graph = impl->graph;
+	int res;
+	uint32_t i, n_params, *offs;
+	struct pw_array offsets;
+	const struct spa_pod **params = NULL;
+	struct spa_pod_dynamic_builder b;
+	struct spa_filter_graph *graph = impl->graph;
 
-  if (impl->control_stream_active) {
-    impl->control = pw_stream_new(impl->core, "filter control",
-                                  impl->control_props);
-    impl->control_props = NULL;
-    if (impl->control == NULL) return -errno;
+	if (impl->control_stream_active) {
+		impl->control = pw_stream_new(impl->core, "filter control",
+		                              impl->control_props);
+		impl->control_props = NULL;
+		if (impl->control == NULL) return -errno;
 
-    pw_stream_add_listener(impl->control, &impl->control_listener,
-                           &control_stream_events, impl);
+		pw_stream_add_listener(impl->control, &impl->control_listener,
+		                       &control_stream_events, impl);
 
-    uint8_t buffer[256];
-    struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
-    const struct spa_pod *param[1];
+		uint8_t buffer[256];
+		struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(
+			buffer, sizeof(buffer));
+		const struct spa_pod *param[1];
 
-    param[0] = spa_pod_builder_add_object(&bt, SPA_TYPE_OBJECT_Format,
-                                          SPA_PARAM_EnumFormat,
-                                          SPA_FORMAT_mediaType,
-                                          SPA_POD_Id(SPA_MEDIA_TYPE_application
-                                          ), SPA_FORMAT_mediaSubtype,
-                                          SPA_POD_Id(SPA_MEDIA_SUBTYPE_control));
+		param[0] = spa_pod_builder_add_object(
+			&bt, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
+			SPA_FORMAT_mediaType,
+			SPA_POD_Id(SPA_MEDIA_TYPE_application ),
+			SPA_FORMAT_mediaSubtype,
+			SPA_POD_Id(SPA_MEDIA_SUBTYPE_control));
 
-    pw_stream_connect(impl->control, PW_DIRECTION_INPUT, PW_ID_ANY,
-                      PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS |
-                      PW_STREAM_FLAG_RT_PROCESS, param, 1);
-  }
+		pw_stream_connect(impl->control, PW_DIRECTION_INPUT, PW_ID_ANY,
+		                  PW_STREAM_FLAG_AUTOCONNECT |
+		                  PW_STREAM_FLAG_MAP_BUFFERS |
+		                  PW_STREAM_FLAG_RT_PROCESS, param, 1);
+	}
 
-  impl->capture = pw_stream_new(impl->core, "filter capture",
-                                impl->capture_props);
-  impl->capture_props = NULL;
-  if (impl->capture == NULL) return -errno;
+	impl->capture = pw_stream_new(impl->core, "filter capture",
+	                              impl->capture_props);
+	impl->capture_props = NULL;
+	if (impl->capture == NULL) return -errno;
 
-  pw_stream_add_listener(impl->capture, &impl->capture_listener,
-                         &in_stream_events, impl);
+	pw_stream_add_listener(impl->capture, &impl->capture_listener,
+	                       &in_stream_events, impl);
 
-  impl->playback = pw_stream_new(impl->core, "filter playback",
-                                 impl->playback_props);
-  impl->playback_props = NULL;
-  if (impl->playback == NULL) return -errno;
+	impl->playback = pw_stream_new(impl->core, "filter playback",
+	                               impl->playback_props);
+	impl->playback_props = NULL;
+	if (impl->playback == NULL) return -errno;
 
-  pw_stream_add_listener(impl->playback, &impl->playback_listener,
-                         &out_stream_events, impl);
+	pw_stream_add_listener(impl->playback, &impl->playback_listener,
+	                       &out_stream_events, impl);
 
-  spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
-  pw_array_init(&offsets, 512);
+	spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
+	pw_array_init(&offsets, 512);
 
-  if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) == NULL) {
-    res = -errno;
-    goto done;
-  }
-  *offs = b.b.state.offset;
-  spa_format_audio_raw_build(&b.b, SPA_PARAM_EnumFormat, &impl->capture_info);
+	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) == NULL) {
+		res = -errno;
+		goto done;
+	}
+	*offs = b.b.state.offset;
+	spa_format_audio_raw_build(&b.b, SPA_PARAM_EnumFormat,
+	                           &impl->capture_info);
 
-  for (i = 0;; i++) {
-    uint32_t save = b.b.state.offset;
-    if (spa_filter_graph_enum_prop_info(graph, i, &b.b, NULL) != 1) break;
-    if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *offs = save;
-  }
+	for (i = 0;; i++) {
+		uint32_t save = b.b.state.offset;
+		if (spa_filter_graph_enum_prop_info(graph, i, &b.b, NULL) != 1)
+			break;
+		if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *
+			offs = save;
+	}
 
-  if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *offs = b.b.
-    state.offset;
-  spa_filter_graph_get_props(graph, &b.b, NULL);
+	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
+		*offs = b.b.state.offset;
+	spa_filter_graph_get_props(graph, &b.b, NULL);
 
-  if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *offs = b.b.
-    state.offset;
-  spa_process_latency_build(&b.b, SPA_PARAM_ProcessLatency,
-                            &impl->process_latency);
+	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
+		*offs = b.b.state.offset;
+	spa_process_latency_build(&b.b, SPA_PARAM_ProcessLatency,
+	                          &impl->process_latency);
 
-  n_params = pw_array_get_len(&offsets, uint32_t);
-  if (n_params == 0) {
-    res = -ENOMEM;
-    goto done;
-  }
-  if ((params = calloc(n_params, sizeof(struct spa_pod*))) == NULL) {
-    res = -errno;
-    goto done;
-  }
+	n_params = pw_array_get_len(&offsets, uint32_t);
+	if (n_params == 0) {
+		res = -ENOMEM;
+		goto done;
+	}
+	if ((params = calloc(n_params, sizeof(struct spa_pod*))) == NULL) {
+		res = -errno;
+		goto done;
+	}
 
-  offs = offsets.data;
-  for (i = 0; i < n_params; i++) params[i] = spa_pod_builder_deref(
-    &b.b, offs[i]);
+	offs = offsets.data;
+	for (i = 0; i < n_params; i++)
+		params[i] = spa_pod_builder_deref(&b.b, offs[i]);
 
-  res = pw_stream_connect(impl->capture, PW_DIRECTION_INPUT, PW_ID_ANY,
-                          PW_STREAM_FLAG_AUTOCONNECT |
-                          PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS
-                          | PW_STREAM_FLAG_ASYNC, params, n_params);
+	res = pw_stream_connect(impl->capture, PW_DIRECTION_INPUT, PW_ID_ANY,
+	                        PW_STREAM_FLAG_AUTOCONNECT |
+	                        PW_STREAM_FLAG_MAP_BUFFERS |
+	                        PW_STREAM_FLAG_RT_PROCESS |
+	                        PW_STREAM_FLAG_ASYNC, params, n_params);
 
-  spa_pod_dynamic_builder_clean(&b);
-  if (res < 0) goto done;
+	spa_pod_dynamic_builder_clean(&b);
+	if (res < 0) goto done;
 
-  n_params = 0;
-  spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
-  params[n_params++] = spa_format_audio_raw_build(
-    &b.b, SPA_PARAM_EnumFormat, &impl->playback_info);
+	n_params = 0;
+	spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
+	params[n_params++] = spa_format_audio_raw_build(
+		&b.b, SPA_PARAM_EnumFormat, &impl->playback_info);
 
-  res = pw_stream_connect(impl->playback, PW_DIRECTION_OUTPUT, PW_ID_ANY,
-                          PW_STREAM_FLAG_AUTOCONNECT |
-                          PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS
-                          | PW_STREAM_FLAG_TRIGGER, params, n_params);
-  spa_pod_dynamic_builder_clean(&b);
+	res = pw_stream_connect(impl->playback, PW_DIRECTION_OUTPUT, PW_ID_ANY,
+	                        PW_STREAM_FLAG_AUTOCONNECT |
+	                        PW_STREAM_FLAG_MAP_BUFFERS |
+	                        PW_STREAM_FLAG_RT_PROCESS |
+	                        PW_STREAM_FLAG_TRIGGER, params, n_params);
+	spa_pod_dynamic_builder_clean(&b);
 
 done:
-  free(params);
-  pw_array_clear(&offsets);
+	free(params);
+	pw_array_clear(&offsets);
 
-  return res < 0 ? res : 0;
+	return res < 0 ? res : 0;
 }
 
 static void copy_position(struct spa_audio_info_raw *dst,
                           const struct spa_audio_info_raw *src) {
-  if (SPA_FLAG_IS_SET(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED) && !
-    SPA_FLAG_IS_SET(src->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
-    for (uint32_t i = 0; i < src->channels; i++) dst->position[i] = src->
-      position[i];
-    SPA_FLAG_CLEAR(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED);
-  }
+	if (SPA_FLAG_IS_SET(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED) && !
+		SPA_FLAG_IS_SET(src->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
+		for (uint32_t i = 0; i < src->channels; i++)
+			dst->position[i] = src->position[i];
+		SPA_FLAG_CLEAR(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED);
+	}
 }
 
 static void graph_info(void *object, const struct spa_filter_graph_info *info) {
-  struct impl *impl = object;
-  struct spa_dict *props = info->props;
-  uint32_t i;
+	struct impl *impl = object;
+	struct spa_dict *props = info->props;
+	uint32_t i;
 
-  if (impl->capture_info.channels == 0) impl->capture_info.channels = info->
-    n_inputs;
-  if (impl->playback_info.channels == 0) impl->playback_info.channels = info->
-    n_outputs;
+	if (impl->capture_info.channels == 0)
+		impl->capture_info.channels = info->n_inputs;
+	if (impl->playback_info.channels == 0)
+		impl->playback_info.channels = info->n_outputs;
 
-  impl->n_inputs = info->n_inputs;
-  impl->n_outputs = info->n_outputs;
+	impl->n_inputs = info->n_inputs;
+	impl->n_outputs = info->n_outputs;
 
-  if (impl->capture_info.channels == impl->playback_info.channels) {
-    copy_position(&impl->capture_info, &impl->playback_info);
-    copy_position(&impl->playback_info, &impl->capture_info);
-  }
-  for (i = 0; props && i < props->n_items; i++) {
-    const char *k = props->items[i].key;
-    const char *s = props->items[i].value;
-    pw_log_info("%s %s", k, s);
-    if (spa_streq(k, "latency")) {
-      double latency;
-      if (spa_atod(s, &latency)) {
-        if (impl->process_latency.rate != (int32_t)latency) {
-          impl->process_latency.rate = (int32_t)latency;
-          update_latencies(impl, true);
-        }
-      }
-    }
-  }
+	if (impl->capture_info.channels == impl->playback_info.channels) {
+		copy_position(&impl->capture_info, &impl->playback_info);
+		copy_position(&impl->playback_info, &impl->capture_info);
+	}
+	for (i = 0; props && i < props->n_items; i++) {
+		const char *k = props->items[i].key;
+		const char *s = props->items[i].value;
+		pw_log_info("%s %s", k, s);
+		if (spa_streq(k, "latency")) {
+			double latency;
+			if (spa_atod(s, &latency)) {
+				if (impl->process_latency.rate != (int32_t)
+					latency) {
+					impl->process_latency.rate = (int32_t)
+						latency;
+					update_latencies(impl, true);
+				}
+			}
+		}
+	}
 }
 
 static void graph_apply_props(void *object, enum spa_direction direction,
                               const struct spa_pod *props) {
-  struct impl *impl = object;
-  pw_stream_set_param(
-    direction == SPA_DIRECTION_INPUT ? impl->capture : impl->playback,
-    SPA_PARAM_Props, props);
+	struct impl *impl = object;
+	pw_stream_set_param(
+		direction == SPA_DIRECTION_INPUT
+			? impl->capture
+			: impl->playback, SPA_PARAM_Props, props);
 }
 
 static void graph_props_changed(void *object, enum spa_direction direction) {
-  struct impl *impl = object;
-  struct spa_filter_graph *graph = impl->graph;
-  uint8_t buffer[1024];
-  struct spa_pod_dynamic_builder b;
-  const struct spa_pod *params[1];
+	struct impl *impl = object;
+	struct spa_filter_graph *graph = impl->graph;
+	uint8_t buffer[1024];
+	struct spa_pod_dynamic_builder b;
+	const struct spa_pod *params[1];
 
-  spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
-  spa_filter_graph_get_props(graph, &b.b, (struct spa_pod**)&params[0]);
+	spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
+	spa_filter_graph_get_props(graph, &b.b, (struct spa_pod**)&params[0]);
 
-  pw_stream_update_params(impl->capture, params, 1);
-  spa_pod_dynamic_builder_clean(&b);
+	pw_stream_update_params(impl->capture, params, 1);
+	spa_pod_dynamic_builder_clean(&b);
 }
 
 struct spa_filter_graph_events graph_events = {
-  SPA_VERSION_FILTER_GRAPH_EVENTS, .info = graph_info,
-  .apply_props = graph_apply_props, .props_changed = graph_props_changed,
+	SPA_VERSION_FILTER_GRAPH_EVENTS, .info = graph_info,
+	.apply_props = graph_apply_props, .props_changed = graph_props_changed,
 };
 
 static void core_error(void *data, uint32_t id, int seq, int res,
                        const char *message) {
-  struct impl *impl = data;
+	struct impl *impl = data;
 
-  if (res == -ENOENT) {
-    pw_log_info("message id:%u seq:%d res:%d (%s): %s", id, seq, res,
-                spa_strerror(res), message);
-  } else {
-    pw_log_warn("error id:%u seq:%d res:%d (%s): %s", id, seq, res,
-                spa_strerror(res), message);
-  }
+	if (res == -ENOENT) {
+		pw_log_info("message id:%u seq:%d res:%d (%s): %s", id, seq,
+		            res, spa_strerror(res), message);
+	} else {
+		pw_log_warn("error id:%u seq:%d res:%d (%s): %s", id, seq, res,
+		            spa_strerror(res), message);
+	}
 
-  if (id == PW_ID_CORE && res == -EPIPE) pw_impl_module_schedule_destroy(
-    impl->module);
+	if (id == PW_ID_CORE && res == -EPIPE)
+		pw_impl_module_schedule_destroy(impl->module);
 }
 
 static const struct pw_core_events core_events = {
-  PW_VERSION_CORE_EVENTS, .error = core_error,
+	PW_VERSION_CORE_EVENTS, .error = core_error,
 };
 
 static void core_destroy(void *d) {
-  struct impl *impl = d;
-  spa_hook_remove(&impl->core_listener);
-  impl->core = NULL;
-  pw_impl_module_schedule_destroy(impl->module);
+	struct impl *impl = d;
+	spa_hook_remove(&impl->core_listener);
+	impl->core = NULL;
+	pw_impl_module_schedule_destroy(impl->module);
 }
 
 static const struct pw_proxy_events core_proxy_events = {
-  .destroy = core_destroy,
+	.destroy = core_destroy,
 };
 
 static void impl_destroy(struct impl *impl) {
-  /* disconnect both streams before destroying any of them */
-  if (impl->capture) pw_stream_disconnect(impl->capture);
-  if (impl->playback) pw_stream_disconnect(impl->playback);
+	/* disconnect both streams before destroying any of them */
+	if (impl->capture) pw_stream_disconnect(impl->capture);
+	if (impl->playback) pw_stream_disconnect(impl->playback);
 
-  if (impl->capture) pw_stream_destroy(impl->capture);
-  if (impl->playback) pw_stream_destroy(impl->playback);
+	if (impl->capture) pw_stream_destroy(impl->capture);
+	if (impl->playback) pw_stream_destroy(impl->playback);
 
-  if (impl->core && impl->do_disconnect) pw_core_disconnect(impl->core);
+	if (impl->core && impl->do_disconnect) pw_core_disconnect(impl->core);
 
-  if (impl->handle) pw_unload_spa_handle(impl->handle);
+	if (impl->handle) pw_unload_spa_handle(impl->handle);
 
-  pw_properties_free(impl->capture_props);
-  pw_properties_free(impl->playback_props);
+	pw_properties_free(impl->capture_props);
+	pw_properties_free(impl->playback_props);
 
-  pw_properties_free(impl->props);
-  free(impl);
+	pw_properties_free(impl->props);
+	free(impl);
 }
 
 static void module_destroy(void *data) {
-  struct impl *impl = data;
-  spa_hook_remove(&impl->module_listener);
-  impl_destroy(impl);
+	struct impl *impl = data;
+	spa_hook_remove(&impl->module_listener);
+	impl_destroy(impl);
 }
 
 static const struct pw_impl_module_events module_events = {
-  PW_VERSION_IMPL_MODULE_EVENTS, .destroy = module_destroy,
+	PW_VERSION_IMPL_MODULE_EVENTS, .destroy = module_destroy,
 };
 
 static void parse_audio_info(struct pw_properties *props,
                              struct spa_audio_info_raw *info) {
-  spa_audio_info_raw_init_dict_keys(
-    info, &SPA_DICT_ITEMS(SPA_DICT_ITEM(SPA_KEY_AUDIO_FORMAT, "F32P")),
-    &props->dict, SPA_KEY_AUDIO_RATE, SPA_KEY_AUDIO_CHANNELS,
-    SPA_KEY_AUDIO_POSITION, NULL);
+	spa_audio_info_raw_init_dict_keys(
+		info,
+		&SPA_DICT_ITEMS(SPA_DICT_ITEM(SPA_KEY_AUDIO_FORMAT, "F32P")),
+		&props->dict, SPA_KEY_AUDIO_RATE, SPA_KEY_AUDIO_CHANNELS,
+		SPA_KEY_AUDIO_POSITION, NULL);
 }
 
 static void copy_props(struct impl *impl, struct pw_properties *props,
                        const char *key) {
-  const char *str;
-  if ((str = pw_properties_get(props, key)) != NULL) {
-    if (pw_properties_get(impl->capture_props, key) == NULL) pw_properties_set(
-      impl->capture_props, key, str);
-    if (pw_properties_get(impl->playback_props, key) == NULL) pw_properties_set(
-      impl->playback_props, key, str);
-  }
+	const char *str;
+	if ((str = pw_properties_get(props, key)) != NULL) {
+		if (pw_properties_get(impl->capture_props, key) == NULL)
+			pw_properties_set(impl->capture_props, key, str);
+		if (pw_properties_get(impl->playback_props, key) == NULL)
+			pw_properties_set(impl->playback_props, key, str);
+	}
 }
 
 SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
                                      const char *args) {
-  struct pw_context *context = pw_impl_module_get_context(module);
-  const struct pw_properties *p;
-  struct pw_properties *props;
-  struct impl *impl;
-  uint32_t id = pw_global_get_id(pw_impl_module_get_global(module));
-  uint32_t pid = getpid();
-  const char *str;
-  int res;
-  void *iface = NULL;
+	struct pw_context *context = pw_impl_module_get_context(module);
+	const struct pw_properties *p;
+	struct pw_properties *props;
+	struct impl *impl;
+	uint32_t id = pw_global_get_id(pw_impl_module_get_global(module));
+	uint32_t pid = getpid();
+	const char *str;
+	int res;
+	void *iface = NULL;
 
-  PW_LOG_TOPIC_INIT(mod_topic);
+	PW_LOG_TOPIC_INIT(mod_topic);
 
-  impl = calloc(1, sizeof(struct impl));
-  if (impl == NULL) return -errno;
+	impl = calloc(1, sizeof(struct impl));
+	if (impl == NULL) return -errno;
 
-  pw_log_debug("module %p: new %s", impl, args);
+	pw_log_debug("module %p: new %s", impl, args);
 
-  if (args) props = pw_properties_new_string(args);
-  else props = pw_properties_new(NULL, NULL);
+	if (args) props = pw_properties_new_string(args);
+	else props = pw_properties_new(NULL, NULL);
 
-  if (props == NULL) {
-    res = -errno;
-    pw_log_error("can't create properties: %m");
-    goto error;
-  }
-  impl->props = props;
+	if (props == NULL) {
+		res = -errno;
+		pw_log_error("can't create properties: %m");
+		goto error;
+	}
+	impl->props = props;
 
-  impl->capture_props = pw_properties_new(NULL, NULL);
-  impl->playback_props = pw_properties_new(NULL, NULL);
-  impl->control_props = pw_properties_new(NULL, NULL);
-  if (impl->capture_props == NULL || impl->playback_props == NULL || impl->
-    control_props == NULL) {
-    res = -errno;
-    pw_log_error("can't create properties: %m");
-    goto error;
-  }
+	impl->capture_props = pw_properties_new(NULL, NULL);
+	impl->playback_props = pw_properties_new(NULL, NULL);
+	impl->control_props = pw_properties_new(NULL, NULL);
+	if (impl->capture_props == NULL || impl->playback_props == NULL || impl
+		->control_props == NULL) {
+		res = -errno;
+		pw_log_error("can't create properties: %m");
+		goto error;
+	}
 
-  impl->module = module;
-  impl->context = context;
-  impl->latency[SPA_DIRECTION_INPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_INPUT);
-  impl->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_OUTPUT);
+	impl->module = module;
+	impl->context = context;
+	impl->latency[SPA_DIRECTION_INPUT] = SPA_LATENCY_INFO(
+		SPA_DIRECTION_INPUT);
+	impl->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(
+		SPA_DIRECTION_OUTPUT);
 
-  if (pw_properties_get(props, PW_KEY_NODE_GROUP) == NULL) pw_properties_setf(
-    props, PW_KEY_NODE_GROUP, "filter-chain-%u-%u", pid, id);
-  if (pw_properties_get(props, PW_KEY_NODE_LINK_GROUP) == NULL)
-    pw_properties_setf(props, PW_KEY_NODE_LINK_GROUP, "filter-chain-%u-%u", pid,
-                       id);
-  if (pw_properties_get(props, PW_KEY_NODE_VIRTUAL) == NULL) pw_properties_set(
-    props, PW_KEY_NODE_VIRTUAL, "true");
-  if (pw_properties_get(props, "resample.prefill") == NULL) pw_properties_set(
-    props, "resample.prefill", "true");
-  if (pw_properties_get(props, PW_KEY_NODE_DESCRIPTION) == NULL)
-    pw_properties_setf(props, PW_KEY_NODE_DESCRIPTION, "filter-chain-%u-%u",
-                       pid, id);
+	if (pw_properties_get(props, PW_KEY_NODE_GROUP) == NULL)
+		pw_properties_setf(props, PW_KEY_NODE_GROUP,
+		                   "filter-chain-%u-%u", pid, id);
+	if (pw_properties_get(props, PW_KEY_NODE_LINK_GROUP) == NULL)
+		pw_properties_setf(props, PW_KEY_NODE_LINK_GROUP,
+		                   "filter-chain-%u-%u", pid, id);
+	if (pw_properties_get(props, PW_KEY_NODE_VIRTUAL) == NULL)
+		pw_properties_set(props, PW_KEY_NODE_VIRTUAL, "true");
+	if (pw_properties_get(props, "resample.prefill") == NULL)
+		pw_properties_set(props, "resample.prefill", "true");
+	if (pw_properties_get(props, PW_KEY_NODE_DESCRIPTION) == NULL)
+		pw_properties_setf(props, PW_KEY_NODE_DESCRIPTION,
+		                   "filter-chain-%u-%u", pid, id);
 
-  if ((str = pw_properties_get(props, "capture.props")) != NULL)
-    pw_properties_update_string(impl->capture_props, str, strlen(str));
-  if ((str = pw_properties_get(props, "playback.props")) != NULL)
-    pw_properties_update_string(impl->playback_props, str, strlen(str));
-  if ((str = pw_properties_get(props, "control.props")) != NULL)
-    pw_properties_update_string(impl->control_props, str, strlen(str));
+	if ((str = pw_properties_get(props, "capture.props")) != NULL)
+		pw_properties_update_string(impl->capture_props, str,
+		                            strlen(str));
+	if ((str = pw_properties_get(props, "playback.props")) != NULL)
+		pw_properties_update_string(impl->playback_props, str,
+		                            strlen(str));
+	if ((str = pw_properties_get(props, "control.props")) != NULL)
+		pw_properties_update_string(impl->control_props, str,
+		                            strlen(str));
 
-  copy_props(impl, props, PW_KEY_AUDIO_RATE);
-  copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
-  copy_props(impl, props, SPA_KEY_AUDIO_POSITION);
-  copy_props(impl, props, PW_KEY_NODE_DESCRIPTION);
-  copy_props(impl, props, PW_KEY_NODE_GROUP);
-  copy_props(impl, props, PW_KEY_NODE_LINK_GROUP);
-  copy_props(impl, props, PW_KEY_NODE_LATENCY);
-  copy_props(impl, props, PW_KEY_NODE_VIRTUAL);
-  copy_props(impl, props, PW_KEY_MEDIA_NAME);
-  copy_props(impl, props, "resample.prefill");
+	copy_props(impl, props, PW_KEY_AUDIO_RATE);
+	copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
+	copy_props(impl, props, SPA_KEY_AUDIO_POSITION);
+	copy_props(impl, props, PW_KEY_NODE_DESCRIPTION);
+	copy_props(impl, props, PW_KEY_NODE_GROUP);
+	copy_props(impl, props, PW_KEY_NODE_LINK_GROUP);
+	copy_props(impl, props, PW_KEY_NODE_LATENCY);
+	copy_props(impl, props, PW_KEY_NODE_VIRTUAL);
+	copy_props(impl, props, PW_KEY_MEDIA_NAME);
+	copy_props(impl, props, "resample.prefill");
 
-  parse_audio_info(impl->capture_props, &impl->capture_info);
-  parse_audio_info(impl->playback_props, &impl->playback_info);
+	parse_audio_info(impl->capture_props, &impl->capture_info);
+	parse_audio_info(impl->playback_props, &impl->playback_info);
 
-  if (!impl->capture_info.rate && !impl->playback_info.rate) {
-    if (pw_properties_get(impl->playback_props, "resample.disable") == NULL)
-      pw_properties_set(impl->playback_props, "resample.disable", "true");
-    if (pw_properties_get(impl->capture_props, "resample.disable") == NULL)
-      pw_properties_set(impl->capture_props, "resample.disable", "true");
-  } else if (impl->capture_info.rate && !impl->playback_info.rate) impl->
-    playback_info.rate = impl->capture_info.rate;
-  else if (impl->playback_info.rate && !impl->capture_info.rate) impl->
-    capture_info.rate = !impl->playback_info.rate;
-  else if (impl->capture_info.rate != impl->playback_info.rate) {
-    pw_log_warn(
-      "Both capture and playback rate are set, but"
-      " they are different. Using the highest of two. This behaviour"
-      " is deprecated, please use equal rates in the module config");
-    impl->playback_info.rate = impl->capture_info.rate = SPA_MAX(
-      impl->playback_info.rate, impl->capture_info.rate);
-  }
+	if (!impl->capture_info.rate && !impl->playback_info.rate) {
+		if (pw_properties_get(impl->playback_props, "resample.disable")
+			== NULL) pw_properties_set(
+			impl->playback_props, "resample.disable", "true");
+		if (pw_properties_get(impl->capture_props, "resample.disable")
+			== NULL) pw_properties_set(
+			impl->capture_props, "resample.disable", "true");
+	} else if (impl->capture_info.rate && !impl->playback_info.rate)
+		impl->playback_info.rate = impl->capture_info.rate;
+	else if (impl->playback_info.rate && !impl->capture_info.rate)
+		impl->capture_info.rate = !impl->playback_info.rate;
+	else if (impl->capture_info.rate != impl->playback_info.rate) {
+		pw_log_warn(
+			"Both capture and playback rate are set, but"
+			" they are different. Using the highest of two. This behaviour"
+			" is deprecated, please use equal rates in the module config");
+		impl->playback_info.rate = impl->capture_info.rate = SPA_MAX(
+			impl->playback_info.rate, impl->capture_info.rate);
+	}
 
-  if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
-    pw_properties_setf(props, PW_KEY_NODE_NAME, "filter-chain-%u-%u", pid, id);
-    str = pw_properties_get(props, PW_KEY_NODE_NAME);
-  }
-  if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
-    pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME, "input.%s", str);
-  if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
-    pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME, "output.%s",
-                       str);
+	if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
+		pw_properties_setf(props, PW_KEY_NODE_NAME,
+		                   "filter-chain-%u-%u", pid, id);
+		str = pw_properties_get(props, PW_KEY_NODE_NAME);
+	}
+	if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
+		pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME,
+		                   "input.%s", str);
+	if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
+		pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME,
+		                   "output.%s", str);
 
-  if (pw_properties_get(impl->capture_props, PW_KEY_MEDIA_NAME) == NULL)
-    pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME, "%s input",
-                       pw_properties_get(impl->capture_props,
-                                         PW_KEY_NODE_DESCRIPTION));
-  if (pw_properties_get(impl->playback_props, PW_KEY_MEDIA_NAME) == NULL)
-    pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME, "%s output",
-                       pw_properties_get(impl->playback_props,
-                                         PW_KEY_NODE_DESCRIPTION));
+	if (pw_properties_get(impl->capture_props, PW_KEY_MEDIA_NAME) == NULL)
+		pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME,
+		                   "%s input",
+		                   pw_properties_get(impl->capture_props,
+			                   PW_KEY_NODE_DESCRIPTION));
+	if (pw_properties_get(impl->playback_props, PW_KEY_MEDIA_NAME) == NULL)
+		pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME,
+		                   "%s output",
+		                   pw_properties_get(impl->playback_props,
+			                   PW_KEY_NODE_DESCRIPTION));
 
-  p = pw_context_get_properties(impl->context);
-  pw_properties_set(props, "clock.quantum-limit",
-                    pw_properties_get(p, "default.clock.quantum-limit"));
+	p = pw_context_get_properties(impl->context);
+	pw_properties_set(props, "clock.quantum-limit",
+	                  pw_properties_get(p, "default.clock.quantum-limit"));
 
-  pw_properties_setf(props, "filter-graph.n_inputs", "%d",
-                     impl->capture_info.channels);
-  pw_properties_setf(props, "filter-graph.n_outputs", "%d",
-                     impl->playback_info.channels);
+	pw_properties_setf(props, "filter-graph.n_inputs", "%d",
+	                   impl->capture_info.channels);
+	pw_properties_setf(props, "filter-graph.n_outputs", "%d",
+	                   impl->playback_info.channels);
 
-  pw_properties_set(props, SPA_KEY_LIBRARY_NAME,
-                    "filter-graph/libspa-filter-graph");
-  impl->handle = pw_context_load_spa_handle(impl->context, "filter.graph",
-                                            &props->dict);
-  if (impl->handle == NULL) {
-    res = -errno;
-    goto error;
-  }
+	pw_properties_set(props, SPA_KEY_LIBRARY_NAME,
+	                  "filter-graph/libspa-filter-graph");
+	impl->handle = pw_context_load_spa_handle(impl->context, "filter.graph",
+	                                          &props->dict);
+	if (impl->handle == NULL) {
+		res = -errno;
+		goto error;
+	}
 
-  res = spa_handle_get_interface(impl->handle, SPA_TYPE_INTERFACE_FilterGraph,
-                                 &iface);
-  if (res < 0 || iface == NULL) goto error;
+	res = spa_handle_get_interface(impl->handle,
+	                               SPA_TYPE_INTERFACE_FilterGraph, &iface);
+	if (res < 0 || iface == NULL) goto error;
 
-  impl->graph = iface;
+	impl->graph = iface;
 
-  spa_filter_graph_add_listener(impl->graph, &impl->graph_listener,
-                                &graph_events, impl);
+	spa_filter_graph_add_listener(impl->graph, &impl->graph_listener,
+	                              &graph_events, impl);
 
-  impl->core = pw_context_get_object(impl->context, PW_TYPE_INTERFACE_Core);
-  if (impl->core == NULL) {
-    str = pw_properties_get(props, PW_KEY_REMOTE_NAME);
-    impl->core = pw_context_connect(impl->context,
-                                    pw_properties_new(
-                                      PW_KEY_REMOTE_NAME, str, NULL), 0);
-    impl->do_disconnect = true;
-  }
-  if (impl->core == NULL) {
-    res = -errno;
-    pw_log_error("can't connect: %m");
-    goto error;
-  }
+	impl->core = pw_context_get_object(impl->context,
+	                                   PW_TYPE_INTERFACE_Core);
+	if (impl->core == NULL) {
+		str = pw_properties_get(props, PW_KEY_REMOTE_NAME);
+		impl->core = pw_context_connect(impl->context,
+		                                pw_properties_new(
+			                                PW_KEY_REMOTE_NAME, str,
+			                                NULL), 0);
+		impl->do_disconnect = true;
+	}
+	if (impl->core == NULL) {
+		res = -errno;
+		pw_log_error("can't connect: %m");
+		goto error;
+	}
 
-  pw_proxy_add_listener((struct pw_proxy*)impl->core,
-                        &impl->core_proxy_listener, &core_proxy_events, impl);
-  pw_core_add_listener(impl->core, &impl->core_listener, &core_events, impl);
+	pw_proxy_add_listener((struct pw_proxy*)impl->core,
+	                      &impl->core_proxy_listener, &core_proxy_events,
+	                      impl);
+	pw_core_add_listener(impl->core, &impl->core_listener, &core_events,
+	                     impl);
 
-  if (pw_properties_get(impl->control_props, "enabled") == NULL) {
-    impl->control_stream_active = false;
-  } else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "true")
-    == 0) {
-    impl->control_stream_active = true;
-  } else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "false")
-    == 0) {
-    impl->control_stream_active = false;
-  }
+	if (pw_properties_get(impl->control_props, "enabled") == NULL) {
+		impl->control_stream_active = false;
+	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"),
+	                  "true") == 0) {
+		impl->control_stream_active = true;
+	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"),
+	                  "false") == 0) {
+		impl->control_stream_active = false;
+	}
 
-  setup_streams(impl);
+	setup_streams(impl);
 
-  pw_impl_module_add_listener(module, &impl->module_listener, &module_events,
-                              impl);
+	pw_impl_module_add_listener(module, &impl->module_listener,
+	                            &module_events, impl);
 
-  pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
+	pw_impl_module_update_properties(
+		module, &SPA_DICT_INIT_ARRAY(module_props));
 
-  return 0;
+	return 0;
 
 error:
 
-  impl_destroy(impl);
-  return res;
+	impl_destroy(impl);
+	return res;
 }

From 3d3f34d4b9d4da5a5a6d1179a9871bcb1c745f9b Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sat, 16 Aug 2025 21:37:18 -0400
Subject: [PATCH 10/26] formatting

---
 src/modules/module-filter-chain.c | 796 ++++++++++++++++--------------
 1 file changed, 415 insertions(+), 381 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 61afd49ab..4af6bf528 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1106,31 +1106,38 @@ extern struct spa_handle_factory spa_filter_graph_factory;
  *\endcode
  */
 static const struct spa_dict_item module_props[] = {
-	{PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>"},
-	{PW_KEY_MODULE_DESCRIPTION, "Create filter chain streams"},
-	{
-		PW_KEY_MODULE_USAGE,
-		" ( remote.name=<remote> ) "
-		"( node.latency=<latency as fraction> ) "
-		"( node.description=<description of the nodes> ) "
-		"( audio.rate=<sample rate> ) "
-		"( audio.channels=<number of channels> ) "
-		"( audio.position=<channel map> ) " "filter.graph = [ "
-		"    nodes = [ " "        { "
-		"          type = <ladspa | lv2 | builtin | sofa> "
-		"          name = <name> " "          plugin = <plugin> "
-		"          label = <label> " "          config = { "
-		"             <configkey> = <value> ... " "          } "
-		"          control = { "
-		"             <controlname|controlindex> = <value> ... "
-		"          } " "        } " "    ] " "    links = [ "
-		"        { output = <portname> input = <portname> } ... "
-		"    ] " "    inputs = [ <portname> ... ] "
-		"    outputs = [ <portname> ... ] " "] "
-		"( capture.props=<properties> ) "
-		"( playback.props=<properties> ) "
-	},
-	{PW_KEY_MODULE_VERSION, PACKAGE_VERSION},
+	{ PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
+	{ PW_KEY_MODULE_DESCRIPTION, "Create filter chain streams" },
+	{ PW_KEY_MODULE_USAGE, " ( remote.name=<remote> ) "
+				"( node.latency=<latency as fraction> ) "
+				"( node.description=<description of the nodes> ) "
+				"( audio.rate=<sample rate> ) "
+				"( audio.channels=<number of channels> ) "
+				"( audio.position=<channel map> ) "
+				"filter.graph = [ "
+				"    nodes = [ "
+				"        { "
+				"          type = <ladspa | lv2 | builtin | sofa> "
+				"          name = <name> "
+				"          plugin = <plugin> "
+				"          label = <label> "
+				"          config = { "
+				"             <configkey> = <value> ... "
+				"          } "
+				"          control = { "
+				"             <controlname|controlindex> = <value> ... "
+				"          } "
+				"        } "
+				"    ] "
+				"    links = [ "
+				"        { output = <portname> input = <portname> } ... "
+				"    ] "
+				"    inputs = [ <portname> ... ] "
+				"    outputs = [ <portname> ... ] "
+				"] "
+				"( capture.props=<properties> ) "
+				"( playback.props=<properties> ) " },
+	{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
 };
 
 #include <unistd.h>
@@ -1175,13 +1182,13 @@ struct impl {
 	struct pw_properties *control_props;
 	struct pw_stream *control;
 	struct spa_hook control_listener;
-	bool control_stream_active;
+  bool control_stream_active;
 
 	struct spa_audio_info_raw info;
 
 	struct spa_io_position *position;
 
-	unsigned int do_disconnect : 1;
+	unsigned int do_disconnect:1;
 
 	long unsigned rate;
 
@@ -1196,21 +1203,23 @@ struct impl {
 	struct spa_process_latency_info process_latency;
 };
 
-static void capture_destroy(void *d) {
+static void capture_destroy(void *d)
+{
 	struct impl *impl = d;
 	spa_hook_remove(&impl->capture_listener);
 	impl->capture = NULL;
 }
 
-static void capture_process(void *d) {
+static void capture_process(void *d)
+{
 	struct impl *impl = d;
 	int res;
 	if ((res = pw_stream_trigger_process(impl->playback)) < 0) {
 		pw_log_debug("playback trigger error: %s", spa_strerror(res));
 		while (true) {
 			struct pw_buffer *t;
-			if ((t = pw_stream_dequeue_buffer(impl->capture)) ==
-				NULL) break;
+			if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL)
+				break;
 			/* playback part is not ready, consume, discard and recycle
 			 * the capture buffers */
 			pw_stream_queue_buffer(impl->capture, t);
@@ -1218,53 +1227,48 @@ static void capture_process(void *d) {
 	}
 }
 
-static int apply_props(struct spa_loop *loop, bool async, uint32_t seq,
-                       const void *data, size_t size, void *user_data) {
-	const struct impl *impl = user_data;
-	const struct spa_pod *props = data;
-	spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
-	return 0;
+static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
+{
+  const struct impl *impl = user_data;
+  const struct spa_pod *props = data;
+  spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
+  return 0;
 }
 
-static void control_process(void *d) {
+static void control_process(void *d)
+{
 	struct impl *impl = d;
 
-	struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
-	if (control == NULL) goto done;
-	if (control->buffer->n_datas > 0) {
-		struct spa_pod *pod = spa_pod_from_data(
-			control->buffer->datas[0].data,
-			control->buffer->datas[0].maxsize,
-			control->buffer->datas[0].chunk->offset,
-			control->buffer->datas[0].chunk->size);
+  struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
+  if (control == NULL)
+    goto done;
+  if (control->buffer->n_datas > 0) {
+    struct spa_pod *pod = spa_pod_from_data(
+      control->buffer->datas[0].data,
+      control->buffer->datas[0].maxsize,
+      control->buffer->datas[0].chunk->offset,
+      control->buffer->datas[0].chunk->size);
 
-		if (spa_pod_is_sequence(pod)) {
-			struct spa_pod_sequence *sequence = (struct
-				spa_pod_sequence*)pod;
+    if (spa_pod_is_sequence(pod)) {
+      struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
 
-			struct spa_pod_control *pod_control;
-			SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
-				if (pod_control->type ==
-					SPA_CONTROL_Properties) {
-					struct pw_loop *loop =
-						pw_context_get_main_loop(
-							impl->context);
-					pw_loop_invoke(
-						loop, apply_props, 0,
-						&pod_control->value,
-						SPA_POD_SIZE(
-							&pod_control->value),
-						false, impl);
-				}
-			}
-		}
-	}
+      struct spa_pod_control *pod_control;
+      SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
+        if (pod_control->type == SPA_CONTROL_Properties) {
+            struct pw_loop *loop = pw_context_get_main_loop(impl->context);
+            pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
+              SPA_POD_SIZE(&pod_control->value), false, impl);
+        }
+      }
+    }
+  }
 
-done:
-	pw_stream_queue_buffer(impl->control, control);
+  done:
+    pw_stream_queue_buffer(impl->control, control);
 }
 
-static void playback_process(void *d) {
+static void playback_process(void *d)
+{
 	struct impl *impl = d;
 	struct pw_buffer *in, *out;
 	uint32_t i, data_size = 0;
@@ -1276,9 +1280,10 @@ static void playback_process(void *d) {
 	in = NULL;
 	while (true) {
 		struct pw_buffer *t;
-		if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL) break
-			;
-		if (in) pw_stream_queue_buffer(impl->capture, in);
+		if ((t = pw_stream_dequeue_buffer(impl->capture)) == NULL)
+			break;
+		if (in)
+			pw_stream_queue_buffer(impl->capture, in);
 		in = t;
 	}
 	if (in == NULL)
@@ -1287,7 +1292,8 @@ static void playback_process(void *d) {
 	if ((out = pw_stream_dequeue_buffer(impl->playback)) == NULL)
 		pw_log_debug("%p: out of playback buffers: %m", impl);
 
-	if (in == NULL || out == NULL) goto done;
+	if (in == NULL || out == NULL)
+		goto done;
 
 	for (i = 0; i < in->buffer->n_datas; i++) {
 		uint32_t offs, size;
@@ -1302,7 +1308,8 @@ static void playback_process(void *d) {
 		data_size = i == 0 ? size : SPA_MIN(data_size, size);
 		stride = SPA_MAX(stride, bd->chunk->stride);
 	}
-	for (; i < impl->n_inputs; i++) cin[i] = NULL;
+	for (; i < impl->n_inputs; i++)
+		cin[i] = NULL;
 
 	for (i = 0; i < out->buffer->n_datas; i++) {
 		bd = &out->buffer->datas[i];
@@ -1315,36 +1322,36 @@ static void playback_process(void *d) {
 		bd->chunk->size = data_size;
 		bd->chunk->stride = stride;
 	}
-	for (; i < impl->n_outputs; i++) cout[i] = NULL;
+	for (; i < impl->n_outputs; i++)
+		cout[i] = NULL;
 
-	pw_log_trace_fp("%p: stride:%d size:%d requested:%"PRIu64" (%"PRIu64")",
-	                impl, stride, data_size, out->requested,
-	                out->requested * stride);
+	pw_log_trace_fp("%p: stride:%d size:%d requested:%"PRIu64" (%"PRIu64")", impl,
+			stride, data_size, out->requested, out->requested * stride);
 
 	if (impl->graph_active)
-		spa_filter_graph_process(impl->graph, cin, cout,
-		                         data_size / sizeof(float));
+		spa_filter_graph_process(impl->graph, cin, cout, data_size / sizeof(float));
 
 done:
-	if (in != NULL) pw_stream_queue_buffer(impl->capture, in);
-	if (out != NULL) pw_stream_queue_buffer(impl->playback, out);
+	if (in != NULL)
+		pw_stream_queue_buffer(impl->capture, in);
+	if (out != NULL)
+		pw_stream_queue_buffer(impl->playback, out);
 }
 
-static int activate_graph(struct impl *impl) {
+static int activate_graph(struct impl *impl)
+{
 	char rate[64];
 	int res;
 
-	if (impl->graph_active) return 0;
+	if (impl->graph_active)
+		return 0;
 
 	snprintf(rate, sizeof(rate), "%lu", impl->rate);
-	res = spa_filter_graph_activate(impl->graph,
-	                                &SPA_DICT_ITEMS(
-		                                SPA_DICT_ITEM(SPA_KEY_AUDIO_RATE
-			                                , rate)));
+	res = spa_filter_graph_activate(impl->graph, &SPA_DICT_ITEMS(
+				SPA_DICT_ITEM(SPA_KEY_AUDIO_RATE, rate)));
 
 	if (res >= 0) {
-		struct pw_loop *data_loop = pw_stream_get_data_loop(
-			impl->playback);
+		struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
 		pw_loop_lock(data_loop);
 		impl->graph_active = true;
 		pw_loop_unlock(data_loop);
@@ -1352,10 +1359,12 @@ static int activate_graph(struct impl *impl) {
 	return res;
 }
 
-static int deactivate_graph(struct impl *impl) {
+static int deactivate_graph(struct impl *impl)
+{
 	struct pw_loop *data_loop;
 
-	if (!impl->graph_active) return 0;
+	if (!impl->graph_active)
+		return 0;
 
 	data_loop = pw_stream_get_data_loop(impl->playback);
 
@@ -1366,7 +1375,8 @@ static int deactivate_graph(struct impl *impl) {
 	return spa_filter_graph_deactivate(impl->graph);
 }
 
-static int reset_graph(struct impl *impl) {
+static int reset_graph(struct impl *impl)
+{
 	struct pw_loop *data_loop = pw_stream_get_data_loop(impl->playback);
 	int res;
 	bool old_active = impl->graph_active;
@@ -1384,16 +1394,15 @@ static int reset_graph(struct impl *impl) {
 	return res;
 }
 
-static void update_latency(struct impl *impl, enum spa_direction direction,
-                           bool process) {
+static void update_latency(struct impl *impl, enum spa_direction direction, bool process)
+{
 	struct spa_latency_info latency;
 	uint8_t buffer[1024];
 	struct spa_pod_builder b;
 	const struct spa_pod *params[2];
 	uint32_t n_params = 0;
-	struct pw_stream *s = direction == SPA_DIRECTION_OUTPUT
-		                      ? impl->playback
-		                      : impl->capture;
+	struct pw_stream *s = direction == SPA_DIRECTION_OUTPUT ?
+		impl->playback : impl->capture;
 
 	spa_pod_builder_init(&b, buffer, sizeof(buffer));
 	latency = impl->latency[direction];
@@ -1401,79 +1410,87 @@ static void update_latency(struct impl *impl, enum spa_direction direction,
 	params[n_params++] = spa_latency_build(&b, SPA_PARAM_Latency, &latency);
 
 	if (process) {
-		params[n_params++] = spa_process_latency_build(
-			&b, SPA_PARAM_ProcessLatency, &impl->process_latency);
+		params[n_params++] = spa_process_latency_build(&b,
+				SPA_PARAM_ProcessLatency, &impl->process_latency);
 	}
 	pw_stream_update_params(s, params, n_params);
 }
 
-static void update_latencies(struct impl *impl, bool process) {
+static void update_latencies(struct impl *impl, bool process)
+{
 	update_latency(impl, SPA_DIRECTION_INPUT, process);
 	update_latency(impl, SPA_DIRECTION_OUTPUT, process);
 }
 
-static void param_latency_changed(struct impl *impl,
-                                  const struct spa_pod *param,
-                                  enum spa_direction direction) {
+static void param_latency_changed(struct impl *impl, const struct spa_pod *param,
+		enum spa_direction direction)
+{
 	struct spa_latency_info latency;
 
-	if (param == NULL || spa_latency_parse(param, &latency) < 0) return;
+	if (param == NULL || spa_latency_parse(param, &latency) < 0)
+		return;
 
 	impl->latency[latency.direction] = latency;
 	update_latency(impl, latency.direction, false);
 }
 
-static void param_process_latency_changed(struct impl *impl,
-                                          const struct spa_pod *param,
-                                          enum spa_direction direction) {
+static void param_process_latency_changed(struct impl *impl, const struct spa_pod *param,
+		enum spa_direction direction)
+{
 	struct spa_process_latency_info process_latency;
 
 	if (param == NULL)
 		spa_zero(process_latency);
-	else if (spa_process_latency_parse(param, &process_latency) < 0) return;
-	if (spa_process_latency_info_compare(&impl->process_latency,
-	                                     &process_latency) == 0) return;
+	else if (spa_process_latency_parse(param, &process_latency) < 0)
+		return;
+	if (spa_process_latency_info_compare(&impl->process_latency, &process_latency) == 0)
+		return;
 
 	impl->process_latency = process_latency;
 	update_latencies(impl, true);
 }
 
 static void param_tag_changed(struct impl *impl, const struct spa_pod *param,
-                              enum spa_direction direction) {
+		enum spa_direction direction)
+{
 	struct spa_tag_info tag;
-	const struct spa_pod *params[1] = {param};
+	const struct spa_pod *params[1] = { param };
 	void *state = NULL;
 
-	if (param == 0 || spa_tag_parse(param, &tag, &state) < 0) return;
+	if (param == 0 || spa_tag_parse(param, &tag, &state) < 0)
+		return;
 
 	if (tag.direction == SPA_DIRECTION_INPUT)
 		pw_stream_update_params(impl->capture, params, 1);
-	else pw_stream_update_params(impl->playback, params, 1);
+	else
+		pw_stream_update_params(impl->playback, params, 1);
 }
 
 static void capture_state_changed(void *data, enum pw_stream_state old,
-                                  enum pw_stream_state state,
-                                  const char *error) {
+		enum pw_stream_state state, const char *error)
+{
 	struct impl *impl = data;
 
 	switch (state) {
 	case PW_STREAM_STATE_PAUSED:
 		pw_stream_flush(impl->capture, false);
 		break;
-	case PW_STREAM_STATE_UNCONNECTED: pw_log_info(
-			"module %p: unconnected", impl);
+	case PW_STREAM_STATE_UNCONNECTED:
+		pw_log_info("module %p: unconnected", impl);
 		pw_impl_module_schedule_destroy(impl->module);
 		break;
-	case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl,
-	                                        error);
+	case PW_STREAM_STATE_ERROR:
+		pw_log_info("module %p: error: %s", impl, error);
 		break;
-	case PW_STREAM_STATE_STREAMING: default:
+	case PW_STREAM_STATE_STREAMING:
+	default:
 		break;
 	}
 	return;
 }
 
-static void io_changed(void *data, uint32_t id, void *area, uint32_t size) {
+static void io_changed(void *data, uint32_t id, void *area, uint32_t size)
+{
 	struct impl *impl = data;
 	switch (id) {
 	case SPA_IO_Position:
@@ -1484,33 +1501,31 @@ static void io_changed(void *data, uint32_t id, void *area, uint32_t size) {
 	}
 }
 
-static void param_changed(struct impl *impl, uint32_t id,
-                          const struct spa_pod *param,
-                          enum spa_direction direction,
-                          struct pw_stream *stream, struct pw_stream *other) {
+static void param_changed(struct impl *impl, uint32_t id, const struct spa_pod *param,
+		enum spa_direction direction, struct pw_stream *stream, struct pw_stream *other)
+{
 	int res;
 
 	switch (id) {
 	case SPA_PARAM_Format:
-		{
-			struct spa_audio_info_raw info;
-			spa_zero(info);
-			if (param == NULL) {
-				pw_log_info("module %p: filter deactivate",
-				            impl);
-				if (direction == SPA_DIRECTION_OUTPUT)
-					deactivate_graph(impl);
-				impl->rate = 0;
-			} else {
-				if ((res = spa_format_audio_raw_parse(
-					param, &info)) < 0) goto error;
-			}
-			impl->info = info;
-			break;
+	{
+		struct spa_audio_info_raw info;
+		spa_zero(info);
+		if (param == NULL) {
+			pw_log_info("module %p: filter deactivate", impl);
+			if (direction == SPA_DIRECTION_OUTPUT)
+				deactivate_graph(impl);
+			impl->rate = 0;
+		} else {
+			if ((res = spa_format_audio_raw_parse(param, &info)) < 0)
+				goto error;
 		}
+		impl->info = info;
+		break;
+	}
 	case SPA_PARAM_Props:
-		if (param != NULL) spa_filter_graph_set_props(
-			impl->graph, direction, param);
+		if (param != NULL)
+			spa_filter_graph_set_props(impl->graph, direction, param);
 		break;
 	case SPA_PARAM_Latency:
 		param_latency_changed(impl, param, direction);
@@ -1525,30 +1540,28 @@ static void param_changed(struct impl *impl, uint32_t id,
 	return;
 
 error:
-	pw_stream_set_error(
-		direction == SPA_DIRECTION_INPUT
-			? impl->capture
-			: impl->playback, res, "can't start graph: %s",
-		spa_strerror(res));
+	pw_stream_set_error(direction == SPA_DIRECTION_INPUT ? impl->capture : impl->playback,
+			res, "can't start graph: %s", spa_strerror(res));
 }
 
-static void capture_param_changed(void *data, uint32_t id,
-                                  const struct spa_pod *param) {
+static void capture_param_changed(void *data, uint32_t id, const struct spa_pod *param)
+{
 	struct impl *impl = data;
-	param_changed(impl, id, param, SPA_DIRECTION_INPUT, impl->capture,
-	              impl->playback);
+	param_changed(impl, id, param, SPA_DIRECTION_INPUT, impl->capture, impl->playback);
 }
 
 static const struct pw_stream_events in_stream_events = {
-	PW_VERSION_STREAM_EVENTS, .destroy = capture_destroy,
-	.process = capture_process, .io_changed = io_changed,
+	PW_VERSION_STREAM_EVENTS,
+	.destroy = capture_destroy,
+	.process = capture_process,
+	.io_changed = io_changed,
 	.state_changed = capture_state_changed,
 	.param_changed = capture_param_changed
 };
 
 static void playback_state_changed(void *data, enum pw_stream_state old,
-                                   enum pw_stream_state state,
-                                   const char *error) {
+		enum pw_stream_state state, const char *error)
+{
 	struct impl *impl = data;
 	int res;
 
@@ -1557,92 +1570,99 @@ static void playback_state_changed(void *data, enum pw_stream_state old,
 		pw_stream_flush(impl->playback, false);
 		reset_graph(impl);
 		break;
-	case PW_STREAM_STATE_UNCONNECTED: pw_log_info(
-			"module %p: unconnected", impl);
+	case PW_STREAM_STATE_UNCONNECTED:
+		pw_log_info("module %p: unconnected", impl);
 		pw_impl_module_schedule_destroy(impl->module);
 		break;
-	case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl,
-	                                        error);
+	case PW_STREAM_STATE_ERROR:
+		pw_log_info("module %p: error: %s", impl, error);
 		break;
 	case PW_STREAM_STATE_STREAMING:
-		{
-			uint32_t target = impl->info.rate;
-			if (target == 0)
-				target = impl->position
-					         ? impl->position->clock.
-					         target_rate.denom
-					         : DEFAULT_RATE;
-			if (target == 0) {
-				res = -EINVAL;
-				goto error;
-			}
-			if (impl->rate != target) {
-				impl->rate = target;
-				deactivate_graph(impl);
-			}
-			if ((res = activate_graph(impl)) < 0) goto error;
-			break;
+	{
+		uint32_t target = impl->info.rate;
+		if (target == 0)
+			target = impl->position ?
+				impl->position->clock.target_rate.denom : DEFAULT_RATE;
+		if (target == 0) {
+			res = -EINVAL;
+			goto error;
 		}
+		if (impl->rate != target) {
+			impl->rate = target;
+			deactivate_graph(impl);
+		}
+		if ((res = activate_graph(impl)) < 0)
+			goto error;
+		break;
+	}
 	default:
 		break;
 	}
 	return;
 error:
 	pw_stream_set_error(impl->capture, res, "can't start graph: %s",
-	                    spa_strerror(res));
+			spa_strerror(res));
 }
 
-static void playback_param_changed(void *data, uint32_t id,
-                                   const struct spa_pod *param) {
+static void playback_param_changed(void *data, uint32_t id, const struct spa_pod *param)
+{
 	struct impl *impl = data;
-	param_changed(impl, id, param, SPA_DIRECTION_OUTPUT, impl->playback,
-	              impl->capture);
+	param_changed(impl, id, param, SPA_DIRECTION_OUTPUT, impl->playback, impl->capture);
 }
 
-static void playback_destroy(void *d) {
+static void playback_destroy(void *d)
+{
 	struct impl *impl = d;
 	spa_hook_remove(&impl->playback_listener);
 	impl->playback = NULL;
 }
 
 static const struct pw_stream_events out_stream_events = {
-	PW_VERSION_STREAM_EVENTS, .destroy = playback_destroy,
-	.process = playback_process, .io_changed = io_changed,
+	PW_VERSION_STREAM_EVENTS,
+	.destroy = playback_destroy,
+	.process = playback_process,
+	.io_changed = io_changed,
 	.state_changed = playback_state_changed,
 	.param_changed = playback_param_changed,
 };
 
-static void control_destroy(void *d) {
+static void control_destroy(void *d)
+{
 	struct impl *impl = d;
 	spa_hook_remove(&impl->control_listener);
 	impl->control = NULL;
 }
 
 static void control_state_changed(void *data, enum pw_stream_state old,
-                                  enum pw_stream_state state,
-                                  const char *error) {
-	struct impl *impl = data;
+    enum pw_stream_state state, const char *error)
+{
+  struct impl *impl = data;
 
-	switch (state) {
-	case PW_STREAM_STATE_PAUSED:
-		pw_stream_flush(impl->control, false);
-		break;
-	case PW_STREAM_STATE_ERROR: pw_log_info("module %p: error: %s", impl,
-	                                        error);
-		break;
-	case PW_STREAM_STATE_STREAMING: default:
-		break;
-	}
-	return;
+  switch (state) {
+  case PW_STREAM_STATE_PAUSED:
+    pw_stream_flush(impl->control, false);
+    break;
+  case PW_STREAM_STATE_ERROR:
+    pw_log_info("module %p: error: %s", impl, error);
+    break;
+  case PW_STREAM_STATE_STREAMING:
+  default:
+    break;
+  }
+  return;
 }
 
 static const struct pw_stream_events control_stream_events = {
-	PW_VERSION_STREAM_EVENTS, .destroy = control_destroy,
-	.process = control_process, .io_changed = NULL,
-	.state_changed = control_state_changed, .param_changed = NULL,
+	PW_VERSION_STREAM_EVENTS,
+	.destroy = control_destroy,
+	.process = control_process,
+	.io_changed = NULL,
+	.state_changed = control_state_changed,
+	.param_changed = NULL,
 };
 
-static int setup_streams(struct impl *impl) {
+static int setup_streams(struct impl *impl)
+{
 	int res;
 	uint32_t i, n_params, *offs;
 	struct pw_array offsets;
@@ -1650,48 +1670,55 @@ static int setup_streams(struct impl *impl) {
 	struct spa_pod_dynamic_builder b;
 	struct spa_filter_graph *graph = impl->graph;
 
-	if (impl->control_stream_active) {
-		impl->control = pw_stream_new(impl->core, "filter control",
-		                              impl->control_props);
-		impl->control_props = NULL;
-		if (impl->control == NULL) return -errno;
+  if (impl->control_stream_active) {
+    impl->control = pw_stream_new(impl->core,
+        "filter control", impl->control_props);
+    impl->control_props = NULL;
+    if (impl->control == NULL)
+      return -errno;
 
-		pw_stream_add_listener(impl->control, &impl->control_listener,
-		                       &control_stream_events, impl);
+    pw_stream_add_listener(impl->control,
+        &impl->control_listener,
+        &control_stream_events, impl);
 
-		uint8_t buffer[256];
-		struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(
-			buffer, sizeof(buffer));
-		const struct spa_pod *param[1];
+    uint8_t buffer[256];
+    struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+    const struct spa_pod *param[1];
 
-		param[0] = spa_pod_builder_add_object(
-			&bt, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
-			SPA_FORMAT_mediaType,
-			SPA_POD_Id(SPA_MEDIA_TYPE_application ),
-			SPA_FORMAT_mediaSubtype,
-			SPA_POD_Id(SPA_MEDIA_SUBTYPE_control));
+    param[0] = spa_pod_builder_add_object(&bt,
+        SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
+        SPA_FORMAT_mediaType,    SPA_POD_Id(SPA_MEDIA_TYPE_application),
+        SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
+    );
 
-		pw_stream_connect(impl->control, PW_DIRECTION_INPUT, PW_ID_ANY,
-		                  PW_STREAM_FLAG_AUTOCONNECT |
-		                  PW_STREAM_FLAG_MAP_BUFFERS |
-		                  PW_STREAM_FLAG_RT_PROCESS, param, 1);
-	}
+    pw_stream_connect(impl->control,
+        PW_DIRECTION_INPUT,
+        PW_ID_ANY,
+        PW_STREAM_FLAG_AUTOCONNECT |
+        PW_STREAM_FLAG_MAP_BUFFERS |
+        PW_STREAM_FLAG_RT_PROCESS,
+        param, 1);
+  }
 
-	impl->capture = pw_stream_new(impl->core, "filter capture",
-	                              impl->capture_props);
+	impl->capture = pw_stream_new(impl->core,
+			"filter capture", impl->capture_props);
 	impl->capture_props = NULL;
-	if (impl->capture == NULL) return -errno;
+	if (impl->capture == NULL)
+		return -errno;
 
-	pw_stream_add_listener(impl->capture, &impl->capture_listener,
-	                       &in_stream_events, impl);
+	pw_stream_add_listener(impl->capture,
+			&impl->capture_listener,
+			&in_stream_events, impl);
 
-	impl->playback = pw_stream_new(impl->core, "filter playback",
-	                               impl->playback_props);
+	impl->playback = pw_stream_new(impl->core,
+			"filter playback", impl->playback_props);
 	impl->playback_props = NULL;
-	if (impl->playback == NULL) return -errno;
+	if (impl->playback == NULL)
+		return -errno;
 
-	pw_stream_add_listener(impl->playback, &impl->playback_listener,
-	                       &out_stream_events, impl);
+	pw_stream_add_listener(impl->playback,
+			&impl->playback_listener,
+			&out_stream_events, impl);
 
 	spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
 	pw_array_init(&offsets, 512);
@@ -1701,15 +1728,15 @@ static int setup_streams(struct impl *impl) {
 		goto done;
 	}
 	*offs = b.b.state.offset;
-	spa_format_audio_raw_build(&b.b, SPA_PARAM_EnumFormat,
-	                           &impl->capture_info);
+	spa_format_audio_raw_build(&b.b,
+			SPA_PARAM_EnumFormat, &impl->capture_info);
 
 	for (i = 0;; i++) {
 		uint32_t save = b.b.state.offset;
 		if (spa_filter_graph_enum_prop_info(graph, i, &b.b, NULL) != 1)
 			break;
-		if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL) *
-			offs = save;
+		if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
+			*offs = save;
 	}
 
 	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
@@ -1718,8 +1745,8 @@ static int setup_streams(struct impl *impl) {
 
 	if ((offs = pw_array_add(&offsets, sizeof(uint32_t))) != NULL)
 		*offs = b.b.state.offset;
-	spa_process_latency_build(&b.b, SPA_PARAM_ProcessLatency,
-	                          &impl->process_latency);
+	spa_process_latency_build(&b.b,
+			SPA_PARAM_ProcessLatency, &impl->process_latency);
 
 	n_params = pw_array_get_len(&offsets, uint32_t);
 	if (n_params == 0) {
@@ -1735,25 +1762,32 @@ static int setup_streams(struct impl *impl) {
 	for (i = 0; i < n_params; i++)
 		params[i] = spa_pod_builder_deref(&b.b, offs[i]);
 
-	res = pw_stream_connect(impl->capture, PW_DIRECTION_INPUT, PW_ID_ANY,
-	                        PW_STREAM_FLAG_AUTOCONNECT |
-	                        PW_STREAM_FLAG_MAP_BUFFERS |
-	                        PW_STREAM_FLAG_RT_PROCESS |
-	                        PW_STREAM_FLAG_ASYNC, params, n_params);
+	res = pw_stream_connect(impl->capture,
+			PW_DIRECTION_INPUT,
+			PW_ID_ANY,
+			PW_STREAM_FLAG_AUTOCONNECT |
+			PW_STREAM_FLAG_MAP_BUFFERS |
+			PW_STREAM_FLAG_RT_PROCESS |
+			PW_STREAM_FLAG_ASYNC,
+			params, n_params);
 
 	spa_pod_dynamic_builder_clean(&b);
-	if (res < 0) goto done;
+	if (res < 0)
+		goto done;
 
 	n_params = 0;
 	spa_pod_dynamic_builder_init(&b, NULL, 0, 4096);
-	params[n_params++] = spa_format_audio_raw_build(
-		&b.b, SPA_PARAM_EnumFormat, &impl->playback_info);
+	params[n_params++] = spa_format_audio_raw_build(&b.b,
+			SPA_PARAM_EnumFormat, &impl->playback_info);
 
-	res = pw_stream_connect(impl->playback, PW_DIRECTION_OUTPUT, PW_ID_ANY,
-	                        PW_STREAM_FLAG_AUTOCONNECT |
-	                        PW_STREAM_FLAG_MAP_BUFFERS |
-	                        PW_STREAM_FLAG_RT_PROCESS |
-	                        PW_STREAM_FLAG_TRIGGER, params, n_params);
+	res = pw_stream_connect(impl->playback,
+			PW_DIRECTION_OUTPUT,
+			PW_ID_ANY,
+			PW_STREAM_FLAG_AUTOCONNECT |
+			PW_STREAM_FLAG_MAP_BUFFERS |
+			PW_STREAM_FLAG_RT_PROCESS  |
+			PW_STREAM_FLAG_TRIGGER,
+			params, n_params);
 	spa_pod_dynamic_builder_clean(&b);
 
 done:
@@ -1763,17 +1797,18 @@ done:
 	return res < 0 ? res : 0;
 }
 
-static void copy_position(struct spa_audio_info_raw *dst,
-                          const struct spa_audio_info_raw *src) {
-	if (SPA_FLAG_IS_SET(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED) && !
-		SPA_FLAG_IS_SET(src->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
+static void copy_position(struct spa_audio_info_raw *dst, const struct spa_audio_info_raw *src)
+{
+	if (SPA_FLAG_IS_SET(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED) &&
+	    !SPA_FLAG_IS_SET(src->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
 		for (uint32_t i = 0; i < src->channels; i++)
 			dst->position[i] = src->position[i];
 		SPA_FLAG_CLEAR(dst->flags, SPA_AUDIO_FLAG_UNPOSITIONED);
 	}
 }
 
-static void graph_info(void *object, const struct spa_filter_graph_info *info) {
+static void graph_info(void *object, const struct spa_filter_graph_info *info)
+{
 	struct impl *impl = object;
 	struct spa_dict *props = info->props;
 	uint32_t i;
@@ -1797,10 +1832,8 @@ static void graph_info(void *object, const struct spa_filter_graph_info *info) {
 		if (spa_streq(k, "latency")) {
 			double latency;
 			if (spa_atod(s, &latency)) {
-				if (impl->process_latency.rate != (int32_t)
-					latency) {
-					impl->process_latency.rate = (int32_t)
-						latency;
+				if (impl->process_latency.rate != (int32_t)latency) {
+					impl->process_latency.rate = (int32_t)latency;
 					update_latencies(impl, true);
 				}
 			}
@@ -1808,16 +1841,16 @@ static void graph_info(void *object, const struct spa_filter_graph_info *info) {
 	}
 }
 
-static void graph_apply_props(void *object, enum spa_direction direction,
-                              const struct spa_pod *props) {
+static void graph_apply_props(void *object, enum spa_direction direction, const struct spa_pod *props)
+{
 	struct impl *impl = object;
-	pw_stream_set_param(
-		direction == SPA_DIRECTION_INPUT
-			? impl->capture
-			: impl->playback, SPA_PARAM_Props, props);
+	pw_stream_set_param(direction == SPA_DIRECTION_INPUT ?
+			impl->capture : impl->playback,
+			SPA_PARAM_Props, props);
 }
 
-static void graph_props_changed(void *object, enum spa_direction direction) {
+static void graph_props_changed(void *object, enum spa_direction direction)
+{
 	struct impl *impl = object;
 	struct spa_filter_graph *graph = impl->graph;
 	uint8_t buffer[1024];
@@ -1825,27 +1858,29 @@ static void graph_props_changed(void *object, enum spa_direction direction) {
 	const struct spa_pod *params[1];
 
 	spa_pod_dynamic_builder_init(&b, buffer, sizeof(buffer), 4096);
-	spa_filter_graph_get_props(graph, &b.b, (struct spa_pod**)&params[0]);
+	spa_filter_graph_get_props(graph, &b.b, (struct spa_pod **)&params[0]);
 
 	pw_stream_update_params(impl->capture, params, 1);
 	spa_pod_dynamic_builder_clean(&b);
 }
 
 struct spa_filter_graph_events graph_events = {
-	SPA_VERSION_FILTER_GRAPH_EVENTS, .info = graph_info,
-	.apply_props = graph_apply_props, .props_changed = graph_props_changed,
+	SPA_VERSION_FILTER_GRAPH_EVENTS,
+	.info = graph_info,
+	.apply_props = graph_apply_props,
+	.props_changed = graph_props_changed,
 };
 
-static void core_error(void *data, uint32_t id, int seq, int res,
-                       const char *message) {
+static void core_error(void *data, uint32_t id, int seq, int res, const char *message)
+{
 	struct impl *impl = data;
 
 	if (res == -ENOENT) {
-		pw_log_info("message id:%u seq:%d res:%d (%s): %s", id, seq,
-		            res, spa_strerror(res), message);
+		pw_log_info("message id:%u seq:%d res:%d (%s): %s",
+				id, seq, res, spa_strerror(res), message);
 	} else {
-		pw_log_warn("error id:%u seq:%d res:%d (%s): %s", id, seq, res,
-		            spa_strerror(res), message);
+		pw_log_warn("error id:%u seq:%d res:%d (%s): %s",
+				id, seq, res, spa_strerror(res), message);
 	}
 
 	if (id == PW_ID_CORE && res == -EPIPE)
@@ -1853,10 +1888,12 @@ static void core_error(void *data, uint32_t id, int seq, int res,
 }
 
 static const struct pw_core_events core_events = {
-	PW_VERSION_CORE_EVENTS, .error = core_error,
+	PW_VERSION_CORE_EVENTS,
+	.error = core_error,
 };
 
-static void core_destroy(void *d) {
+static void core_destroy(void *d)
+{
 	struct impl *impl = d;
 	spa_hook_remove(&impl->core_listener);
 	impl->core = NULL;
@@ -1867,17 +1904,28 @@ static const struct pw_proxy_events core_proxy_events = {
 	.destroy = core_destroy,
 };
 
-static void impl_destroy(struct impl *impl) {
+static void impl_destroy(struct impl *impl)
+{
 	/* disconnect both streams before destroying any of them */
-	if (impl->capture) pw_stream_disconnect(impl->capture);
-	if (impl->playback) pw_stream_disconnect(impl->playback);
+	if (impl->capture)
+		pw_stream_disconnect(impl->capture);
+	if (impl->playback)
+		pw_stream_disconnect(impl->playback);
+	if (impl->control)
+		pw_stream_disconnect(impl->control);
 
-	if (impl->capture) pw_stream_destroy(impl->capture);
-	if (impl->playback) pw_stream_destroy(impl->playback);
+	if (impl->capture)
+		pw_stream_destroy(impl->capture);
+	if (impl->playback)
+		pw_stream_destroy(impl->playback);
+	if (impl->control)
+		pw_stream_destroy(impl->control);
 
-	if (impl->core && impl->do_disconnect) pw_core_disconnect(impl->core);
+	if (impl->core && impl->do_disconnect)
+		pw_core_disconnect(impl->core);
 
-	if (impl->handle) pw_unload_spa_handle(impl->handle);
+	if (impl->handle)
+		pw_unload_spa_handle(impl->handle);
 
 	pw_properties_free(impl->capture_props);
 	pw_properties_free(impl->playback_props);
@@ -1886,27 +1934,31 @@ static void impl_destroy(struct impl *impl) {
 	free(impl);
 }
 
-static void module_destroy(void *data) {
+static void module_destroy(void *data)
+{
 	struct impl *impl = data;
 	spa_hook_remove(&impl->module_listener);
 	impl_destroy(impl);
 }
 
 static const struct pw_impl_module_events module_events = {
-	PW_VERSION_IMPL_MODULE_EVENTS, .destroy = module_destroy,
+	PW_VERSION_IMPL_MODULE_EVENTS,
+	.destroy = module_destroy,
 };
 
-static void parse_audio_info(struct pw_properties *props,
-                             struct spa_audio_info_raw *info) {
-	spa_audio_info_raw_init_dict_keys(
-		info,
-		&SPA_DICT_ITEMS(SPA_DICT_ITEM(SPA_KEY_AUDIO_FORMAT, "F32P")),
-		&props->dict, SPA_KEY_AUDIO_RATE, SPA_KEY_AUDIO_CHANNELS,
-		SPA_KEY_AUDIO_POSITION, NULL);
+static void parse_audio_info(struct pw_properties *props, struct spa_audio_info_raw *info)
+{
+	spa_audio_info_raw_init_dict_keys(info,
+			&SPA_DICT_ITEMS(
+				 SPA_DICT_ITEM(SPA_KEY_AUDIO_FORMAT, "F32P")),
+			&props->dict,
+			SPA_KEY_AUDIO_RATE,
+			SPA_KEY_AUDIO_CHANNELS,
+			SPA_KEY_AUDIO_POSITION, NULL);
 }
 
-static void copy_props(struct impl *impl, struct pw_properties *props,
-                       const char *key) {
+static void copy_props(struct impl *impl, struct pw_properties *props, const char *key)
+{
 	const char *str;
 	if ((str = pw_properties_get(props, key)) != NULL) {
 		if (pw_properties_get(impl->capture_props, key) == NULL)
@@ -1916,8 +1968,9 @@ static void copy_props(struct impl *impl, struct pw_properties *props,
 	}
 }
 
-SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
-                                     const char *args) {
+SPA_EXPORT
+int pipewire__module_init(struct pw_impl_module *module, const char *args)
+{
 	struct pw_context *context = pw_impl_module_get_context(module);
 	const struct pw_properties *p;
 	struct pw_properties *props;
@@ -1931,16 +1984,19 @@ SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
 	PW_LOG_TOPIC_INIT(mod_topic);
 
 	impl = calloc(1, sizeof(struct impl));
-	if (impl == NULL) return -errno;
+	if (impl == NULL)
+		return -errno;
 
 	pw_log_debug("module %p: new %s", impl, args);
 
-	if (args) props = pw_properties_new_string(args);
-	else props = pw_properties_new(NULL, NULL);
+	if (args)
+		props = pw_properties_new_string(args);
+	else
+		props = pw_properties_new(NULL, NULL);
 
 	if (props == NULL) {
 		res = -errno;
-		pw_log_error("can't create properties: %m");
+		pw_log_error( "can't create properties: %m");
 		goto error;
 	}
 	impl->props = props;
@@ -1948,43 +2004,34 @@ SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
 	impl->capture_props = pw_properties_new(NULL, NULL);
 	impl->playback_props = pw_properties_new(NULL, NULL);
 	impl->control_props = pw_properties_new(NULL, NULL);
-	if (impl->capture_props == NULL || impl->playback_props == NULL || impl
-		->control_props == NULL) {
+	if (impl->capture_props == NULL || impl->playback_props == NULL || impl->control_props == NULL) {
 		res = -errno;
-		pw_log_error("can't create properties: %m");
+		pw_log_error( "can't create properties: %m");
 		goto error;
 	}
 
 	impl->module = module;
 	impl->context = context;
-	impl->latency[SPA_DIRECTION_INPUT] = SPA_LATENCY_INFO(
-		SPA_DIRECTION_INPUT);
-	impl->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(
-		SPA_DIRECTION_OUTPUT);
+	impl->latency[SPA_DIRECTION_INPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_INPUT);
+	impl->latency[SPA_DIRECTION_OUTPUT] = SPA_LATENCY_INFO(SPA_DIRECTION_OUTPUT);
 
 	if (pw_properties_get(props, PW_KEY_NODE_GROUP) == NULL)
-		pw_properties_setf(props, PW_KEY_NODE_GROUP,
-		                   "filter-chain-%u-%u", pid, id);
+		pw_properties_setf(props, PW_KEY_NODE_GROUP, "filter-chain-%u-%u", pid, id);
 	if (pw_properties_get(props, PW_KEY_NODE_LINK_GROUP) == NULL)
-		pw_properties_setf(props, PW_KEY_NODE_LINK_GROUP,
-		                   "filter-chain-%u-%u", pid, id);
+		pw_properties_setf(props, PW_KEY_NODE_LINK_GROUP, "filter-chain-%u-%u", pid, id);
 	if (pw_properties_get(props, PW_KEY_NODE_VIRTUAL) == NULL)
 		pw_properties_set(props, PW_KEY_NODE_VIRTUAL, "true");
 	if (pw_properties_get(props, "resample.prefill") == NULL)
 		pw_properties_set(props, "resample.prefill", "true");
 	if (pw_properties_get(props, PW_KEY_NODE_DESCRIPTION) == NULL)
-		pw_properties_setf(props, PW_KEY_NODE_DESCRIPTION,
-		                   "filter-chain-%u-%u", pid, id);
+		pw_properties_setf(props, PW_KEY_NODE_DESCRIPTION, "filter-chain-%u-%u", pid, id);
 
 	if ((str = pw_properties_get(props, "capture.props")) != NULL)
-		pw_properties_update_string(impl->capture_props, str,
-		                            strlen(str));
+		pw_properties_update_string(impl->capture_props, str, strlen(str));
 	if ((str = pw_properties_get(props, "playback.props")) != NULL)
-		pw_properties_update_string(impl->playback_props, str,
-		                            strlen(str));
+		pw_properties_update_string(impl->playback_props, str, strlen(str));
 	if ((str = pw_properties_get(props, "control.props")) != NULL)
-		pw_properties_update_string(impl->control_props, str,
-		                            strlen(str));
+		pw_properties_update_string(impl->control_props, str, strlen(str));
 
 	copy_props(impl, props, PW_KEY_AUDIO_RATE);
 	copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
@@ -2001,83 +2048,72 @@ SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
 	parse_audio_info(impl->playback_props, &impl->playback_info);
 
 	if (!impl->capture_info.rate && !impl->playback_info.rate) {
-		if (pw_properties_get(impl->playback_props, "resample.disable")
-			== NULL) pw_properties_set(
-			impl->playback_props, "resample.disable", "true");
-		if (pw_properties_get(impl->capture_props, "resample.disable")
-			== NULL) pw_properties_set(
-			impl->capture_props, "resample.disable", "true");
+		if (pw_properties_get(impl->playback_props, "resample.disable") == NULL)
+			pw_properties_set(impl->playback_props, "resample.disable", "true");
+		if (pw_properties_get(impl->capture_props, "resample.disable") == NULL)
+			pw_properties_set(impl->capture_props, "resample.disable", "true");
 	} else if (impl->capture_info.rate && !impl->playback_info.rate)
 		impl->playback_info.rate = impl->capture_info.rate;
 	else if (impl->playback_info.rate && !impl->capture_info.rate)
 		impl->capture_info.rate = !impl->playback_info.rate;
 	else if (impl->capture_info.rate != impl->playback_info.rate) {
-		pw_log_warn(
-			"Both capture and playback rate are set, but"
+		pw_log_warn("Both capture and playback rate are set, but"
 			" they are different. Using the highest of two. This behaviour"
 			" is deprecated, please use equal rates in the module config");
-		impl->playback_info.rate = impl->capture_info.rate = SPA_MAX(
-			impl->playback_info.rate, impl->capture_info.rate);
+		impl->playback_info.rate = impl->capture_info.rate =
+			SPA_MAX(impl->playback_info.rate, impl->capture_info.rate);
 	}
 
 	if ((str = pw_properties_get(props, PW_KEY_NODE_NAME)) == NULL) {
 		pw_properties_setf(props, PW_KEY_NODE_NAME,
-		                   "filter-chain-%u-%u", pid, id);
+				"filter-chain-%u-%u", pid, id);
 		str = pw_properties_get(props, PW_KEY_NODE_NAME);
 	}
 	if (pw_properties_get(impl->capture_props, PW_KEY_NODE_NAME) == NULL)
 		pw_properties_setf(impl->capture_props, PW_KEY_NODE_NAME,
-		                   "input.%s", str);
+				"input.%s", str);
 	if (pw_properties_get(impl->playback_props, PW_KEY_NODE_NAME) == NULL)
 		pw_properties_setf(impl->playback_props, PW_KEY_NODE_NAME,
-		                   "output.%s", str);
+				"output.%s", str);
 
 	if (pw_properties_get(impl->capture_props, PW_KEY_MEDIA_NAME) == NULL)
-		pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME,
-		                   "%s input",
-		                   pw_properties_get(impl->capture_props,
-			                   PW_KEY_NODE_DESCRIPTION));
+		pw_properties_setf(impl->capture_props, PW_KEY_MEDIA_NAME, "%s input",
+				pw_properties_get(impl->capture_props, PW_KEY_NODE_DESCRIPTION));
 	if (pw_properties_get(impl->playback_props, PW_KEY_MEDIA_NAME) == NULL)
-		pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME,
-		                   "%s output",
-		                   pw_properties_get(impl->playback_props,
-			                   PW_KEY_NODE_DESCRIPTION));
+		pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME, "%s output",
+				pw_properties_get(impl->playback_props, PW_KEY_NODE_DESCRIPTION));
 
 	p = pw_context_get_properties(impl->context);
 	pw_properties_set(props, "clock.quantum-limit",
-	                  pw_properties_get(p, "default.clock.quantum-limit"));
+			pw_properties_get(p, "default.clock.quantum-limit"));
 
-	pw_properties_setf(props, "filter-graph.n_inputs", "%d",
-	                   impl->capture_info.channels);
-	pw_properties_setf(props, "filter-graph.n_outputs", "%d",
-	                   impl->playback_info.channels);
+	pw_properties_setf(props, "filter-graph.n_inputs", "%d", impl->capture_info.channels);
+	pw_properties_setf(props, "filter-graph.n_outputs", "%d", impl->playback_info.channels);
 
-	pw_properties_set(props, SPA_KEY_LIBRARY_NAME,
-	                  "filter-graph/libspa-filter-graph");
-	impl->handle = pw_context_load_spa_handle(impl->context, "filter.graph",
-	                                          &props->dict);
+	pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "filter-graph/libspa-filter-graph");
+	impl->handle = pw_context_load_spa_handle(impl->context, "filter.graph", &props->dict);
 	if (impl->handle == NULL) {
 		res = -errno;
 		goto error;
 	}
 
-	res = spa_handle_get_interface(impl->handle,
-	                               SPA_TYPE_INTERFACE_FilterGraph, &iface);
-	if (res < 0 || iface == NULL) goto error;
+	res = spa_handle_get_interface(impl->handle, SPA_TYPE_INTERFACE_FilterGraph, &iface);
+	if (res < 0 || iface == NULL)
+		goto error;
 
 	impl->graph = iface;
 
 	spa_filter_graph_add_listener(impl->graph, &impl->graph_listener,
-	                              &graph_events, impl);
+			&graph_events, impl);
 
-	impl->core = pw_context_get_object(impl->context,
-	                                   PW_TYPE_INTERFACE_Core);
+	impl->core = pw_context_get_object(impl->context, PW_TYPE_INTERFACE_Core);
 	if (impl->core == NULL) {
 		str = pw_properties_get(props, PW_KEY_REMOTE_NAME);
 		impl->core = pw_context_connect(impl->context,
-		                                pw_properties_new(
-			                                PW_KEY_REMOTE_NAME, str,
-			                                NULL), 0);
+				pw_properties_new(
+					PW_KEY_REMOTE_NAME, str,
+					NULL),
+				0);
 		impl->do_disconnect = true;
 	}
 	if (impl->core == NULL) {
@@ -2087,33 +2123,31 @@ SPA_EXPORT int pipewire__module_init(struct pw_impl_module *module,
 	}
 
 	pw_proxy_add_listener((struct pw_proxy*)impl->core,
-	                      &impl->core_proxy_listener, &core_proxy_events,
-	                      impl);
-	pw_core_add_listener(impl->core, &impl->core_listener, &core_events,
-	                     impl);
+			&impl->core_proxy_listener,
+			&core_proxy_events, impl);
+	pw_core_add_listener(impl->core,
+			&impl->core_listener,
+			&core_events, impl);
 
 	if (pw_properties_get(impl->control_props, "enabled") == NULL) {
-		impl->control_stream_active = false;
-	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"),
-	                  "true") == 0) {
-		impl->control_stream_active = true;
-	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"),
-	                  "false") == 0) {
-		impl->control_stream_active = false;
+	  impl->control_stream_active = false;
+	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "true")
+	  == 0) {
+	  impl->control_stream_active = true;
+	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "false")
+	  == 0) {
+	  impl->control_stream_active = false;
 	}
 
 	setup_streams(impl);
 
-	pw_impl_module_add_listener(module, &impl->module_listener,
-	                            &module_events, impl);
+	pw_impl_module_add_listener(module, &impl->module_listener, &module_events, impl);
 
-	pw_impl_module_update_properties(
-		module, &SPA_DICT_INIT_ARRAY(module_props));
+	pw_impl_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
 
 	return 0;
 
 error:
-
 	impl_destroy(impl);
 	return res;
 }

From f6a52e0c113d44cb98d5c1741d8369551ae9a8f8 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sat, 16 Aug 2025 21:40:25 -0400
Subject: [PATCH 11/26] formatting

---
 src/modules/module-filter-chain.c | 84 +++++++++++++++----------------
 1 file changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 4af6bf528..b96e5999c 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1182,7 +1182,7 @@ struct impl {
 	struct pw_properties *control_props;
 	struct pw_stream *control;
 	struct spa_hook control_listener;
-  bool control_stream_active;
+	bool control_stream_active;
 
 	struct spa_audio_info_raw info;
 
@@ -1229,42 +1229,42 @@ static void capture_process(void *d)
 
 static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
 {
-  const struct impl *impl = user_data;
-  const struct spa_pod *props = data;
-  spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
-  return 0;
+	const struct impl *impl = user_data;
+	const struct spa_pod *props = data;
+	spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
+	return 0;
 }
 
 static void control_process(void *d)
 {
 	struct impl *impl = d;
 
-  struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
-  if (control == NULL)
-    goto done;
-  if (control->buffer->n_datas > 0) {
-    struct spa_pod *pod = spa_pod_from_data(
-      control->buffer->datas[0].data,
-      control->buffer->datas[0].maxsize,
-      control->buffer->datas[0].chunk->offset,
-      control->buffer->datas[0].chunk->size);
+	struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
+	if (control == NULL)
+	  goto done;
+	if (control->buffer->n_datas > 0) {
+	  struct spa_pod *pod = spa_pod_from_data(
+	    control->buffer->datas[0].data,
+	    control->buffer->datas[0].maxsize,
+	    control->buffer->datas[0].chunk->offset,
+	    control->buffer->datas[0].chunk->size);
 
-    if (spa_pod_is_sequence(pod)) {
-      struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
+	  if (spa_pod_is_sequence(pod)) {
+	    struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
 
-      struct spa_pod_control *pod_control;
-      SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
-        if (pod_control->type == SPA_CONTROL_Properties) {
-            struct pw_loop *loop = pw_context_get_main_loop(impl->context);
-            pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
-              SPA_POD_SIZE(&pod_control->value), false, impl);
-        }
-      }
-    }
-  }
+	    struct spa_pod_control *pod_control;
+	    SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
+	      if (pod_control->type == SPA_CONTROL_Properties) {
+		  struct pw_loop *loop = pw_context_get_main_loop(impl->context);
+		  pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
+		    SPA_POD_SIZE(&pod_control->value), false, impl);
+	      }
+	    }
+	  }
+	}
 
-  done:
-    pw_stream_queue_buffer(impl->control, control);
+done:
+	pw_stream_queue_buffer(impl->control, control);
 }
 
 static void playback_process(void *d)
@@ -1634,22 +1634,22 @@ static void control_destroy(void *d)
 }
 
 static void control_state_changed(void *data, enum pw_stream_state old,
-    enum pw_stream_state state, const char *error)
+			enum pw_stream_state state, const char *error)
 {
-  struct impl *impl = data;
+	struct impl *impl = data;
 
-  switch (state) {
-  case PW_STREAM_STATE_PAUSED:
-    pw_stream_flush(impl->control, false);
-    break;
-  case PW_STREAM_STATE_ERROR:
-    pw_log_info("module %p: error: %s", impl, error);
-    break;
-  case PW_STREAM_STATE_STREAMING:
-  default:
-    break;
-  }
-  return;
+	switch (state) {
+	case PW_STREAM_STATE_PAUSED:
+	  pw_stream_flush(impl->control, false);
+	  break;
+	case PW_STREAM_STATE_ERROR:
+	  pw_log_info("module %p: error: %s", impl, error);
+	  break;
+	case PW_STREAM_STATE_STREAMING:
+	default:
+	  break;
+	}
+	return;
 }
 
 static const struct pw_stream_events control_stream_events = {

From 7df3bf48ce7a9c007fe87edd9d57522fcf39b086 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sat, 16 Aug 2025 21:43:30 -0400
Subject: [PATCH 12/26] formatting

---
 src/modules/module-filter-chain.c | 53 ++++++++++++++++---------------
 1 file changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index b96e5999c..e775b885d 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1670,35 +1670,38 @@ static int setup_streams(struct impl *impl)
 	struct spa_pod_dynamic_builder b;
 	struct spa_filter_graph *graph = impl->graph;
 
-  if (impl->control_stream_active) {
-    impl->control = pw_stream_new(impl->core,
-        "filter control", impl->control_props);
-    impl->control_props = NULL;
-    if (impl->control == NULL)
-      return -errno;
+	if (impl->control_stream_active) {
+		impl->control = pw_stream_new(impl->core,
+		    "filter control", impl->control_props);
+		impl->control_props = NULL;
+		if (impl->control == NULL)
+		  return -errno;
 
-    pw_stream_add_listener(impl->control,
-        &impl->control_listener,
-        &control_stream_events, impl);
+		pw_stream_add_listener(impl->control,
+		    &impl->control_listener,
+		    &control_stream_events, impl);
 
-    uint8_t buffer[256];
-    struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
-    const struct spa_pod *param[1];
+		uint8_t buffer[256];
+		struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+		const struct spa_pod *param[1];
 
-    param[0] = spa_pod_builder_add_object(&bt,
-        SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
-        SPA_FORMAT_mediaType,    SPA_POD_Id(SPA_MEDIA_TYPE_application),
-        SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
-    );
+		param[0] = spa_pod_builder_add_object(&bt,
+			SPA_TYPE_OBJECT_Format,
+			SPA_PARAM_EnumFormat,
+			SPA_FORMAT_mediaType,
+			SPA_POD_Id(SPA_MEDIA_TYPE_application),
+			SPA_FORMAT_mediaSubtype,
+			SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
+		);
 
-    pw_stream_connect(impl->control,
-        PW_DIRECTION_INPUT,
-        PW_ID_ANY,
-        PW_STREAM_FLAG_AUTOCONNECT |
-        PW_STREAM_FLAG_MAP_BUFFERS |
-        PW_STREAM_FLAG_RT_PROCESS,
-        param, 1);
-  }
+		pw_stream_connect(impl->control,
+			PW_DIRECTION_INPUT,
+			PW_ID_ANY,
+			PW_STREAM_FLAG_AUTOCONNECT |
+			PW_STREAM_FLAG_MAP_BUFFERS |
+			PW_STREAM_FLAG_RT_PROCESS,
+			param, 1);
+	}
 
 	impl->capture = pw_stream_new(impl->core,
 			"filter capture", impl->capture_props);

From 17d6d7b0b1c372e0a603c8269f65165b6225b7a8 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sat, 16 Aug 2025 21:50:45 -0400
Subject: [PATCH 13/26] formatting

---
 src/modules/module-filter-chain.c | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index e775b885d..7a2d0fb6a 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1227,7 +1227,8 @@ static void capture_process(void *d)
 	}
 }
 
-static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data, size_t size, void *user_data)
+static int apply_props(struct spa_loop *loop, bool async, uint32_t seq,
+		const void *data, size_t size, void *user_data)
 {
 	const struct impl *impl = user_data;
 	const struct spa_pod *props = data;
@@ -1640,14 +1641,14 @@ static void control_state_changed(void *data, enum pw_stream_state old,
 
 	switch (state) {
 	case PW_STREAM_STATE_PAUSED:
-	  pw_stream_flush(impl->control, false);
-	  break;
+		pw_stream_flush(impl->control, false);
+		break;
 	case PW_STREAM_STATE_ERROR:
-	  pw_log_info("module %p: error: %s", impl, error);
-	  break;
+		pw_log_info("module %p: error: %s", impl, error);
+		break;
 	case PW_STREAM_STATE_STREAMING:
 	default:
-	  break;
+		break;
 	}
 	return;
 }
@@ -2133,13 +2134,13 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 			&core_events, impl);
 
 	if (pw_properties_get(impl->control_props, "enabled") == NULL) {
-	  impl->control_stream_active = false;
-	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "true")
-	  == 0) {
-	  impl->control_stream_active = true;
-	} else if (strcmp(pw_properties_get(impl->control_props, "enabled"), "false")
-	  == 0) {
-	  impl->control_stream_active = false;
+		impl->control_stream_active = false;
+	} else if (strcmp(pw_properties_get(
+			impl->control_props, "enabled"), "true") == 0) {
+		impl->control_stream_active = true;
+	} else if (strcmp(pw_properties_get(
+			impl->control_props, "enabled"), "false") == 0) {
+		impl->control_stream_active = false;
 	}
 
 	setup_streams(impl);

From 7a190dd2ab482c66b7291ebdc89570ab43e93d09 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sun, 17 Aug 2025 10:35:21 -0400
Subject: [PATCH 14/26] use boolean in config

---
 src/modules/module-filter-chain.c | 39 +++++++++++++++++++++++++------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 7a2d0fb6a..6c5ccc4f0 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1012,6 +1012,35 @@ extern struct spa_handle_factory spa_filter_graph_factory;
  *         prefixed with 'input.' and 'output.' to generate a capture and playback
  *         stream node.name respectively.
  *
+ * ## Control Stream
+ *
+ * The module can provide an input stream for control data. It can only be
+ * configured with the property `control.props`, properties on the filter
+ * definition will not be taken into account.
+ *
+ * The control stream has to be enabled by setting the attribute `enabled` of
+ * the `control.props` to true.
+ *
+ *\code{.unparsed}
+ * # ~/.config/pipewire/filter-chain.conf.d/my-filter-chain-1.conf
+ *
+ * context.modules = [
+ * {   name = libpipewire-module-filter-chain
+ *     args = {
+ *         ...
+ *         filter.graph = {...}
+ *         capture.props = {...}
+ *	   control.props = {
+ *		node.name = "control_in",
+ *		node.autoconnect = true,
+ *		enabled = true,
+ *		media.class = "Stream/Input/Control"
+ *	   }
+ *     }
+ * }
+ * ]
+ *\endcode
+ *
  * ## Example configuration of a virtual source
  *
  * This example uses the rnnoise LADSPA plugin to create a new
@@ -2133,14 +2162,10 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 			&impl->core_listener,
 			&core_events, impl);
 
-	if (pw_properties_get(impl->control_props, "enabled") == NULL) {
-		impl->control_stream_active = false;
-	} else if (strcmp(pw_properties_get(
-			impl->control_props, "enabled"), "true") == 0) {
-		impl->control_stream_active = true;
-	} else if (strcmp(pw_properties_get(
-			impl->control_props, "enabled"), "false") == 0) {
+	if ((str = pw_properties_get(impl->control_props, "enabled")) == NULL) {
 		impl->control_stream_active = false;
+	} else {
+		impl->control_stream_active = spa_atob(str);
 	}
 
 	setup_streams(impl);

From 6251d37cc819435c4de957cfe36dbf07b21d54c3 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sun, 17 Aug 2025 10:37:01 -0400
Subject: [PATCH 15/26] parse boolean in config with pw_properties_get_bool

---
 src/modules/module-filter-chain.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 6c5ccc4f0..7002e36ab 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -2162,11 +2162,7 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 			&impl->core_listener,
 			&core_events, impl);
 
-	if ((str = pw_properties_get(impl->control_props, "enabled")) == NULL) {
-		impl->control_stream_active = false;
-	} else {
-		impl->control_stream_active = spa_atob(str);
-	}
+	impl->control_stream_active = pw_properties_get_bool(impl->control_props, "enabled", false);
 
 	setup_streams(impl);
 

From 682c29434f35a50e03e80c6f5e84ba319528c0b7 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sun, 17 Aug 2025 14:43:37 +0000
Subject: [PATCH 16/26] Apply 1 suggestion(s) to 1 file(s)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Barnabás Pőcze <pobrn@protonmail.com>
---
 src/modules/module-filter-chain.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 7002e36ab..e934b2206 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1962,6 +1962,7 @@ static void impl_destroy(struct impl *impl)
 
 	pw_properties_free(impl->capture_props);
 	pw_properties_free(impl->playback_props);
+	pw_properties_free(impl->control_props);
 
 	pw_properties_free(impl->props);
 	free(impl);

From e1aec031343b7985c2c9afea41fedfe026987a8f Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sun, 17 Aug 2025 10:57:03 -0400
Subject: [PATCH 17/26] move includes

---
 src/modules/module-filter-chain.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index e934b2206..f213d1965 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -13,7 +13,9 @@
 #include <dlfcn.h>
 #include <unistd.h>
 
+#include <spa/control/control.h>
 #include <spa/param/latency-utils.h>
+#include <spa/param/props.h>
 #include <spa/param/tag-utils.h>
 #include <spa/param/audio/raw-json.h>
 #include <spa/pod/dynamic.h>
@@ -21,8 +23,6 @@
 
 #include <pipewire/impl.h>
 
-#include "spa/control/control.h"
-#include "spa/param/props.h"
 
 #define NAME "filter-chain"
 

From 3ccd3b15a0e89a315edafa640873f1217917fbc8 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Sun, 17 Aug 2025 11:39:33 -0400
Subject: [PATCH 18/26] formatting

---
 src/modules/module-filter-chain.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index f213d1965..73b6dd25c 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1256,8 +1256,8 @@ static void capture_process(void *d)
 	}
 }
 
-static int apply_props(struct spa_loop *loop, bool async, uint32_t seq,
-		const void *data, size_t size, void *user_data)
+static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const void *data,
+		size_t size, void *user_data)
 {
 	const struct impl *impl = user_data;
 	const struct spa_pod *props = data;

From b1804382033f6672d35741695125031e66ba55bb Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Tue, 19 Aug 2025 12:00:21 -0400
Subject: [PATCH 19/26] change usage of pw_loop_invoke

---
 src/modules/module-filter-chain.c | 41 ++++++++++++++++---------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 73b6dd25c..16423f534 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1260,8 +1260,16 @@ static int apply_props(struct spa_loop *loop, bool async, uint32_t seq, const vo
 		size_t size, void *user_data)
 {
 	const struct impl *impl = user_data;
-	const struct spa_pod *props = data;
-	spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT, props);
+	const struct spa_pod *pod = data;
+
+	struct spa_pod_control *pod_control;
+	SPA_POD_SEQUENCE_FOREACH((struct spa_pod_sequence *)pod, pod_control) {
+		if (pod_control->type == SPA_CONTROL_Properties) {
+			spa_filter_graph_set_props(impl->graph, SPA_DIRECTION_OUTPUT,
+					&pod_control->value);
+		}
+	}
+
 	return 0;
 }
 
@@ -1271,26 +1279,19 @@ static void control_process(void *d)
 
 	struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
 	if (control == NULL)
-	  goto done;
+	  	goto done;
 	if (control->buffer->n_datas > 0) {
-	  struct spa_pod *pod = spa_pod_from_data(
-	    control->buffer->datas[0].data,
-	    control->buffer->datas[0].maxsize,
-	    control->buffer->datas[0].chunk->offset,
-	    control->buffer->datas[0].chunk->size);
+	  	struct spa_pod *pod = spa_pod_from_data(
+	    		control->buffer->datas[0].data,
+	    		control->buffer->datas[0].maxsize,
+	    		control->buffer->datas[0].chunk->offset,
+	    		control->buffer->datas[0].chunk->size);
 
-	  if (spa_pod_is_sequence(pod)) {
-	    struct spa_pod_sequence *sequence = (struct spa_pod_sequence *)pod;
-
-	    struct spa_pod_control *pod_control;
-	    SPA_POD_SEQUENCE_FOREACH(sequence, pod_control) {
-	      if (pod_control->type == SPA_CONTROL_Properties) {
-		  struct pw_loop *loop = pw_context_get_main_loop(impl->context);
-		  pw_loop_invoke(loop, apply_props, 0, &pod_control->value,
-		    SPA_POD_SIZE(&pod_control->value), false, impl);
-	      }
-	    }
-	  }
+		if (spa_pod_is_sequence(pod)) {
+	  		struct pw_loop *loop = pw_context_get_main_loop(impl->context);
+	  		pw_loop_invoke(loop, apply_props, 0, pod, SPA_POD_SIZE(pod),
+				false, impl);
+		}
 	}
 
 done:

From c5e5a6c7888d6311cc873c9b3270d18cae6430d6 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 13:00:30 -0400
Subject: [PATCH 20/26] Add feedback port that sends out the filters control
 state when parameters change

---
 src/modules/module-filter-chain.c | 217 +++++++++++++++++++++++++++++-
 src/tools/meson.build             |   1 +
 src/tools/pw-ctrldump.c           | 190 ++++++++++++++++++++++++++
 3 files changed, 405 insertions(+), 3 deletions(-)
 create mode 100644 src/tools/pw-ctrldump.c

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 16423f534..4437ff90a 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -19,10 +19,13 @@
 #include <spa/param/tag-utils.h>
 #include <spa/param/audio/raw-json.h>
 #include <spa/pod/dynamic.h>
+#include <spa/utils/ringbuffer.h>
 #include <spa/filter-graph/filter-graph.h>
 
 #include <pipewire/impl.h>
 
+#include "pipewire/extensions/session-manager/interfaces.h"
+
 
 #define NAME "filter-chain"
 
@@ -1185,6 +1188,8 @@ static const struct spa_dict_item module_props[] = {
 #include <pipewire/pipewire.h>
 
 #define DEFAULT_RATE	48000
+#define DEFAULT_FEEDBACK_BUFFER_SIZE	49152
+#define DEFAULT_FEEDBACK_MAX_MESSAGE_SIZE	4096;
 
 struct impl {
 	struct pw_context *context;
@@ -1213,6 +1218,16 @@ struct impl {
 	struct spa_hook control_listener;
 	bool control_stream_active;
 
+	struct pw_properties *feedback_props;
+	struct pw_stream *feedback;
+	struct spa_hook feedback_listener;
+	bool feedback_stream_active;
+
+	struct spa_ringbuffer feedback_ringbuffer;
+	uint32_t feedback_ringbuffer_size;
+	uint32_t feedback_ringbuffer_max_message_size;
+	void *feedback_ringbuffer_data;
+
 	struct spa_audio_info_raw info;
 
 	struct spa_io_position *position;
@@ -1279,7 +1294,7 @@ static void control_process(void *d)
 
 	struct pw_buffer *control = pw_stream_dequeue_buffer(impl->control);
 	if (control == NULL)
-	  	goto done;
+		return;
 	if (control->buffer->n_datas > 0) {
 	  	struct spa_pod *pod = spa_pod_from_data(
 	    		control->buffer->datas[0].data,
@@ -1294,10 +1309,93 @@ static void control_process(void *d)
 		}
 	}
 
-done:
 	pw_stream_queue_buffer(impl->control, control);
 }
 
+static void feedback_process(void *d) {
+	struct impl *impl = d;
+
+	struct pw_buffer *feedback = pw_stream_dequeue_buffer(impl->feedback);
+	if (feedback == NULL) {
+		pw_log_debug("%p: out of control buffers: %m", &impl);
+		return;
+	}
+
+	struct spa_buffer *spa_buffer = feedback->buffer;
+	if (!spa_buffer || spa_buffer->n_datas < 1) {
+		pw_log_warn("control buffer has no data planes");
+		return;
+	}
+
+	struct spa_data *data = &spa_buffer->datas[0];
+	if (!data->data || !data->chunk || data->maxsize == 0) {
+		pw_log_warn("invalid control buffer data");
+		return;
+	}
+
+	struct spa_pod_builder b;
+	spa_pod_builder_init(&b, data->data, data->maxsize);
+
+	struct spa_pod_frame seq_f;
+	spa_pod_builder_push_sequence(&b, &seq_f, 0);
+
+	uint8_t message_buffer[4096];
+	uint32_t index;
+	while (spa_ringbuffer_get_read_index(&impl->feedback_ringbuffer, &index) > 0) {
+		fprintf(stdout, "reading from ringbuffer index: %d\n", index);
+
+		uint64_t pod_data_size;
+		spa_ringbuffer_read_data(
+			&impl->feedback_ringbuffer,
+			impl->feedback_ringbuffer_data,
+			impl->feedback_ringbuffer_size,
+			index % impl->feedback_ringbuffer_size,
+			&pod_data_size,
+			sizeof(uint64_t));
+
+		struct spa_pod_builder_state state;
+		spa_pod_builder_get_state(&b, &state);
+		fprintf(stdout, "pod_data_size: %lu\n", pod_data_size);
+		fprintf(stdout, "builder size:%u maxsize:%d offset:%d\n",
+		        b.size, data->maxsize, state.offset);
+
+		// next control size: round_up_8(sizeof(struct spa_pod_control) + data_size)
+		/*
+		if (pod_data_size + sizeof(struct spa_pod_control) + sizeof(
+			struct spa_pod_sequence) > b.size - state.offset) {
+			fprintf(stdout, "buffer too small\n");
+			pw_log_warn("not enough space in builder for pod data");
+			break;
+		}
+		 */
+
+		spa_ringbuffer_read_data(
+			&impl->feedback_ringbuffer,
+			impl->feedback_ringbuffer_data,
+			impl->feedback_ringbuffer_size,
+			(index + sizeof(uint64_t)) % impl->feedback_ringbuffer_size,
+			&message_buffer,
+			pod_data_size);
+
+		spa_ringbuffer_read_update(&impl->feedback_ringbuffer,
+			index + sizeof(uint64_t) + pod_data_size);
+
+		fprintf(stdout, "adding control data\n");
+		spa_pod_builder_control(&b, 0, SPA_CONTROL_Properties);
+		spa_pod_builder_raw(&b, message_buffer, pod_data_size);
+
+		fprintf(stdout, "builder size:%u maxsize:%d offset:%d\n",
+			b.size, data->maxsize, state.offset);
+	}
+
+	const struct spa_sequence *spa_sequence = spa_pod_builder_pop(&b, &seq_f);
+	const uint32_t seq_size = SPA_POD_SIZE(spa_sequence);
+	data->chunk->offset = 0;
+	data->chunk->size = seq_size;
+	data->chunk->stride = 0;
+	pw_stream_queue_buffer(impl->feedback, feedback);
+}
+
 static void playback_process(void *d)
 {
 	struct impl *impl = d;
@@ -1692,6 +1790,41 @@ static const struct pw_stream_events control_stream_events = {
 	.param_changed = NULL,
 };
 
+static void feedback_destroy(void *d)
+{
+	struct impl *impl = d;
+	spa_hook_remove(&impl->feedback_listener);
+	impl->feedback = NULL;
+}
+
+static void feedback_state_changed(void *data, enum pw_stream_state old,
+				enum pw_stream_state state, const char *error)
+{
+	struct impl *impl = data;
+
+	switch (state) {
+	case PW_STREAM_STATE_PAUSED:
+		pw_stream_flush(impl->feedback, false);
+		break;
+	case PW_STREAM_STATE_ERROR:
+		pw_log_info("module %p: error: %s", impl, error);
+		break;
+	case PW_STREAM_STATE_STREAMING:
+	default:
+		break;
+	}
+	return;
+}
+
+static const struct  pw_stream_events feedback_stream_events = {
+	.version = PW_VERSION_STREAM_EVENTS,
+	.destroy = feedback_destroy,
+	.process = feedback_process,
+	.io_changed = NULL,
+	.state_changed = feedback_state_changed,
+	.param_changed = NULL,
+};
+
 static int setup_streams(struct impl *impl)
 {
 	int res;
@@ -1734,6 +1867,39 @@ static int setup_streams(struct impl *impl)
 			param, 1);
 	}
 
+	if (impl->feedback_stream_active) {
+		impl->feedback = pw_stream_new(impl->core,
+		    "filter feedback", impl->feedback_props);
+		impl->feedback_props = NULL;
+		if (impl->feedback == NULL)
+		  return -errno;
+
+		pw_stream_add_listener(impl->feedback,
+			&impl->feedback_listener,
+			&feedback_stream_events, impl);
+
+		uint8_t buffer[256];
+		struct spa_pod_builder bt = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+		const struct spa_pod *param[1];
+
+		param[0] = spa_pod_builder_add_object(&bt,
+			SPA_TYPE_OBJECT_Format,
+			SPA_PARAM_EnumFormat,
+			SPA_FORMAT_mediaType,
+			SPA_POD_Id(SPA_MEDIA_TYPE_application),
+			SPA_FORMAT_mediaSubtype,
+			SPA_POD_Id(SPA_MEDIA_SUBTYPE_control)
+		);
+
+		pw_stream_connect(impl->feedback,
+			PW_DIRECTION_OUTPUT,
+			PW_ID_ANY,
+			PW_STREAM_FLAG_AUTOCONNECT |
+			PW_STREAM_FLAG_MAP_BUFFERS |
+			PW_STREAM_FLAG_RT_PROCESS,
+			param, 1);
+	}
+
 	impl->capture = pw_stream_new(impl->core,
 			"filter capture", impl->capture_props);
 	impl->capture_props = NULL;
@@ -1895,6 +2061,39 @@ static void graph_props_changed(void *object, enum spa_direction direction)
 	spa_filter_graph_get_props(graph, &b.b, (struct spa_pod **)&params[0]);
 
 	pw_stream_update_params(impl->capture, params, 1);
+
+	fprintf(stdout, "graph props changed\n");
+	uint32_t index;
+	const uint32_t available = impl->feedback_ringbuffer_size
+		- spa_ringbuffer_get_write_index(&impl->feedback_ringbuffer, &index);
+	if (available >= impl->feedback_ringbuffer_max_message_size) {
+		fprintf(stdout, "writing to buffer\n");
+		const uint64_t pod_length = SPA_POD_SIZE(params[0]);
+		const uint64_t full_length = pod_length + sizeof(uint64_t);
+		if (full_length > impl->feedback_ringbuffer_max_message_size) {
+			fprintf(stdout, "feedback ringbuffer full\n");
+			pw_log_warn("feedback ringbuffer message too large");
+		} else {
+			fprintf(stdout, "writing data, pod length: %lu\nindex: %u\n",
+				pod_length, index);
+
+			spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
+				impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
+				index % impl->feedback_ringbuffer_size, &pod_length,
+				sizeof(uint64_t));
+
+			spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
+				impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
+				(index + sizeof(uint64_t)) % impl->feedback_ringbuffer_size, params[0],
+				SPA_POD_SIZE(params[0]));
+
+			spa_ringbuffer_write_update(&impl->feedback_ringbuffer,
+				index + sizeof(uint64_t) + SPA_POD_SIZE(params[0]));
+		}
+	} else {
+		fprintf(stdout, "not enough space in ringbuffer\n");
+	}
+
 	spa_pod_dynamic_builder_clean(&b);
 }
 
@@ -2039,7 +2238,9 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 	impl->capture_props = pw_properties_new(NULL, NULL);
 	impl->playback_props = pw_properties_new(NULL, NULL);
 	impl->control_props = pw_properties_new(NULL, NULL);
-	if (impl->capture_props == NULL || impl->playback_props == NULL || impl->control_props == NULL) {
+	impl->feedback_props = pw_properties_new(NULL, NULL);
+	if (impl->capture_props == NULL || impl->playback_props == NULL ||
+	    impl->control_props == NULL || impl->feedback_props == NULL) {
 		res = -errno;
 		pw_log_error( "can't create properties: %m");
 		goto error;
@@ -2067,6 +2268,8 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 		pw_properties_update_string(impl->playback_props, str, strlen(str));
 	if ((str = pw_properties_get(props, "control.props")) != NULL)
 		pw_properties_update_string(impl->control_props, str, strlen(str));
+	if ((str = pw_properties_get(props, "feedback.props")) != NULL)
+		pw_properties_update_string(impl->feedback_props, str, strlen(str));
 
 	copy_props(impl, props, PW_KEY_AUDIO_RATE);
 	copy_props(impl, props, PW_KEY_AUDIO_CHANNELS);
@@ -2165,6 +2368,14 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 			&core_events, impl);
 
 	impl->control_stream_active = pw_properties_get_bool(impl->control_props, "enabled", false);
+	impl->feedback_stream_active = pw_properties_get_bool(impl->feedback_props, "enabled", false);
+
+	if (impl->feedback_stream_active) {
+		spa_ringbuffer_init(&impl->feedback_ringbuffer);
+		impl->feedback_ringbuffer_data = malloc(DEFAULT_FEEDBACK_BUFFER_SIZE);
+		impl->feedback_ringbuffer_size = DEFAULT_FEEDBACK_BUFFER_SIZE;
+		impl->feedback_ringbuffer_max_message_size = DEFAULT_FEEDBACK_MAX_MESSAGE_SIZE;
+	}
 
 	setup_streams(impl);
 
diff --git a/src/tools/meson.build b/src/tools/meson.build
index 103b48adc..c2b070d7a 100644
--- a/src/tools/meson.build
+++ b/src/tools/meson.build
@@ -9,6 +9,7 @@ tools_sources = [
   [ 'pw-metadata', [ 'pw-metadata.c' ] ],
   [ 'pw-loopback', [ 'pw-loopback.c' ] ],
   [ 'pw-link', [ 'pw-link.c' ] ],
+  [ 'pw-ctrldump', [ 'pw-ctrldump.c' ] ],
 ]
 
 foreach t : tools_sources
diff --git a/src/tools/pw-ctrldump.c b/src/tools/pw-ctrldump.c
new file mode 100644
index 000000000..af3cad92d
--- /dev/null
+++ b/src/tools/pw-ctrldump.c
@@ -0,0 +1,190 @@
+/* PipeWire */
+/* SPDX-FileCopyrightText: Copyright © 2020 Wim Taymans */
+/* SPDX-License-Identifier: MIT */
+
+#include <stdio.h>
+#include <signal.h>
+#include <math.h>
+#include <getopt.h>
+#include <locale.h>
+
+#include <spa/utils/result.h>
+#include <spa/utils/defs.h>
+#include <spa/control/control.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/props.h>
+#include <spa/debug/mem.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/filter.h>
+
+#include "midifile.h"
+
+struct data;
+
+struct port {
+	struct data *data;
+};
+
+struct data {
+	struct pw_main_loop *loop;
+	const char *opt_remote;
+	struct pw_filter *filter;
+	struct port *in_port;
+	int64_t clock_time;
+};
+
+static void on_process(void *_data, struct spa_io_position *position)
+{
+	struct data *data = _data;
+	struct pw_buffer *b;
+	struct spa_buffer *buf;
+	struct spa_data *d;
+	struct spa_pod_parser parser;
+	struct spa_pod_frame frame;
+	struct spa_pod_sequence seq;
+	const void *seq_body, *c_body;
+	struct spa_pod_control c;
+	uint64_t offset;
+
+	offset = data->clock_time;
+	data->clock_time += position->clock.duration;
+
+	b = pw_filter_dequeue_buffer(data->in_port);
+	if (b == NULL)
+		return;
+
+	buf = b->buffer;
+	d = &buf->datas[0];
+
+	if (d->data == NULL)
+		goto done;
+
+	spa_pod_parser_init_from_data(&parser, d->data, d->maxsize, d->chunk->offset, d->chunk->size);
+
+	if (spa_pod_parser_push_sequence_body(&parser, &frame, &seq, &seq_body) < 0)
+		goto done;
+
+	while (spa_pod_parser_get_control_body(&parser, &c, &c_body) >= 0) {
+		struct midi_event ev;
+
+		if (c.type != SPA_CONTROL_Properties)
+			continue;
+
+		fprintf(stdout, "received message");
+	}
+
+done:
+	pw_filter_queue_buffer(data->in_port, b);
+}
+
+static const struct pw_filter_events filter_events = {
+	PW_VERSION_FILTER_EVENTS,
+	.process = on_process,
+};
+
+static void do_quit(void *userdata, int signal_number)
+{
+	struct data *data = userdata;
+	pw_main_loop_quit(data->loop);
+}
+
+static int dump_filter(struct data *data)
+{
+	data->loop = pw_main_loop_new(NULL);
+	if (data->loop == NULL)
+		return -errno;
+
+	pw_loop_add_signal(pw_main_loop_get_loop(data->loop), SIGINT, do_quit, data);
+	pw_loop_add_signal(pw_main_loop_get_loop(data->loop), SIGTERM, do_quit, data);
+
+	data->filter = pw_filter_new_simple(
+			pw_main_loop_get_loop(data->loop),
+			"ctrl-dump",
+			pw_properties_new(
+				PW_KEY_REMOTE_NAME, data->opt_remote,
+				PW_KEY_MEDIA_TYPE, "Control",
+				PW_KEY_MEDIA_CATEGORY, "Filter",
+				PW_KEY_MEDIA_ROLE, "DSP",
+				NULL),
+			&filter_events,
+			data);
+
+	data->in_port = pw_filter_add_port(data->filter,
+			PW_DIRECTION_INPUT,
+			PW_FILTER_PORT_FLAG_MAP_BUFFERS,
+			sizeof(struct port),
+			pw_properties_new(
+				PW_KEY_FORMAT_DSP, "8 bit raw",
+				PW_KEY_PORT_NAME, "input",
+				NULL),
+			NULL, 0);
+
+	if (pw_filter_connect(data->filter, PW_FILTER_FLAG_RT_PROCESS, NULL, 0) < 0) {
+		fprintf(stderr, "can't connect\n");
+		return -1;
+	}
+
+	pw_main_loop_run(data->loop);
+
+	pw_filter_destroy(data->filter);
+	pw_main_loop_destroy(data->loop);
+
+	return 0;
+}
+
+static void show_help(const char *name, bool error)
+{
+	fprintf(error ? stderr : stdout, "%s [options] [FILE]\n"
+		"  -h, --help                            Show this help\n"
+		"      --version                         Show version\n"
+		"  -r, --remote                          Remote daemon name\n",
+		name);
+}
+
+int main(int argc, char *argv[])
+{
+	struct data data = { 0, };
+	int res = 0, c;
+	static const struct option long_options[] = {
+		{ "help",	no_argument,		NULL, 'h' },
+		{ "version",	no_argument,		NULL, 'V' },
+		{ "remote",	required_argument,	NULL, 'r' },
+		{ NULL,	0, NULL, 0}
+	};
+
+	setlocale(LC_ALL, "");
+	pw_init(&argc, &argv);
+
+	setlinebuf(stdout);
+
+	while ((c = getopt_long(argc, argv, "hVr:", long_options, NULL)) != -1) {
+		switch (c) {
+		case 'h':
+			show_help(argv[0], false);
+			return 0;
+		case 'V':
+			printf("%s\n"
+				"Compiled with libpipewire %s\n"
+				"Linked with libpipewire %s\n",
+				argv[0],
+				pw_get_headers_version(),
+				pw_get_library_version());
+			return 0;
+		case 'r':
+			data.opt_remote = optarg;
+			break;
+		default:
+			show_help(argv[0], true);
+			return -1;
+		}
+	}
+
+	if (optind < argc) {
+		fprintf(stderr, "write to file not possible\n");
+	} else {
+		res = dump_filter(&data);
+	}
+	pw_deinit();
+	return res;
+}

From 2f36f4009a5308e424a47b709f3d4f3b1e0a9ab4 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 18:29:17 -0400
Subject: [PATCH 21/26] Use real size to determine if we have room for the
 message

---
 src/modules/module-filter-chain.c | 44 +++++++++++++++----------------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 4437ff90a..27efc4c52 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -1189,7 +1189,6 @@ static const struct spa_dict_item module_props[] = {
 
 #define DEFAULT_RATE	48000
 #define DEFAULT_FEEDBACK_BUFFER_SIZE	49152
-#define DEFAULT_FEEDBACK_MAX_MESSAGE_SIZE	4096;
 
 struct impl {
 	struct pw_context *context;
@@ -1225,7 +1224,6 @@ struct impl {
 
 	struct spa_ringbuffer feedback_ringbuffer;
 	uint32_t feedback_ringbuffer_size;
-	uint32_t feedback_ringbuffer_max_message_size;
 	void *feedback_ringbuffer_data;
 
 	struct spa_audio_info_raw info;
@@ -2066,30 +2064,25 @@ static void graph_props_changed(void *object, enum spa_direction direction)
 	uint32_t index;
 	const uint32_t available = impl->feedback_ringbuffer_size
 		- spa_ringbuffer_get_write_index(&impl->feedback_ringbuffer, &index);
-	if (available >= impl->feedback_ringbuffer_max_message_size) {
+	const uint64_t pod_length = SPA_POD_SIZE(params[0]);
+	const uint64_t full_length = pod_length + sizeof(uint64_t);
+	if (available >= full_length) {
 		fprintf(stdout, "writing to buffer\n");
-		const uint64_t pod_length = SPA_POD_SIZE(params[0]);
-		const uint64_t full_length = pod_length + sizeof(uint64_t);
-		if (full_length > impl->feedback_ringbuffer_max_message_size) {
-			fprintf(stdout, "feedback ringbuffer full\n");
-			pw_log_warn("feedback ringbuffer message too large");
-		} else {
-			fprintf(stdout, "writing data, pod length: %lu\nindex: %u\n",
-				pod_length, index);
+		fprintf(stdout, "writing data, pod length: %lu\nindex: %u\n",
+			pod_length, index);
 
-			spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
-				impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
-				index % impl->feedback_ringbuffer_size, &pod_length,
-				sizeof(uint64_t));
+		spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
+			impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
+			index % impl->feedback_ringbuffer_size, &pod_length,
+			sizeof(uint64_t));
 
-			spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
-				impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
-				(index + sizeof(uint64_t)) % impl->feedback_ringbuffer_size, params[0],
-				SPA_POD_SIZE(params[0]));
+		spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
+			impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
+			(index + sizeof(uint64_t)) % impl->feedback_ringbuffer_size, params[0],
+			SPA_POD_SIZE(params[0]));
 
-			spa_ringbuffer_write_update(&impl->feedback_ringbuffer,
-				index + sizeof(uint64_t) + SPA_POD_SIZE(params[0]));
-		}
+		spa_ringbuffer_write_update(&impl->feedback_ringbuffer,
+			index + sizeof(uint64_t) + SPA_POD_SIZE(params[0]));
 	} else {
 		fprintf(stdout, "not enough space in ringbuffer\n");
 	}
@@ -2320,6 +2313,12 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 	if (pw_properties_get(impl->playback_props, PW_KEY_MEDIA_NAME) == NULL)
 		pw_properties_setf(impl->playback_props, PW_KEY_MEDIA_NAME, "%s output",
 				pw_properties_get(impl->playback_props, PW_KEY_NODE_DESCRIPTION));
+	if (pw_properties_get(impl->control_props, PW_KEY_MEDIA_NAME) == NULL)
+		pw_properties_setf(impl->control_props, PW_KEY_MEDIA_NAME, "%s control",
+				pw_properties_get(impl->control_props, PW_KEY_NODE_DESCRIPTION));
+	if (pw_properties_get(impl->feedback_props, PW_KEY_MEDIA_NAME) == NULL)
+		pw_properties_setf(impl->feedback_props, PW_KEY_MEDIA_NAME, "%s feedback",
+				pw_properties_get(impl->feedback_props, PW_KEY_NODE_DESCRIPTION));
 
 	p = pw_context_get_properties(impl->context);
 	pw_properties_set(props, "clock.quantum-limit",
@@ -2374,7 +2373,6 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 		spa_ringbuffer_init(&impl->feedback_ringbuffer);
 		impl->feedback_ringbuffer_data = malloc(DEFAULT_FEEDBACK_BUFFER_SIZE);
 		impl->feedback_ringbuffer_size = DEFAULT_FEEDBACK_BUFFER_SIZE;
-		impl->feedback_ringbuffer_max_message_size = DEFAULT_FEEDBACK_MAX_MESSAGE_SIZE;
 	}
 
 	setup_streams(impl);

From 2f7d2a6668602415898b2aa5d1bc339adf8faf1a Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 18:41:30 -0400
Subject: [PATCH 22/26] Only add to ringbuffer if feedback stream is active

---
 src/modules/module-filter-chain.c | 46 ++++++++++++++++---------------
 1 file changed, 24 insertions(+), 22 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 27efc4c52..2f7f4b4c1 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -2060,31 +2060,33 @@ static void graph_props_changed(void *object, enum spa_direction direction)
 
 	pw_stream_update_params(impl->capture, params, 1);
 
-	fprintf(stdout, "graph props changed\n");
-	uint32_t index;
-	const uint32_t available = impl->feedback_ringbuffer_size
-		- spa_ringbuffer_get_write_index(&impl->feedback_ringbuffer, &index);
-	const uint64_t pod_length = SPA_POD_SIZE(params[0]);
-	const uint64_t full_length = pod_length + sizeof(uint64_t);
-	if (available >= full_length) {
-		fprintf(stdout, "writing to buffer\n");
-		fprintf(stdout, "writing data, pod length: %lu\nindex: %u\n",
-			pod_length, index);
+	if (impl->feedback_stream_active) {
+		fprintf(stdout, "graph props changed\n");
+		uint32_t index;
+		int32_t write_index_return = spa_ringbuffer_get_write_index(&impl->feedback_ringbuffer, &index);
+		const uint32_t available = impl->feedback_ringbuffer_size - write_index_return;
+		const uint64_t pod_length = SPA_POD_SIZE(params[0]);
+		const uint64_t full_length = pod_length + sizeof(uint64_t);
+		if (available >= full_length) {
+			fprintf(stdout, "writing to buffer\n");
+			fprintf(stdout, "writing data, pod length: %lu\nindex: %u\n",
+				pod_length, index);
 
-		spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
-			impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
-			index % impl->feedback_ringbuffer_size, &pod_length,
-			sizeof(uint64_t));
+			spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
+				impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
+				index % impl->feedback_ringbuffer_size, &pod_length,
+				sizeof(uint64_t));
 
-		spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
-			impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
-			(index + sizeof(uint64_t)) % impl->feedback_ringbuffer_size, params[0],
-			SPA_POD_SIZE(params[0]));
+			spa_ringbuffer_write_data(&impl->feedback_ringbuffer,
+				impl->feedback_ringbuffer_data, impl->feedback_ringbuffer_size,
+				(index + sizeof(uint64_t)) % impl->feedback_ringbuffer_size, params[0],
+				SPA_POD_SIZE(params[0]));
 
-		spa_ringbuffer_write_update(&impl->feedback_ringbuffer,
-			index + sizeof(uint64_t) + SPA_POD_SIZE(params[0]));
-	} else {
-		fprintf(stdout, "not enough space in ringbuffer\n");
+			spa_ringbuffer_write_update(&impl->feedback_ringbuffer,
+				index + sizeof(uint64_t) + SPA_POD_SIZE(params[0]));
+		} else {
+			fprintf(stdout, "not enough space in ringbuffer, available: %u, required: %lu, write index return: %i, buffer size: %u\n", available, full_length, write_index_return, impl->feedback_ringbuffer_size);
+		}
 	}
 
 	spa_pod_dynamic_builder_clean(&b);

From cec3130c77b0a6682dffcbb9006997a91719cb5e Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 19:16:11 -0400
Subject: [PATCH 23/26] copy relevant props

---
 src/modules/module-filter-chain.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 2f7f4b4c1..1d2bc0124 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -2197,6 +2197,22 @@ static void copy_props(struct impl *impl, struct pw_properties *props, const cha
 	}
 }
 
+static void copy_props_control(struct impl *impl, struct pw_properties *props, const char *key)
+{
+	const char *str;
+	if ((str = pw_properties_get(props, key)) != NULL) {
+		if (impl->control_stream_active) {
+			if (pw_properties_get(impl->control_props, key) == NULL)
+				pw_properties_set(impl->control_props, key, str);
+		}
+
+		if (impl->feedback_stream_active) {
+			if (pw_properties_get(impl->feedback_props, key) == NULL)
+				pw_properties_set(impl->feedback_props, key, str);
+		}
+	}
+}
+
 SPA_EXPORT
 int pipewire__module_init(struct pw_impl_module *module, const char *args)
 {
@@ -2277,6 +2293,12 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 	copy_props(impl, props, PW_KEY_MEDIA_NAME);
 	copy_props(impl, props, "resample.prefill");
 
+	copy_props_control(impl, props, PW_KEY_NODE_DESCRIPTION);
+	copy_props_control(impl, props, PW_KEY_NODE_GROUP);
+	copy_props_control(impl, props, PW_KEY_NODE_LINK_GROUP);
+	copy_props_control(impl, props, PW_KEY_NODE_VIRTUAL);
+	copy_props_control(impl, props, PW_KEY_MEDIA_NAME);
+
 	parse_audio_info(impl->capture_props, &impl->capture_info);
 	parse_audio_info(impl->playback_props, &impl->playback_info);
 

From 2a62e6e977153a17ff1a364476ef19c5628b7a47 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 19:36:41 -0400
Subject: [PATCH 24/26] actually copy relevant props if control or feedback
 stream enabled

---
 src/modules/module-filter-chain.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 1d2bc0124..cb091aab0 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -2293,6 +2293,15 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 	copy_props(impl, props, PW_KEY_MEDIA_NAME);
 	copy_props(impl, props, "resample.prefill");
 
+	impl->control_stream_active = pw_properties_get_bool(impl->control_props, "enabled", false);
+	impl->feedback_stream_active = pw_properties_get_bool(impl->feedback_props, "enabled", false);
+
+	if (impl->feedback_stream_active) {
+		spa_ringbuffer_init(&impl->feedback_ringbuffer);
+		impl->feedback_ringbuffer_data = malloc(DEFAULT_FEEDBACK_BUFFER_SIZE);
+		impl->feedback_ringbuffer_size = DEFAULT_FEEDBACK_BUFFER_SIZE;
+	}
+
 	copy_props_control(impl, props, PW_KEY_NODE_DESCRIPTION);
 	copy_props_control(impl, props, PW_KEY_NODE_GROUP);
 	copy_props_control(impl, props, PW_KEY_NODE_LINK_GROUP);
@@ -2390,15 +2399,6 @@ int pipewire__module_init(struct pw_impl_module *module, const char *args)
 			&impl->core_listener,
 			&core_events, impl);
 
-	impl->control_stream_active = pw_properties_get_bool(impl->control_props, "enabled", false);
-	impl->feedback_stream_active = pw_properties_get_bool(impl->feedback_props, "enabled", false);
-
-	if (impl->feedback_stream_active) {
-		spa_ringbuffer_init(&impl->feedback_ringbuffer);
-		impl->feedback_ringbuffer_data = malloc(DEFAULT_FEEDBACK_BUFFER_SIZE);
-		impl->feedback_ringbuffer_size = DEFAULT_FEEDBACK_BUFFER_SIZE;
-	}
-
 	setup_streams(impl);
 
 	pw_impl_module_add_listener(module, &impl->module_listener, &module_events, impl);

From be398ae64800faade47c9595b5c12aaa20735fc9 Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 22:45:02 -0400
Subject: [PATCH 25/26] delete feedback stream

---
 src/modules/module-filter-chain.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index cb091aab0..30d57b158 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -2134,13 +2134,15 @@ static const struct pw_proxy_events core_proxy_events = {
 
 static void impl_destroy(struct impl *impl)
 {
-	/* disconnect both streams before destroying any of them */
+	/* disconnect all streams before destroying any of them */
 	if (impl->capture)
 		pw_stream_disconnect(impl->capture);
 	if (impl->playback)
 		pw_stream_disconnect(impl->playback);
 	if (impl->control)
 		pw_stream_disconnect(impl->control);
+	if (impl->feedback)
+		pw_stream_disconnect(impl->feedback);
 
 	if (impl->capture)
 		pw_stream_destroy(impl->capture);
@@ -2148,6 +2150,8 @@ static void impl_destroy(struct impl *impl)
 		pw_stream_destroy(impl->playback);
 	if (impl->control)
 		pw_stream_destroy(impl->control);
+	if (impl->feedback)
+		pw_stream_destroy(impl->feedback);
 
 	if (impl->core && impl->do_disconnect)
 		pw_core_disconnect(impl->core);

From c38e1b040bd3272f46a9cece9c620931144a633e Mon Sep 17 00:00:00 2001
From: Frank Krick <frank.krick@gmail.com>
Date: Thu, 28 Aug 2025 22:48:06 -0400
Subject: [PATCH 26/26] free feedback properties

---
 src/modules/module-filter-chain.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/modules/module-filter-chain.c b/src/modules/module-filter-chain.c
index 30d57b158..b9794a9ea 100644
--- a/src/modules/module-filter-chain.c
+++ b/src/modules/module-filter-chain.c
@@ -2162,6 +2162,7 @@ static void impl_destroy(struct impl *impl)
 	pw_properties_free(impl->capture_props);
 	pw_properties_free(impl->playback_props);
 	pw_properties_free(impl->control_props);
+	pw_properties_free(impl->feedback_props);
 
 	pw_properties_free(impl->props);
 	free(impl);