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] 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;
 }