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