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

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

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