Format all code with clang-format

7 files changed, 961 insertions, 967 deletions

diff --git a/utils/bench.h b/utils/bench.h
index a04996b..28e5221 100644
--- a/utils/bench.h
+++ b/utils/bench.h
@@ -30,24 +30,24 @@ typedef struct timespec BenchmarkTime;
 static inline double
 bench_elapsed_s(const BenchmarkTime* start, const BenchmarkTime* end)
 {
-	return ((end->tv_sec - start->tv_sec)
-	        + ((end->tv_nsec - start->tv_nsec) * 0.000000001));
+  return ((end->tv_sec - start->tv_sec) +
+          ((end->tv_nsec - start->tv_nsec) * 0.000000001));
 }
 
 static inline BenchmarkTime
 bench_start(void)
 {
-	BenchmarkTime start_t;
-	clock_gettime(CLOCK_REALTIME, &start_t);
-	return start_t;
+  BenchmarkTime start_t;
+  clock_gettime(CLOCK_REALTIME, &start_t);
+  return start_t;
 }
 
 static inline double
 bench_end(const BenchmarkTime* start_t)
 {
-	BenchmarkTime end_t;
-	clock_gettime(CLOCK_REALTIME, &end_t);
-	return bench_elapsed_s(start_t, &end_t);
+  BenchmarkTime end_t;
+  clock_gettime(CLOCK_REALTIME, &end_t);
+  return bench_elapsed_s(start_t, &end_t);
 }
 
-#endif  /* BENCH_H */
+#endif /* BENCH_H */
diff --git a/utils/lilv-bench.c b/utils/lilv-bench.c
index 59e49fe..3068123 100644
--- a/utils/lilv-bench.c
+++ b/utils/lilv-bench.c
@@ -19,16 +19,16 @@
 int
 main(int argc, char** argv)
 {
-	LilvWorld* world = lilv_world_new();
-	lilv_world_load_all(world);
+  LilvWorld* world = lilv_world_new();
+  lilv_world_load_all(world);
 
-	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
-	LILV_FOREACH(plugins, p, plugins) {
-		const LilvPlugin* plugin = lilv_plugins_get(plugins, p);
-		lilv_plugin_get_class(plugin);
-	}
+  const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+  LILV_FOREACH (plugins, p, plugins) {
+    const LilvPlugin* plugin = lilv_plugins_get(plugins, p);
+    lilv_plugin_get_class(plugin);
+  }
 
-	lilv_world_free(world);
+  lilv_world_free(world);
 
-	return 0;
+  return 0;
 }
diff --git a/utils/lv2apply.c b/utils/lv2apply.c
index 1d11c50..0a1123a 100644
--- a/utils/lv2apply.c
+++ b/utils/lv2apply.c
@@ -28,73 +28,71 @@
 #include <string.h>
 
 #if defined(__GNUC__)
-#    define LILV_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+#  define LILV_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
 #else
-#    define LILV_LOG_FUNC(fmt, arg1)
+#  define LILV_LOG_FUNC(fmt, arg1)
 #endif
 
 /** Control port value set from the command line */
 typedef struct Param {
-	const char* sym;    ///< Port symbol
-	float       value;  ///< Control value
+  const char* sym;   ///< Port symbol
+  float       value; ///< Control value
 } Param;
 
 /** Port type (only float ports are supported) */
-typedef enum {
-	TYPE_CONTROL,
-	TYPE_AUDIO
-} PortType;
+typedef enum { TYPE_CONTROL, TYPE_AUDIO } PortType;
 
 /** Runtime port information */
 typedef struct {
-	const LilvPort* lilv_port;  ///< Port description
-	PortType        type;       ///< Datatype
-	uint32_t        index;      ///< Port index
-	float           value;      ///< Control value (if applicable)
-	bool            is_input;   ///< True iff an input port
-	bool            optional;   ///< True iff connection optional
+  const LilvPort* lilv_port; ///< Port description
+  PortType        type;      ///< Datatype
+  uint32_t        index;     ///< Port index
+  float           value;     ///< Control value (if applicable)
+  bool            is_input;  ///< True iff an input port
+  bool            optional;  ///< True iff connection optional
 } Port;
 
 /** Application state */
 typedef struct {
-	LilvWorld*        world;
-	const LilvPlugin* plugin;
-	LilvInstance*     instance;
-	const char*       in_path;
-	const char*       out_path;
-	SNDFILE*          in_file;
-	SNDFILE*          out_file;
-	unsigned          n_params;
-	Param*            params;
-	unsigned          n_ports;
-	unsigned          n_audio_in;
-	unsigned          n_audio_out;
-	Port*             ports;
+  LilvWorld*        world;
+  const LilvPlugin* plugin;
+  LilvInstance*     instance;
+  const char*       in_path;
+  const char*       out_path;
+  SNDFILE*          in_file;
+  SNDFILE*          out_file;
+  unsigned          n_params;
+  Param*            params;
+  unsigned          n_ports;
+  unsigned          n_audio_in;
+  unsigned          n_audio_out;
+  Port*             ports;
 } LV2Apply;
 
-static int fatal(LV2Apply* self, int status, const char* fmt, ...);
+static int
+fatal(LV2Apply* self, int status, const char* fmt, ...);
 
 /** Open a sound file with error handling. */
 static SNDFILE*
 sopen(LV2Apply* self, const char* path, int mode, SF_INFO* fmt)
 {
-	SNDFILE*  file = sf_open(path, mode, fmt);
-	const int st   = sf_error(file);
-	if (st) {
-		fatal(self, 1, "Failed to open %s (%s)\n", path, sf_error_number(st));
-		return NULL;
-	}
-	return file;
+  SNDFILE*  file = sf_open(path, mode, fmt);
+  const int st   = sf_error(file);
+  if (st) {
+    fatal(self, 1, "Failed to open %s (%s)\n", path, sf_error_number(st));
+    return NULL;
+  }
+  return file;
 }
 
 /** Close a sound file with error handling. */
 static void
 sclose(const char* path, SNDFILE* file)
 {
-	int st = 0;
-	if (file && (st = sf_close(file))) {
-		fatal(NULL, 1, "Failed to close %s (%s)\n", path, sf_error_number(st));
-	}
+  int st = 0;
+  if (file && (st = sf_close(file))) {
+    fatal(NULL, 1, "Failed to close %s (%s)\n", path, sf_error_number(st));
+  }
 }
 
 /**
@@ -106,24 +104,24 @@ sclose(const char* path, SNDFILE* file)
 static bool
 sread(SNDFILE* file, unsigned file_chans, float* buf, unsigned buf_chans)
 {
-	const sf_count_t n_read = sf_readf_float(file, buf, 1);
-	for (unsigned i = file_chans - 1; i < buf_chans; ++i) {
-		buf[i] = buf[i % file_chans];
-	}
-	return n_read == 1;
+  const sf_count_t n_read = sf_readf_float(file, buf, 1);
+  for (unsigned i = file_chans - 1; i < buf_chans; ++i) {
+    buf[i] = buf[i % file_chans];
+  }
+  return n_read == 1;
 }
 
 /** Clean up all resources. */
 static int
 cleanup(int status, LV2Apply* self)
 {
-	sclose(self->in_path, self->in_file);
-	sclose(self->out_path, self->out_file);
-	lilv_instance_free(self->instance);
-	lilv_world_free(self->world);
-	free(self->ports);
-	free(self->params);
-	return status;
+  sclose(self->in_path, self->in_file);
+  sclose(self->out_path, self->out_file);
+  lilv_instance_free(self->instance);
+  lilv_world_free(self->world);
+  free(self->ports);
+  free(self->params);
+  return status;
 }
 
 /** Print a fatal error and clean up for exit. */
@@ -131,12 +129,12 @@ LILV_LOG_FUNC(3, 4)
 static int
 fatal(LV2Apply* self, int status, const char* fmt, ...)
 {
-	va_list args;
-	va_start(args, fmt);
-	fprintf(stderr, "error: ");
-	vfprintf(stderr, fmt, args);
-	va_end(args);
-	return self ? cleanup(status, self) : status;
+  va_list args;
+  va_start(args, fmt);
+  fprintf(stderr, "error: ");
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+  return self ? cleanup(status, self) : status;
 }
 
 /**
@@ -145,225 +143,226 @@ fatal(LV2Apply* self, int status, const char* fmt, ...)
 static int
 create_ports(LV2Apply* self)
 {
-	LilvWorld*     world   = self->world;
-	const uint32_t n_ports = lilv_plugin_get_num_ports(self->plugin);
-
-	self->n_ports = n_ports;
-	self->ports   = (Port*)calloc(self->n_ports, sizeof(Port));
-
-	/* Get default values for all ports */
-	float* values = (float*)calloc(n_ports, sizeof(float));
-	lilv_plugin_get_port_ranges_float(self->plugin, NULL, NULL, values);
-
-	LilvNode* lv2_InputPort          = lilv_new_uri(world, LV2_CORE__InputPort);
-	LilvNode* lv2_OutputPort         = lilv_new_uri(world, LV2_CORE__OutputPort);
-	LilvNode* lv2_AudioPort          = lilv_new_uri(world, LV2_CORE__AudioPort);
-	LilvNode* lv2_ControlPort        = lilv_new_uri(world, LV2_CORE__ControlPort);
-	LilvNode* lv2_connectionOptional = lilv_new_uri(world, LV2_CORE__connectionOptional);
-
-	for (uint32_t i = 0; i < n_ports; ++i) {
-		Port*           port  = &self->ports[i];
-		const LilvPort* lport = lilv_plugin_get_port_by_index(self->plugin, i);
-
-		port->lilv_port = lport;
-		port->index     = i;
-		port->value     = isnan(values[i]) ? 0.0f : values[i];
-		port->optional  = lilv_port_has_property(
-			self->plugin, lport, lv2_connectionOptional);
-
-		/* Check if port is an input or output */
-		if (lilv_port_is_a(self->plugin, lport, lv2_InputPort)) {
-			port->is_input = true;
-		} else if (!lilv_port_is_a(self->plugin, lport, lv2_OutputPort) &&
-		           !port->optional) {
-			return fatal(self, 1, "Port %u is neither input nor output\n", i);
-		}
-
-		/* Check if port is an audio or control port */
-		if (lilv_port_is_a(self->plugin, lport, lv2_ControlPort)) {
-			port->type = TYPE_CONTROL;
-		} else if (lilv_port_is_a(self->plugin, lport, lv2_AudioPort)) {
-			port->type = TYPE_AUDIO;
-			if (port->is_input) {
-				++self->n_audio_in;
-			} else {
-				++self->n_audio_out;
-			}
-		} else if (!port->optional) {
-			return fatal(self, 1, "Port %u has unsupported type\n", i);
-		}
-	}
-
-	lilv_node_free(lv2_connectionOptional);
-	lilv_node_free(lv2_ControlPort);
-	lilv_node_free(lv2_AudioPort);
-	lilv_node_free(lv2_OutputPort);
-	lilv_node_free(lv2_InputPort);
-	free(values);
-
-	return 0;
+  LilvWorld*     world   = self->world;
+  const uint32_t n_ports = lilv_plugin_get_num_ports(self->plugin);
+
+  self->n_ports = n_ports;
+  self->ports   = (Port*)calloc(self->n_ports, sizeof(Port));
+
+  /* Get default values for all ports */
+  float* values = (float*)calloc(n_ports, sizeof(float));
+  lilv_plugin_get_port_ranges_float(self->plugin, NULL, NULL, values);
+
+  LilvNode* lv2_InputPort   = lilv_new_uri(world, LV2_CORE__InputPort);
+  LilvNode* lv2_OutputPort  = lilv_new_uri(world, LV2_CORE__OutputPort);
+  LilvNode* lv2_AudioPort   = lilv_new_uri(world, LV2_CORE__AudioPort);
+  LilvNode* lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort);
+  LilvNode* lv2_connectionOptional =
+    lilv_new_uri(world, LV2_CORE__connectionOptional);
+
+  for (uint32_t i = 0; i < n_ports; ++i) {
+    Port*           port  = &self->ports[i];
+    const LilvPort* lport = lilv_plugin_get_port_by_index(self->plugin, i);
+
+    port->lilv_port = lport;
+    port->index     = i;
+    port->value     = isnan(values[i]) ? 0.0f : values[i];
+    port->optional =
+      lilv_port_has_property(self->plugin, lport, lv2_connectionOptional);
+
+    /* Check if port is an input or output */
+    if (lilv_port_is_a(self->plugin, lport, lv2_InputPort)) {
+      port->is_input = true;
+    } else if (!lilv_port_is_a(self->plugin, lport, lv2_OutputPort) &&
+               !port->optional) {
+      return fatal(self, 1, "Port %u is neither input nor output\n", i);
+    }
+
+    /* Check if port is an audio or control port */
+    if (lilv_port_is_a(self->plugin, lport, lv2_ControlPort)) {
+      port->type = TYPE_CONTROL;
+    } else if (lilv_port_is_a(self->plugin, lport, lv2_AudioPort)) {
+      port->type = TYPE_AUDIO;
+      if (port->is_input) {
+        ++self->n_audio_in;
+      } else {
+        ++self->n_audio_out;
+      }
+    } else if (!port->optional) {
+      return fatal(self, 1, "Port %u has unsupported type\n", i);
+    }
+  }
+
+  lilv_node_free(lv2_connectionOptional);
+  lilv_node_free(lv2_ControlPort);
+  lilv_node_free(lv2_AudioPort);
+  lilv_node_free(lv2_OutputPort);
+  lilv_node_free(lv2_InputPort);
+  free(values);
+
+  return 0;
 }
 
 static void
 print_version(void)
 {
-	printf(
-		"lv2apply (lilv) " LILV_VERSION "\n"
-		"Copyright 2007-2019 David Robillard <http://drobilla.net>\n"
-		"License: <http://www.opensource.org/licenses/isc-license>\n"
-		"This is free software: you are free to change and redistribute it.\n"
-		"There is NO WARRANTY, to the extent permitted by law.\n");
+  printf("lv2apply (lilv) " LILV_VERSION "\n"
+         "Copyright 2007-2019 David Robillard <http://drobilla.net>\n"
+         "License: <http://www.opensource.org/licenses/isc-license>\n"
+         "This is free software: you are free to change and redistribute it.\n"
+         "There is NO WARRANTY, to the extent permitted by law.\n");
 }
 
 static int
 print_usage(int status)
 {
-	fprintf(status ? stderr : stdout,
-	        "Usage: lv2apply [OPTION]... PLUGIN_URI\n"
-	        "Apply an LV2 plugin to an audio file.\n\n"
-	        "  -i IN_FILE   Input file\n"
-	        "  -o OUT_FILE  Output file\n"
-	        "  -c SYM VAL   Control value\n"
-	        "  --help       Display this help and exit\n"
-	        "  --version    Display version information and exit\n");
-	return status;
+  fprintf(status ? stderr : stdout,
+          "Usage: lv2apply [OPTION]... PLUGIN_URI\n"
+          "Apply an LV2 plugin to an audio file.\n\n"
+          "  -i IN_FILE   Input file\n"
+          "  -o OUT_FILE  Output file\n"
+          "  -c SYM VAL   Control value\n"
+          "  --help       Display this help and exit\n"
+          "  --version    Display version information and exit\n");
+  return status;
 }
 
 int
 main(int argc, char** argv)
 {
-	LV2Apply self = {
-		NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 0, NULL
-	};
-
-	/* Parse command line arguments */
-	const char* plugin_uri = NULL;
-	for (int i = 1; i < argc; ++i) {
-		if (!strcmp(argv[i], "--version")) {
-			free(self.params);
-			print_version();
-			return 0;
-		}
-
-		if (!strcmp(argv[i], "--help")) {
-			free(self.params);
-			return print_usage(0);
-		}
-
-		if (!strcmp(argv[i], "-i")) {
-			self.in_path = argv[++i];
-		} else if (!strcmp(argv[i], "-o")) {
-			self.out_path = argv[++i];
-		} else if (!strcmp(argv[i], "-c")) {
-			if (argc < i + 3) {
-				return fatal(&self, 1, "Missing argument for -c\n");
-			}
-			self.params = (Param*)realloc(self.params,
-			                              ++self.n_params * sizeof(Param));
-			self.params[self.n_params - 1].sym   = argv[++i];
-			self.params[self.n_params - 1].value = atof(argv[++i]);
-		} else if (argv[i][0] == '-') {
-			free(self.params);
-			return print_usage(1);
-		} else if (i == argc - 1) {
-			plugin_uri = argv[i];
-		}
-	}
-
-	/* Check that required arguments are given */
-	if (!self.in_path || !self.out_path || !plugin_uri) {
-		free(self.params);
-		return print_usage(1);
-	}
-
-	/* Create world and plugin URI */
-	self.world = lilv_world_new();
-	LilvNode* uri = lilv_new_uri(self.world, plugin_uri);
-	if (!uri) {
-		return fatal(&self, 2, "Invalid plugin URI <%s>\n", plugin_uri);
-	}
-
-	/* Discover world */
-	lilv_world_load_all(self.world);
-
-	/* Get plugin */
-	const LilvPlugins* plugins = lilv_world_get_all_plugins(self.world);
-	const LilvPlugin*  plugin  = lilv_plugins_get_by_uri(plugins, uri);
-	lilv_node_free(uri);
-	if (!(self.plugin = plugin)) {
-		return fatal(&self, 3, "Plugin <%s> not found\n", plugin_uri);
-	}
-
-	/* Open input file */
-	SF_INFO in_fmt = { 0, 0, 0, 0, 0, 0 };
-	if (!(self.in_file = sopen(&self, self.in_path, SFM_READ, &in_fmt))) {
-		return 4;
-	}
-
-	/* Create port structures */
-	if (create_ports(&self)) {
-		return 5;
-	}
-
-	if (self.n_audio_in == 0 ||
-	    (in_fmt.channels != (int)self.n_audio_in && in_fmt.channels != 1)) {
-		return fatal(&self, 6, "Unable to map %d inputs to %u ports\n",
-		             in_fmt.channels, self.n_audio_in);
-	}
-
-	/* Set control values */
-	for (unsigned i = 0; i < self.n_params; ++i) {
-		const Param*    param = &self.params[i];
-		LilvNode*       sym   = lilv_new_string(self.world, param->sym);
-		const LilvPort* port  = lilv_plugin_get_port_by_symbol(plugin, sym);
-		lilv_node_free(sym);
-		if (!port) {
-			return fatal(&self, 7, "Unknown port `%s'\n", param->sym);
-		}
-
-		self.ports[lilv_port_get_index(plugin, port)].value = param->value;
-	}
-
-	/* Open output file */
-	SF_INFO out_fmt = in_fmt;
-	out_fmt.channels = self.n_audio_out;
-	if (!(self.out_file = sopen(&self, self.out_path, SFM_WRITE, &out_fmt))) {
-		free(self.ports);
-		return 8;
-	}
-
-	/* Instantiate plugin and connect ports */
-	const uint32_t n_ports = lilv_plugin_get_num_ports(plugin);
-	float          in_buf[self.n_audio_in > 0 ? self.n_audio_in : 1];
-	float          out_buf[self.n_audio_out > 0 ? self.n_audio_out : 1];
-	self.instance = lilv_plugin_instantiate(
-		self.plugin, in_fmt.samplerate, NULL);
-	for (uint32_t p = 0, i = 0, o = 0; p < n_ports; ++p) {
-		if (self.ports[p].type == TYPE_CONTROL) {
-			lilv_instance_connect_port(self.instance, p, &self.ports[p].value);
-		} else if (self.ports[p].type == TYPE_AUDIO) {
-			if (self.ports[p].is_input) {
-				lilv_instance_connect_port(self.instance, p, in_buf + i++);
-			} else {
-				lilv_instance_connect_port(self.instance, p, out_buf + o++);
-			}
-		} else {
-			lilv_instance_connect_port(self.instance, p, NULL);
-		}
-	}
-
-	/* Ports are now connected to buffers in interleaved format, so we can run
-	   a single frame at a time and avoid having to interleave buffers to
-	   read/write from/to sndfile. */
-
-	lilv_instance_activate(self.instance);
-	while (sread(self.in_file, in_fmt.channels, in_buf, self.n_audio_in)) {
-		lilv_instance_run(self.instance, 1);
-		if (sf_writef_float(self.out_file, out_buf, 1) != 1) {
-			return fatal(&self, 9, "Failed to write to output file\n");
-		}
-	}
-	lilv_instance_deactivate(self.instance);
-
-	return cleanup(0, &self);
+  LV2Apply self = {
+    NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 0, NULL};
+
+  /* Parse command line arguments */
+  const char* plugin_uri = NULL;
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp(argv[i], "--version")) {
+      free(self.params);
+      print_version();
+      return 0;
+    }
+
+    if (!strcmp(argv[i], "--help")) {
+      free(self.params);
+      return print_usage(0);
+    }
+
+    if (!strcmp(argv[i], "-i")) {
+      self.in_path = argv[++i];
+    } else if (!strcmp(argv[i], "-o")) {
+      self.out_path = argv[++i];
+    } else if (!strcmp(argv[i], "-c")) {
+      if (argc < i + 3) {
+        return fatal(&self, 1, "Missing argument for -c\n");
+      }
+      self.params =
+        (Param*)realloc(self.params, ++self.n_params * sizeof(Param));
+      self.params[self.n_params - 1].sym   = argv[++i];
+      self.params[self.n_params - 1].value = atof(argv[++i]);
+    } else if (argv[i][0] == '-') {
+      free(self.params);
+      return print_usage(1);
+    } else if (i == argc - 1) {
+      plugin_uri = argv[i];
+    }
+  }
+
+  /* Check that required arguments are given */
+  if (!self.in_path || !self.out_path || !plugin_uri) {
+    free(self.params);
+    return print_usage(1);
+  }
+
+  /* Create world and plugin URI */
+  self.world    = lilv_world_new();
+  LilvNode* uri = lilv_new_uri(self.world, plugin_uri);
+  if (!uri) {
+    return fatal(&self, 2, "Invalid plugin URI <%s>\n", plugin_uri);
+  }
+
+  /* Discover world */
+  lilv_world_load_all(self.world);
+
+  /* Get plugin */
+  const LilvPlugins* plugins = lilv_world_get_all_plugins(self.world);
+  const LilvPlugin*  plugin  = lilv_plugins_get_by_uri(plugins, uri);
+  lilv_node_free(uri);
+  if (!(self.plugin = plugin)) {
+    return fatal(&self, 3, "Plugin <%s> not found\n", plugin_uri);
+  }
+
+  /* Open input file */
+  SF_INFO in_fmt = {0, 0, 0, 0, 0, 0};
+  if (!(self.in_file = sopen(&self, self.in_path, SFM_READ, &in_fmt))) {
+    return 4;
+  }
+
+  /* Create port structures */
+  if (create_ports(&self)) {
+    return 5;
+  }
+
+  if (self.n_audio_in == 0 ||
+      (in_fmt.channels != (int)self.n_audio_in && in_fmt.channels != 1)) {
+    return fatal(&self,
+                 6,
+                 "Unable to map %d inputs to %u ports\n",
+                 in_fmt.channels,
+                 self.n_audio_in);
+  }
+
+  /* Set control values */
+  for (unsigned i = 0; i < self.n_params; ++i) {
+    const Param*    param = &self.params[i];
+    LilvNode*       sym   = lilv_new_string(self.world, param->sym);
+    const LilvPort* port  = lilv_plugin_get_port_by_symbol(plugin, sym);
+    lilv_node_free(sym);
+    if (!port) {
+      return fatal(&self, 7, "Unknown port `%s'\n", param->sym);
+    }
+
+    self.ports[lilv_port_get_index(plugin, port)].value = param->value;
+  }
+
+  /* Open output file */
+  SF_INFO out_fmt  = in_fmt;
+  out_fmt.channels = self.n_audio_out;
+  if (!(self.out_file = sopen(&self, self.out_path, SFM_WRITE, &out_fmt))) {
+    free(self.ports);
+    return 8;
+  }
+
+  /* Instantiate plugin and connect ports */
+  const uint32_t n_ports = lilv_plugin_get_num_ports(plugin);
+  float          in_buf[self.n_audio_in > 0 ? self.n_audio_in : 1];
+  float          out_buf[self.n_audio_out > 0 ? self.n_audio_out : 1];
+  self.instance = lilv_plugin_instantiate(self.plugin, in_fmt.samplerate, NULL);
+  for (uint32_t p = 0, i = 0, o = 0; p < n_ports; ++p) {
+    if (self.ports[p].type == TYPE_CONTROL) {
+      lilv_instance_connect_port(self.instance, p, &self.ports[p].value);
+    } else if (self.ports[p].type == TYPE_AUDIO) {
+      if (self.ports[p].is_input) {
+        lilv_instance_connect_port(self.instance, p, in_buf + i++);
+      } else {
+        lilv_instance_connect_port(self.instance, p, out_buf + o++);
+      }
+    } else {
+      lilv_instance_connect_port(self.instance, p, NULL);
+    }
+  }
+
+  /* Ports are now connected to buffers in interleaved format, so we can run
+     a single frame at a time and avoid having to interleave buffers to
+     read/write from/to sndfile. */
+
+  lilv_instance_activate(self.instance);
+  while (sread(self.in_file, in_fmt.channels, in_buf, self.n_audio_in)) {
+    lilv_instance_run(self.instance, 1);
+    if (sf_writef_float(self.out_file, out_buf, 1) != 1) {
+      return fatal(&self, 9, "Failed to write to output file\n");
+    }
+  }
+  lilv_instance_deactivate(self.instance);
+
+  return cleanup(0, &self);
 }
diff --git a/utils/lv2bench.c b/utils/lv2bench.c
index 000f062..7365b5b 100644
--- a/utils/lv2bench.c
+++ b/utils/lv2bench.c
@@ -47,236 +47,238 @@ static bool full_output = false;
 static void
 print_version(void)
 {
-	printf(
-		"lv2bench (lilv) " LILV_VERSION "\n"
-		"Copyright 2012-2019 David Robillard <http://drobilla.net>\n"
-		"License: <http://www.opensource.org/licenses/isc-license>\n"
-		"This is free software: you are free to change and redistribute it.\n"
-		"There is NO WARRANTY, to the extent permitted by law.\n");
+  printf("lv2bench (lilv) " LILV_VERSION "\n"
+         "Copyright 2012-2019 David Robillard <http://drobilla.net>\n"
+         "License: <http://www.opensource.org/licenses/isc-license>\n"
+         "This is free software: you are free to change and redistribute it.\n"
+         "There is NO WARRANTY, to the extent permitted by law.\n");
 }
 
 static void
 print_usage(void)
 {
-	printf("lv2bench - Benchmark all installed and supported LV2 plugins.\n");
-	printf("Usage: lv2bench [OPTIONS] [PLUGIN_URI]\n");
-	printf("\n");
-	printf("  -b BLOCK_SIZE  Specify block size, in audio frames.\n");
-	printf("  -f, --full     Full plottable output.\n");
-	printf("  -h, --help     Display this help and exit.\n");
-	printf("  -n FRAMES      Total number of audio frames to process\n");
-	printf("  --version      Display version information and exit\n");
+  printf("lv2bench - Benchmark all installed and supported LV2 plugins.\n");
+  printf("Usage: lv2bench [OPTIONS] [PLUGIN_URI]\n");
+  printf("\n");
+  printf("  -b BLOCK_SIZE  Specify block size, in audio frames.\n");
+  printf("  -f, --full     Full plottable output.\n");
+  printf("  -h, --help     Display this help and exit.\n");
+  printf("  -n FRAMES      Total number of audio frames to process\n");
+  printf("  --version      Display version information and exit\n");
 }
 
 static double
 bench(const LilvPlugin* p, uint32_t sample_count, uint32_t block_size)
 {
-	URITable uri_table;
-	uri_table_init(&uri_table);
-
-	LV2_URID_Map       map           = { &uri_table, uri_table_map };
-	LV2_Feature        map_feature   = { LV2_URID_MAP_URI, &map };
-	LV2_URID_Unmap     unmap         = { &uri_table, uri_table_unmap };
-	LV2_Feature        unmap_feature = { LV2_URID_UNMAP_URI, &unmap };
-	const LV2_Feature* features[]    = { &map_feature, &unmap_feature, NULL };
-
-	float* const buf = (float*)calloc(block_size * 2, sizeof(float));
-	float* const in  = buf;
-	float* const out = buf + block_size;
-	if (!buf) {
-		fprintf(stderr, "Out of memory\n");
-		return 0.0;
-	}
-
-	const size_t atom_capacity = 1024;
-
-	LV2_Atom_Sequence seq_in = {
-		{ sizeof(LV2_Atom_Sequence_Body),
-		  uri_table_map(&uri_table, LV2_ATOM__Sequence) },
-		{ 0, 0 } };
-
-	LV2_Atom_Sequence* seq_out = (LV2_Atom_Sequence*)malloc(
-		sizeof(LV2_Atom_Sequence) + atom_capacity);
-
-	const char* uri      = lilv_node_as_string(lilv_plugin_get_uri(p));
-	LilvNodes*  required = lilv_plugin_get_required_features(p);
-	LILV_FOREACH(nodes, i, required) {
-		const LilvNode* feature = lilv_nodes_get(required, i);
-		if (!lilv_node_equals(feature, urid_map)) {
-			fprintf(stderr, "<%s> requires feature <%s>, skipping\n",
-			        uri, lilv_node_as_uri(feature));
-			free(seq_out);
-			free(buf);
-			uri_table_destroy(&uri_table);
-			return 0.0;
-		}
-	}
-
-	LilvInstance* instance = lilv_plugin_instantiate(p, 48000.0, features);
-	if (!instance) {
-		fprintf(stderr, "Failed to instantiate <%s>\n",
-		        lilv_node_as_uri(lilv_plugin_get_uri(p)));
-		free(seq_out);
-		free(buf);
-		uri_table_destroy(&uri_table);
-		return 0.0;
-	}
-
-	const uint32_t n_ports  = lilv_plugin_get_num_ports(p);
-	float* const   mins     = (float*)calloc(n_ports, sizeof(float));
-	float* const   maxes    = (float*)calloc(n_ports, sizeof(float));
-	float* const   controls = (float*)calloc(n_ports, sizeof(float));
-	lilv_plugin_get_port_ranges_float(p, mins, maxes, controls);
-
-	for (uint32_t index = 0; index < n_ports; ++index) {
-		const LilvPort* port = lilv_plugin_get_port_by_index(p, index);
-		if (lilv_port_is_a(p, port, lv2_ControlPort)) {
- 			if (isnan(controls[index])) {
-				if (!isnan(mins[index])) {
-					controls[index] = mins[index];
-				} else if (!isnan(maxes[index])) {
-					controls[index] = maxes[index];
-				} else {
-					controls[index] = 0.0;
-				}
-			}
-			lilv_instance_connect_port(instance, index, &controls[index]);
-		} else if (lilv_port_is_a(p, port, lv2_AudioPort) ||
-		           lilv_port_is_a(p, port, lv2_CVPort)) {
-			if (lilv_port_is_a(p, port, lv2_InputPort)) {
-				lilv_instance_connect_port(instance, index, in);
-			} else if (lilv_port_is_a(p, port, lv2_OutputPort)) {
-				lilv_instance_connect_port(instance, index, out);
-			} else {
-				fprintf(stderr, "<%s> port %u neither input nor output, skipping\n",
-				        uri, index);
-				lilv_instance_free(instance);
-				free(seq_out);
-				free(buf);
-				free(controls);
-				uri_table_destroy(&uri_table);
-				return 0.0;
-			}
-		} else if (lilv_port_is_a(p, port, atom_AtomPort)) {
-			if (lilv_port_is_a(p, port, lv2_InputPort)) {
-				lilv_instance_connect_port(instance, index, &seq_in);
-			} else {
-				lilv_instance_connect_port(instance, index, seq_out);
-			}
-		} else {
-			fprintf(stderr, "<%s> port %u has unknown type, skipping\n",
-			        uri, index);
-			lilv_instance_free(instance);
-			free(seq_out);
-			free(buf);
-			free(controls);
-			uri_table_destroy(&uri_table);
-			return 0.0;
-		}
-	}
-
-	lilv_instance_activate(instance);
-
-	struct timespec ts = bench_start();
-	for (uint32_t i = 0; i < (sample_count / block_size); ++i) {
-		seq_in.atom.size   = sizeof(LV2_Atom_Sequence_Body);
-		seq_in.atom.type   = uri_table_map(&uri_table, LV2_ATOM__Sequence);
-		seq_out->atom.size = atom_capacity;
-		seq_out->atom.type = uri_table_map(&uri_table, LV2_ATOM__Chunk);
-
-		lilv_instance_run(instance, block_size);
-	}
-	const double elapsed = bench_end(&ts);
-
-	lilv_instance_deactivate(instance);
-	lilv_instance_free(instance);
-	free(controls);
-	free(maxes);
-	free(mins);
-	free(seq_out);
-
-	uri_table_destroy(&uri_table);
-
-	if (full_output) {
-		printf("%u %u ", block_size, sample_count);
-	}
-	printf("%lf %s\n", elapsed, uri);
-
-	free(buf);
-	return elapsed;
+  URITable uri_table;
+  uri_table_init(&uri_table);
+
+  LV2_URID_Map       map           = {&uri_table, uri_table_map};
+  LV2_Feature        map_feature   = {LV2_URID_MAP_URI, &map};
+  LV2_URID_Unmap     unmap         = {&uri_table, uri_table_unmap};
+  LV2_Feature        unmap_feature = {LV2_URID_UNMAP_URI, &unmap};
+  const LV2_Feature* features[]    = {&map_feature, &unmap_feature, NULL};
+
+  float* const buf = (float*)calloc(block_size * 2, sizeof(float));
+  float* const in  = buf;
+  float* const out = buf + block_size;
+  if (!buf) {
+    fprintf(stderr, "Out of memory\n");
+    return 0.0;
+  }
+
+  const size_t atom_capacity = 1024;
+
+  LV2_Atom_Sequence seq_in = {{sizeof(LV2_Atom_Sequence_Body),
+                               uri_table_map(&uri_table, LV2_ATOM__Sequence)},
+                              {0, 0}};
+
+  LV2_Atom_Sequence* seq_out =
+    (LV2_Atom_Sequence*)malloc(sizeof(LV2_Atom_Sequence) + atom_capacity);
+
+  const char* uri      = lilv_node_as_string(lilv_plugin_get_uri(p));
+  LilvNodes*  required = lilv_plugin_get_required_features(p);
+  LILV_FOREACH (nodes, i, required) {
+    const LilvNode* feature = lilv_nodes_get(required, i);
+    if (!lilv_node_equals(feature, urid_map)) {
+      fprintf(stderr,
+              "<%s> requires feature <%s>, skipping\n",
+              uri,
+              lilv_node_as_uri(feature));
+      free(seq_out);
+      free(buf);
+      uri_table_destroy(&uri_table);
+      return 0.0;
+    }
+  }
+
+  LilvInstance* instance = lilv_plugin_instantiate(p, 48000.0, features);
+  if (!instance) {
+    fprintf(stderr,
+            "Failed to instantiate <%s>\n",
+            lilv_node_as_uri(lilv_plugin_get_uri(p)));
+    free(seq_out);
+    free(buf);
+    uri_table_destroy(&uri_table);
+    return 0.0;
+  }
+
+  const uint32_t n_ports  = lilv_plugin_get_num_ports(p);
+  float* const   mins     = (float*)calloc(n_ports, sizeof(float));
+  float* const   maxes    = (float*)calloc(n_ports, sizeof(float));
+  float* const   controls = (float*)calloc(n_ports, sizeof(float));
+  lilv_plugin_get_port_ranges_float(p, mins, maxes, controls);
+
+  for (uint32_t index = 0; index < n_ports; ++index) {
+    const LilvPort* port = lilv_plugin_get_port_by_index(p, index);
+    if (lilv_port_is_a(p, port, lv2_ControlPort)) {
+      if (isnan(controls[index])) {
+        if (!isnan(mins[index])) {
+          controls[index] = mins[index];
+        } else if (!isnan(maxes[index])) {
+          controls[index] = maxes[index];
+        } else {
+          controls[index] = 0.0;
+        }
+      }
+      lilv_instance_connect_port(instance, index, &controls[index]);
+    } else if (lilv_port_is_a(p, port, lv2_AudioPort) ||
+               lilv_port_is_a(p, port, lv2_CVPort)) {
+      if (lilv_port_is_a(p, port, lv2_InputPort)) {
+        lilv_instance_connect_port(instance, index, in);
+      } else if (lilv_port_is_a(p, port, lv2_OutputPort)) {
+        lilv_instance_connect_port(instance, index, out);
+      } else {
+        fprintf(stderr,
+                "<%s> port %u neither input nor output, skipping\n",
+                uri,
+                index);
+        lilv_instance_free(instance);
+        free(seq_out);
+        free(buf);
+        free(controls);
+        uri_table_destroy(&uri_table);
+        return 0.0;
+      }
+    } else if (lilv_port_is_a(p, port, atom_AtomPort)) {
+      if (lilv_port_is_a(p, port, lv2_InputPort)) {
+        lilv_instance_connect_port(instance, index, &seq_in);
+      } else {
+        lilv_instance_connect_port(instance, index, seq_out);
+      }
+    } else {
+      fprintf(stderr, "<%s> port %u has unknown type, skipping\n", uri, index);
+      lilv_instance_free(instance);
+      free(seq_out);
+      free(buf);
+      free(controls);
+      uri_table_destroy(&uri_table);
+      return 0.0;
+    }
+  }
+
+  lilv_instance_activate(instance);
+
+  struct timespec ts = bench_start();
+  for (uint32_t i = 0; i < (sample_count / block_size); ++i) {
+    seq_in.atom.size   = sizeof(LV2_Atom_Sequence_Body);
+    seq_in.atom.type   = uri_table_map(&uri_table, LV2_ATOM__Sequence);
+    seq_out->atom.size = atom_capacity;
+    seq_out->atom.type = uri_table_map(&uri_table, LV2_ATOM__Chunk);
+
+    lilv_instance_run(instance, block_size);
+  }
+  const double elapsed = bench_end(&ts);
+
+  lilv_instance_deactivate(instance);
+  lilv_instance_free(instance);
+  free(controls);
+  free(maxes);
+  free(mins);
+  free(seq_out);
+
+  uri_table_destroy(&uri_table);
+
+  if (full_output) {
+    printf("%u %u ", block_size, sample_count);
+  }
+  printf("%lf %s\n", elapsed, uri);
+
+  free(buf);
+  return elapsed;
 }
 
 int
 main(int argc, char** argv)
 {
-	uint32_t block_size   = 512;
-	uint32_t sample_count = (1 << 19);
-
-	int a = 1;
-	for (; a < argc; ++a) {
-		if (!strcmp(argv[a], "--version")) {
-			print_version();
-			return 0;
-		}
-
-		if (!strcmp(argv[a], "--help")) {
-			print_usage();
-			return 0;
-		}
-
-		if (!strcmp(argv[a], "-f")) {
-			full_output = true;
-		} else if (!strcmp(argv[a], "-n") && (a + 1 < argc)) {
-			sample_count = atoi(argv[++a]);
-		} else if (!strcmp(argv[a], "-b") && (a + 1 < argc)) {
-			block_size = atoi(argv[++a]);
-		} else if (argv[a][0] != '-') {
-			break;
-		} else {
-			print_usage();
-			return 1;
-		}
-	}
-
-	const char* const plugin_uri_str = (a < argc ? argv[a++] : NULL);
-
-	LilvWorld* world = lilv_world_new();
-	lilv_world_load_all(world);
-
-	atom_AtomPort   = lilv_new_uri(world, LV2_ATOM__AtomPort);
-	atom_Sequence   = lilv_new_uri(world, LV2_ATOM__Sequence);
-	lv2_AudioPort   = lilv_new_uri(world, LV2_CORE__AudioPort);
-	lv2_CVPort      = lilv_new_uri(world, LV2_CORE__CVPort);
-	lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort);
-	lv2_InputPort   = lilv_new_uri(world, LV2_CORE__InputPort);
-	lv2_OutputPort  = lilv_new_uri(world, LV2_CORE__OutputPort);
-	urid_map        = lilv_new_uri(world, LV2_URID__map);
-
-	if (full_output) {
-		printf("# Block Samples Time Plugin\n");
-	}
-
-	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
-	if (plugin_uri_str) {
-		LilvNode* uri = lilv_new_uri(world, plugin_uri_str);
-		bench(lilv_plugins_get_by_uri(plugins, uri), sample_count, block_size);
-		lilv_node_free(uri);
-	} else {
-		LILV_FOREACH(plugins, i, plugins) {
-			bench(lilv_plugins_get(plugins, i), sample_count, block_size);
-		}
-	}
-
-	lilv_node_free(urid_map);
-	lilv_node_free(lv2_OutputPort);
-	lilv_node_free(lv2_InputPort);
-	lilv_node_free(lv2_ControlPort);
-	lilv_node_free(lv2_CVPort);
-	lilv_node_free(lv2_AudioPort);
-	lilv_node_free(atom_Sequence);
-	lilv_node_free(atom_AtomPort);
-
-	lilv_world_free(world);
-
-	return 0;
+  uint32_t block_size   = 512;
+  uint32_t sample_count = (1 << 19);
+
+  int a = 1;
+  for (; a < argc; ++a) {
+    if (!strcmp(argv[a], "--version")) {
+      print_version();
+      return 0;
+    }
+
+    if (!strcmp(argv[a], "--help")) {
+      print_usage();
+      return 0;
+    }
+
+    if (!strcmp(argv[a], "-f")) {
+      full_output = true;
+    } else if (!strcmp(argv[a], "-n") && (a + 1 < argc)) {
+      sample_count = atoi(argv[++a]);
+    } else if (!strcmp(argv[a], "-b") && (a + 1 < argc)) {
+      block_size = atoi(argv[++a]);
+    } else if (argv[a][0] != '-') {
+      break;
+    } else {
+      print_usage();
+      return 1;
+    }
+  }
+
+  const char* const plugin_uri_str = (a < argc ? argv[a++] : NULL);
+
+  LilvWorld* world = lilv_world_new();
+  lilv_world_load_all(world);
+
+  atom_AtomPort   = lilv_new_uri(world, LV2_ATOM__AtomPort);
+  atom_Sequence   = lilv_new_uri(world, LV2_ATOM__Sequence);
+  lv2_AudioPort   = lilv_new_uri(world, LV2_CORE__AudioPort);
+  lv2_CVPort      = lilv_new_uri(world, LV2_CORE__CVPort);
+  lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort);
+  lv2_InputPort   = lilv_new_uri(world, LV2_CORE__InputPort);
+  lv2_OutputPort  = lilv_new_uri(world, LV2_CORE__OutputPort);
+  urid_map        = lilv_new_uri(world, LV2_URID__map);
+
+  if (full_output) {
+    printf("# Block Samples Time Plugin\n");
+  }
+
+  const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+  if (plugin_uri_str) {
+    LilvNode* uri = lilv_new_uri(world, plugin_uri_str);
+    bench(lilv_plugins_get_by_uri(plugins, uri), sample_count, block_size);
+    lilv_node_free(uri);
+  } else {
+    LILV_FOREACH (plugins, i, plugins) {
+      bench(lilv_plugins_get(plugins, i), sample_count, block_size);
+    }
+  }
+
+  lilv_node_free(urid_map);
+  lilv_node_free(lv2_OutputPort);
+  lilv_node_free(lv2_InputPort);
+  lilv_node_free(lv2_ControlPort);
+  lilv_node_free(lv2_CVPort);
+  lilv_node_free(lv2_AudioPort);
+  lilv_node_free(atom_Sequence);
+  lilv_node_free(atom_AtomPort);
+
+  lilv_world_free(world);
+
+  return 0;
 }
diff --git a/utils/lv2info.c b/utils/lv2info.c
index f5dd621..0c79268 100644
--- a/utils/lv2info.c
+++ b/utils/lv2info.c
@@ -45,417 +45,412 @@ print_port(const LilvPlugin* p,
            float*            maxes,
            float*            defaults)
 {
-	const LilvPort* port = lilv_plugin_get_port_by_index(p, index);
-
-	printf("\n\tPort %u:\n", index);
-
-	if (!port) {
-		printf("\t\tERROR: Illegal/nonexistent port\n");
-		return;
-	}
-
-	bool first = true;
-
-	const LilvNodes* classes = lilv_port_get_classes(p, port);
-	printf("\t\tType:        ");
-	LILV_FOREACH(nodes, i, classes) {
-		const LilvNode* value = lilv_nodes_get(classes, i);
-		if (!first) {
-			printf("\n\t\t             ");
-		}
-		printf("%s", lilv_node_as_uri(value));
-		first = false;
-	}
-
-	if (lilv_port_is_a(p, port, event_class)) {
-		LilvNodes* supported = lilv_port_get_value(
-			p, port, supports_event_pred);
-		if (lilv_nodes_size(supported) > 0) {
-			printf("\n\t\tSupported events:\n");
-			LILV_FOREACH(nodes, i, supported) {
-				const LilvNode* value = lilv_nodes_get(supported, i);
-				printf("\t\t\t%s\n", lilv_node_as_uri(value));
-			}
-		}
-		lilv_nodes_free(supported);
-	}
-
-	LilvScalePoints* points = lilv_port_get_scale_points(p, port);
-	if (points) {
-		printf("\n\t\tScale Points:\n");
-	}
-	LILV_FOREACH(scale_points, i, points) {
-		const LilvScalePoint* point = lilv_scale_points_get(points, i);
-		printf("\t\t\t%s = \"%s\"\n",
-				lilv_node_as_string(lilv_scale_point_get_value(point)),
-				lilv_node_as_string(lilv_scale_point_get_label(point)));
-	}
-	lilv_scale_points_free(points);
-
-	const LilvNode* sym = lilv_port_get_symbol(p, port);
-	printf("\n\t\tSymbol:      %s\n", lilv_node_as_string(sym));
-
-	LilvNode* name = lilv_port_get_name(p, port);
-	printf("\t\tName:        %s\n", lilv_node_as_string(name));
-	lilv_node_free(name);
-
-	LilvNodes* groups = lilv_port_get_value(p, port, group_pred);
-	if (lilv_nodes_size(groups) > 0) {
-		printf("\t\tGroup:       %s\n",
-		       lilv_node_as_string(lilv_nodes_get_first(groups)));
-	}
-	lilv_nodes_free(groups);
-
-	LilvNodes* designations = lilv_port_get_value(p, port, designation_pred);
-	if (lilv_nodes_size(designations) > 0) {
-		printf("\t\tDesignation: %s\n",
-		       lilv_node_as_string(lilv_nodes_get_first(designations)));
-	}
-	lilv_nodes_free(designations);
-
-	if (lilv_port_is_a(p, port, control_class)) {
-		if (!isnan(mins[index])) {
-			printf("\t\tMinimum:     %f\n", mins[index]);
-		}
-		if (!isnan(maxes[index])) {
-			printf("\t\tMaximum:     %f\n", maxes[index]);
-		}
-		if (!isnan(defaults[index])) {
-			printf("\t\tDefault:     %f\n", defaults[index]);
-		}
-	}
-
-	LilvNodes* properties = lilv_port_get_properties(p, port);
-	if (lilv_nodes_size(properties) > 0) {
-		printf("\t\tProperties:  ");
-	}
-	first = true;
-	LILV_FOREACH(nodes, i, properties) {
-		if (!first) {
-			printf("\t\t             ");
-		}
-		printf("%s\n", lilv_node_as_uri(lilv_nodes_get(properties, i)));
-		first = false;
-	}
-	if (lilv_nodes_size(properties) > 0) {
-		printf("\n");
-	}
-	lilv_nodes_free(properties);
+  const LilvPort* port = lilv_plugin_get_port_by_index(p, index);
+
+  printf("\n\tPort %u:\n", index);
+
+  if (!port) {
+    printf("\t\tERROR: Illegal/nonexistent port\n");
+    return;
+  }
+
+  bool first = true;
+
+  const LilvNodes* classes = lilv_port_get_classes(p, port);
+  printf("\t\tType:        ");
+  LILV_FOREACH (nodes, i, classes) {
+    const LilvNode* value = lilv_nodes_get(classes, i);
+    if (!first) {
+      printf("\n\t\t             ");
+    }
+    printf("%s", lilv_node_as_uri(value));
+    first = false;
+  }
+
+  if (lilv_port_is_a(p, port, event_class)) {
+    LilvNodes* supported = lilv_port_get_value(p, port, supports_event_pred);
+    if (lilv_nodes_size(supported) > 0) {
+      printf("\n\t\tSupported events:\n");
+      LILV_FOREACH (nodes, i, supported) {
+        const LilvNode* value = lilv_nodes_get(supported, i);
+        printf("\t\t\t%s\n", lilv_node_as_uri(value));
+      }
+    }
+    lilv_nodes_free(supported);
+  }
+
+  LilvScalePoints* points = lilv_port_get_scale_points(p, port);
+  if (points) {
+    printf("\n\t\tScale Points:\n");
+  }
+  LILV_FOREACH (scale_points, i, points) {
+    const LilvScalePoint* point = lilv_scale_points_get(points, i);
+    printf("\t\t\t%s = \"%s\"\n",
+           lilv_node_as_string(lilv_scale_point_get_value(point)),
+           lilv_node_as_string(lilv_scale_point_get_label(point)));
+  }
+  lilv_scale_points_free(points);
+
+  const LilvNode* sym = lilv_port_get_symbol(p, port);
+  printf("\n\t\tSymbol:      %s\n", lilv_node_as_string(sym));
+
+  LilvNode* name = lilv_port_get_name(p, port);
+  printf("\t\tName:        %s\n", lilv_node_as_string(name));
+  lilv_node_free(name);
+
+  LilvNodes* groups = lilv_port_get_value(p, port, group_pred);
+  if (lilv_nodes_size(groups) > 0) {
+    printf("\t\tGroup:       %s\n",
+           lilv_node_as_string(lilv_nodes_get_first(groups)));
+  }
+  lilv_nodes_free(groups);
+
+  LilvNodes* designations = lilv_port_get_value(p, port, designation_pred);
+  if (lilv_nodes_size(designations) > 0) {
+    printf("\t\tDesignation: %s\n",
+           lilv_node_as_string(lilv_nodes_get_first(designations)));
+  }
+  lilv_nodes_free(designations);
+
+  if (lilv_port_is_a(p, port, control_class)) {
+    if (!isnan(mins[index])) {
+      printf("\t\tMinimum:     %f\n", mins[index]);
+    }
+    if (!isnan(maxes[index])) {
+      printf("\t\tMaximum:     %f\n", maxes[index]);
+    }
+    if (!isnan(defaults[index])) {
+      printf("\t\tDefault:     %f\n", defaults[index]);
+    }
+  }
+
+  LilvNodes* properties = lilv_port_get_properties(p, port);
+  if (lilv_nodes_size(properties) > 0) {
+    printf("\t\tProperties:  ");
+  }
+  first = true;
+  LILV_FOREACH (nodes, i, properties) {
+    if (!first) {
+      printf("\t\t             ");
+    }
+    printf("%s\n", lilv_node_as_uri(lilv_nodes_get(properties, i)));
+    first = false;
+  }
+  if (lilv_nodes_size(properties) > 0) {
+    printf("\n");
+  }
+  lilv_nodes_free(properties);
 }
 
 static void
-print_plugin(LilvWorld*        world,
-             const LilvPlugin* p)
+print_plugin(LilvWorld* world, const LilvPlugin* p)
 {
-	LilvNode* val = NULL;
-
-	printf("%s\n\n", lilv_node_as_uri(lilv_plugin_get_uri(p)));
-
-	val = lilv_plugin_get_name(p);
-	if (val) {
-		printf("\tName:              %s\n", lilv_node_as_string(val));
-		lilv_node_free(val);
-	}
-
-	const LilvPluginClass* pclass      = lilv_plugin_get_class(p);
-	const LilvNode*       class_label = lilv_plugin_class_get_label(pclass);
-	if (class_label) {
-		printf("\tClass:             %s\n", lilv_node_as_string(class_label));
-	}
-
-	val = lilv_plugin_get_author_name(p);
-	if (val) {
-		printf("\tAuthor:            %s\n", lilv_node_as_string(val));
-		lilv_node_free(val);
-	}
-
-	val = lilv_plugin_get_author_email(p);
-	if (val) {
-		printf("\tAuthor Email:      %s\n", lilv_node_as_uri(val));
-		lilv_node_free(val);
-	}
-
-	val = lilv_plugin_get_author_homepage(p);
-	if (val) {
-		printf("\tAuthor Homepage:   %s\n", lilv_node_as_uri(val));
-		lilv_node_free(val);
-	}
-
-	if (lilv_plugin_has_latency(p)) {
-		uint32_t latency_port = lilv_plugin_get_latency_port_index(p);
-		printf("\tHas latency:       yes, reported by port %u\n", latency_port);
-	} else {
-		printf("\tHas latency:       no\n");
-	}
-
-	printf("\tBundle:            %s\n",
-	       lilv_node_as_uri(lilv_plugin_get_bundle_uri(p)));
-
-	const LilvNode* binary_uri = lilv_plugin_get_library_uri(p);
-	if (binary_uri) {
-		printf("\tBinary:            %s\n",
-		       lilv_node_as_uri(lilv_plugin_get_library_uri(p)));
-	}
-
-	LilvUIs* uis = lilv_plugin_get_uis(p);
-	if (lilv_nodes_size(uis) > 0) {
-		printf("\tUIs:\n");
-		LILV_FOREACH(uis, i, uis) {
-			const LilvUI* ui = lilv_uis_get(uis, i);
-			printf("\t\t%s\n", lilv_node_as_uri(lilv_ui_get_uri(ui)));
-
-			const char* binary = lilv_node_as_uri(lilv_ui_get_binary_uri(ui));
-
-			const LilvNodes* types = lilv_ui_get_classes(ui);
-			LILV_FOREACH(nodes, t, types) {
-				printf("\t\t\tClass:  %s\n",
-				       lilv_node_as_uri(lilv_nodes_get(types, t)));
-			}
-
-			if (binary) {
-				printf("\t\t\tBinary: %s\n", binary);
-			}
-
-			printf("\t\t\tBundle: %s\n",
-			       lilv_node_as_uri(lilv_ui_get_bundle_uri(ui)));
-		}
-	}
-	lilv_uis_free(uis);
-
-	printf("\tData URIs:         ");
-	const LilvNodes* data_uris = lilv_plugin_get_data_uris(p);
-	bool first = true;
-	LILV_FOREACH(nodes, i, data_uris) {
-		if (!first) {
-			printf("\n\t                   ");
-		}
-		printf("%s", lilv_node_as_uri(lilv_nodes_get(data_uris, i)));
-		first = false;
-	}
-	printf("\n");
-
-	/* Required Features */
-
-	LilvNodes* features = lilv_plugin_get_required_features(p);
-	if (features) {
-		printf("\tRequired Features: ");
-	}
-	first = true;
-	LILV_FOREACH(nodes, i, features) {
-		if (!first) {
-			printf("\n\t                   ");
-		}
-		printf("%s", lilv_node_as_uri(lilv_nodes_get(features, i)));
-		first = false;
-	}
-	if (features) {
-		printf("\n");
-	}
-	lilv_nodes_free(features);
-
-	/* Optional Features */
-
-	features = lilv_plugin_get_optional_features(p);
-	if (features) {
-		printf("\tOptional Features: ");
-	}
-	first = true;
-	LILV_FOREACH(nodes, i, features) {
-		if (!first) {
-			printf("\n\t                   ");
-		}
-		printf("%s", lilv_node_as_uri(lilv_nodes_get(features, i)));
-		first = false;
-	}
-	if (features) {
-		printf("\n");
-	}
-	lilv_nodes_free(features);
-
-	/* Extension Data */
-
-	LilvNodes* data = lilv_plugin_get_extension_data(p);
-	if (data) {
-		printf("\tExtension Data:    ");
-	}
-	first = true;
-	LILV_FOREACH(nodes, i, data) {
-		if (!first) {
-			printf("\n\t                   ");
-		}
-		printf("%s", lilv_node_as_uri(lilv_nodes_get(data, i)));
-		first = false;
-	}
-	if (data) {
-		printf("\n");
-	}
-	lilv_nodes_free(data);
-
-	/* Presets */
-
-	LilvNodes* presets = lilv_plugin_get_related(p, preset_class);
-	if (presets) {
-		printf("\tPresets: \n");
-	}
-	LILV_FOREACH(nodes, i, presets) {
-		const LilvNode* preset = lilv_nodes_get(presets, i);
-		lilv_world_load_resource(world, preset);
-		LilvNodes* titles = lilv_world_find_nodes(
-			world, preset, label_pred, NULL);
-		if (titles) {
-			const LilvNode* title = lilv_nodes_get_first(titles);
-			printf("\t         %s\n", lilv_node_as_string(title));
-			lilv_nodes_free(titles);
-		} else {
-			fprintf(stderr, "Preset <%s> has no rdfs:label\n",
-			        lilv_node_as_string(lilv_nodes_get(presets, i)));
-		}
-	}
-	lilv_nodes_free(presets);
-
-	/* Ports */
-
-	const uint32_t num_ports = lilv_plugin_get_num_ports(p);
-	float* mins     = (float*)calloc(num_ports, sizeof(float));
-	float* maxes    = (float*)calloc(num_ports, sizeof(float));
-	float* defaults = (float*)calloc(num_ports, sizeof(float));
-	lilv_plugin_get_port_ranges_float(p, mins, maxes, defaults);
-
-	for (uint32_t i = 0; i < num_ports; ++i) {
-		print_port(p, i, mins, maxes, defaults);
-	}
-
-	free(mins);
-	free(maxes);
-	free(defaults);
+  LilvNode* val = NULL;
+
+  printf("%s\n\n", lilv_node_as_uri(lilv_plugin_get_uri(p)));
+
+  val = lilv_plugin_get_name(p);
+  if (val) {
+    printf("\tName:              %s\n", lilv_node_as_string(val));
+    lilv_node_free(val);
+  }
+
+  const LilvPluginClass* pclass      = lilv_plugin_get_class(p);
+  const LilvNode*        class_label = lilv_plugin_class_get_label(pclass);
+  if (class_label) {
+    printf("\tClass:             %s\n", lilv_node_as_string(class_label));
+  }
+
+  val = lilv_plugin_get_author_name(p);
+  if (val) {
+    printf("\tAuthor:            %s\n", lilv_node_as_string(val));
+    lilv_node_free(val);
+  }
+
+  val = lilv_plugin_get_author_email(p);
+  if (val) {
+    printf("\tAuthor Email:      %s\n", lilv_node_as_uri(val));
+    lilv_node_free(val);
+  }
+
+  val = lilv_plugin_get_author_homepage(p);
+  if (val) {
+    printf("\tAuthor Homepage:   %s\n", lilv_node_as_uri(val));
+    lilv_node_free(val);
+  }
+
+  if (lilv_plugin_has_latency(p)) {
+    uint32_t latency_port = lilv_plugin_get_latency_port_index(p);
+    printf("\tHas latency:       yes, reported by port %u\n", latency_port);
+  } else {
+    printf("\tHas latency:       no\n");
+  }
+
+  printf("\tBundle:            %s\n",
+         lilv_node_as_uri(lilv_plugin_get_bundle_uri(p)));
+
+  const LilvNode* binary_uri = lilv_plugin_get_library_uri(p);
+  if (binary_uri) {
+    printf("\tBinary:            %s\n",
+           lilv_node_as_uri(lilv_plugin_get_library_uri(p)));
+  }
+
+  LilvUIs* uis = lilv_plugin_get_uis(p);
+  if (lilv_nodes_size(uis) > 0) {
+    printf("\tUIs:\n");
+    LILV_FOREACH (uis, i, uis) {
+      const LilvUI* ui = lilv_uis_get(uis, i);
+      printf("\t\t%s\n", lilv_node_as_uri(lilv_ui_get_uri(ui)));
+
+      const char* binary = lilv_node_as_uri(lilv_ui_get_binary_uri(ui));
+
+      const LilvNodes* types = lilv_ui_get_classes(ui);
+      LILV_FOREACH (nodes, t, types) {
+        printf("\t\t\tClass:  %s\n",
+               lilv_node_as_uri(lilv_nodes_get(types, t)));
+      }
+
+      if (binary) {
+        printf("\t\t\tBinary: %s\n", binary);
+      }
+
+      printf("\t\t\tBundle: %s\n",
+             lilv_node_as_uri(lilv_ui_get_bundle_uri(ui)));
+    }
+  }
+  lilv_uis_free(uis);
+
+  printf("\tData URIs:         ");
+  const LilvNodes* data_uris = lilv_plugin_get_data_uris(p);
+  bool             first     = true;
+  LILV_FOREACH (nodes, i, data_uris) {
+    if (!first) {
+      printf("\n\t                   ");
+    }
+    printf("%s", lilv_node_as_uri(lilv_nodes_get(data_uris, i)));
+    first = false;
+  }
+  printf("\n");
+
+  /* Required Features */
+
+  LilvNodes* features = lilv_plugin_get_required_features(p);
+  if (features) {
+    printf("\tRequired Features: ");
+  }
+  first = true;
+  LILV_FOREACH (nodes, i, features) {
+    if (!first) {
+      printf("\n\t                   ");
+    }
+    printf("%s", lilv_node_as_uri(lilv_nodes_get(features, i)));
+    first = false;
+  }
+  if (features) {
+    printf("\n");
+  }
+  lilv_nodes_free(features);
+
+  /* Optional Features */
+
+  features = lilv_plugin_get_optional_features(p);
+  if (features) {
+    printf("\tOptional Features: ");
+  }
+  first = true;
+  LILV_FOREACH (nodes, i, features) {
+    if (!first) {
+      printf("\n\t                   ");
+    }
+    printf("%s", lilv_node_as_uri(lilv_nodes_get(features, i)));
+    first = false;
+  }
+  if (features) {
+    printf("\n");
+  }
+  lilv_nodes_free(features);
+
+  /* Extension Data */
+
+  LilvNodes* data = lilv_plugin_get_extension_data(p);
+  if (data) {
+    printf("\tExtension Data:    ");
+  }
+  first = true;
+  LILV_FOREACH (nodes, i, data) {
+    if (!first) {
+      printf("\n\t                   ");
+    }
+    printf("%s", lilv_node_as_uri(lilv_nodes_get(data, i)));
+    first = false;
+  }
+  if (data) {
+    printf("\n");
+  }
+  lilv_nodes_free(data);
+
+  /* Presets */
+
+  LilvNodes* presets = lilv_plugin_get_related(p, preset_class);
+  if (presets) {
+    printf("\tPresets: \n");
+  }
+  LILV_FOREACH (nodes, i, presets) {
+    const LilvNode* preset = lilv_nodes_get(presets, i);
+    lilv_world_load_resource(world, preset);
+    LilvNodes* titles = lilv_world_find_nodes(world, preset, label_pred, NULL);
+    if (titles) {
+      const LilvNode* title = lilv_nodes_get_first(titles);
+      printf("\t         %s\n", lilv_node_as_string(title));
+      lilv_nodes_free(titles);
+    } else {
+      fprintf(stderr,
+              "Preset <%s> has no rdfs:label\n",
+              lilv_node_as_string(lilv_nodes_get(presets, i)));
+    }
+  }
+  lilv_nodes_free(presets);
+
+  /* Ports */
+
+  const uint32_t num_ports = lilv_plugin_get_num_ports(p);
+  float*         mins      = (float*)calloc(num_ports, sizeof(float));
+  float*         maxes     = (float*)calloc(num_ports, sizeof(float));
+  float*         defaults  = (float*)calloc(num_ports, sizeof(float));
+  lilv_plugin_get_port_ranges_float(p, mins, maxes, defaults);
+
+  for (uint32_t i = 0; i < num_ports; ++i) {
+    print_port(p, i, mins, maxes, defaults);
+  }
+
+  free(mins);
+  free(maxes);
+  free(defaults);
 }
 
 static void
 print_version(void)
 {
-	printf(
-		"lv2info (lilv) " LILV_VERSION "\n"
-		"Copyright 2007-2019 David Robillard <http://drobilla.net>\n"
-		"License: <http://www.opensource.org/licenses/isc-license>\n"
-		"This is free software: you are free to change and redistribute it.\n"
-		"There is NO WARRANTY, to the extent permitted by law.\n");
+  printf("lv2info (lilv) " LILV_VERSION "\n"
+         "Copyright 2007-2019 David Robillard <http://drobilla.net>\n"
+         "License: <http://www.opensource.org/licenses/isc-license>\n"
+         "This is free software: you are free to change and redistribute it.\n"
+         "There is NO WARRANTY, to the extent permitted by law.\n");
 }
 
 static void
 print_usage(void)
 {
-	printf(
-		"Usage: lv2info [OPTION]... PLUGIN_URI\n"
-		"Print information about an installed LV2 plugin.\n\n"
-		"  -p FILE      Write Turtle description of plugin to FILE\n"
-		"  -m FILE      Add record of plugin to manifest FILE\n"
-		"  --help       Display this help and exit\n"
-		"  --version    Display version information and exit\n\n"
-		"For -p and -m, Turtle files are appended to (not overwritten),\n"
-		"and @prefix directives are only written if the file was empty.\n"
-		"This allows several plugins to be added to a single file.\n");
+  printf("Usage: lv2info [OPTION]... PLUGIN_URI\n"
+         "Print information about an installed LV2 plugin.\n\n"
+         "  -p FILE      Write Turtle description of plugin to FILE\n"
+         "  -m FILE      Add record of plugin to manifest FILE\n"
+         "  --help       Display this help and exit\n"
+         "  --version    Display version information and exit\n\n"
+         "For -p and -m, Turtle files are appended to (not overwritten),\n"
+         "and @prefix directives are only written if the file was empty.\n"
+         "This allows several plugins to be added to a single file.\n");
 }
 
 int
 main(int argc, char** argv)
 {
-	if (argc == 1) {
-		print_usage();
-		return 1;
-	}
-
-	const char* plugin_file   = NULL;
-	const char* manifest_file = NULL;
-	const char* plugin_uri    = NULL;
-	for (int i = 1; i < argc; ++i) {
-		if (!strcmp(argv[i], "--version")) {
-			print_version();
-			return 0;
-		}
-
-		if (!strcmp(argv[i], "--help")) {
-			print_usage();
-			return 0;
-		}
-
-		if (!strcmp(argv[i], "-p")) {
-			plugin_file = argv[++i];
-		} else if (!strcmp(argv[i], "-m")) {
-			manifest_file = argv[++i];
-		} else if (argv[i][0] == '-') {
-			print_usage();
-			return 1;
-		} else if (i == argc - 1) {
-			plugin_uri = argv[i];
-		}
-	}
-
-	int ret = 0;
-
-	LilvWorld* world = lilv_world_new();
-	lilv_world_load_all(world);
-
-	LilvNode* uri = lilv_new_uri(world, plugin_uri);
-	if (!uri) {
-		fprintf(stderr, "Invalid plugin URI\n");
-		lilv_world_free(world);
-		return 1;
-	}
-
-	applies_to_pred     = lilv_new_uri(world, LV2_CORE__appliesTo);
-	control_class       = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
-	event_class         = lilv_new_uri(world, LILV_URI_EVENT_PORT);
-	group_pred          = lilv_new_uri(world, LV2_PORT_GROUPS__group);
-	label_pred          = lilv_new_uri(world, LILV_NS_RDFS "label");
-	preset_class        = lilv_new_uri(world, LV2_PRESETS__Preset);
-	designation_pred    = lilv_new_uri(world, LV2_CORE__designation);
-	supports_event_pred = lilv_new_uri(world, LV2_EVENT__supportsEvent);
-
-	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
-	const LilvPlugin*  p       = lilv_plugins_get_by_uri(plugins, uri);
-
-	if (p && plugin_file) {
-		LilvNode* base = lilv_new_file_uri(world, NULL, plugin_file);
-
-		FILE* plugin_fd = fopen(plugin_file, "a");
-		if (plugin_fd) {
-			lilv_plugin_write_description(world, p, base, plugin_fd);
-			fclose(plugin_fd);
-		} else {
-			fprintf(stderr, "error: Failed to open %s\n", plugin_file);
-		}
-
-		if (manifest_file) {
-			FILE* manifest_fd = fopen(manifest_file, "a");
-			if (manifest_fd) {
-				lilv_plugin_write_manifest_entry(
-					world, p, base, manifest_fd, plugin_file);
-				fclose(manifest_fd);
-			} else {
-				fprintf(stderr, "error: Failed to open %s\n", manifest_file);
-			}
-		}
-		lilv_node_free(base);
-	} else if (p) {
-		print_plugin(world, p);
-	} else {
-		fprintf(stderr, "Plugin not found.\n");
-	}
-
-	ret = (p != NULL ? 0 : -1);
-
-	lilv_node_free(uri);
-
-	lilv_node_free(supports_event_pred);
-	lilv_node_free(designation_pred);
-	lilv_node_free(preset_class);
-	lilv_node_free(label_pred);
-	lilv_node_free(group_pred);
-	lilv_node_free(event_class);
-	lilv_node_free(control_class);
-	lilv_node_free(applies_to_pred);
-
-	lilv_world_free(world);
-	return ret;
+  if (argc == 1) {
+    print_usage();
+    return 1;
+  }
+
+  const char* plugin_file   = NULL;
+  const char* manifest_file = NULL;
+  const char* plugin_uri    = NULL;
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp(argv[i], "--version")) {
+      print_version();
+      return 0;
+    }
+
+    if (!strcmp(argv[i], "--help")) {
+      print_usage();
+      return 0;
+    }
+
+    if (!strcmp(argv[i], "-p")) {
+      plugin_file = argv[++i];
+    } else if (!strcmp(argv[i], "-m")) {
+      manifest_file = argv[++i];
+    } else if (argv[i][0] == '-') {
+      print_usage();
+      return 1;
+    } else if (i == argc - 1) {
+      plugin_uri = argv[i];
+    }
+  }
+
+  int ret = 0;
+
+  LilvWorld* world = lilv_world_new();
+  lilv_world_load_all(world);
+
+  LilvNode* uri = lilv_new_uri(world, plugin_uri);
+  if (!uri) {
+    fprintf(stderr, "Invalid plugin URI\n");
+    lilv_world_free(world);
+    return 1;
+  }
+
+  applies_to_pred     = lilv_new_uri(world, LV2_CORE__appliesTo);
+  control_class       = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
+  event_class         = lilv_new_uri(world, LILV_URI_EVENT_PORT);
+  group_pred          = lilv_new_uri(world, LV2_PORT_GROUPS__group);
+  label_pred          = lilv_new_uri(world, LILV_NS_RDFS "label");
+  preset_class        = lilv_new_uri(world, LV2_PRESETS__Preset);
+  designation_pred    = lilv_new_uri(world, LV2_CORE__designation);
+  supports_event_pred = lilv_new_uri(world, LV2_EVENT__supportsEvent);
+
+  const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+  const LilvPlugin*  p       = lilv_plugins_get_by_uri(plugins, uri);
+
+  if (p && plugin_file) {
+    LilvNode* base = lilv_new_file_uri(world, NULL, plugin_file);
+
+    FILE* plugin_fd = fopen(plugin_file, "a");
+    if (plugin_fd) {
+      lilv_plugin_write_description(world, p, base, plugin_fd);
+      fclose(plugin_fd);
+    } else {
+      fprintf(stderr, "error: Failed to open %s\n", plugin_file);
+    }
+
+    if (manifest_file) {
+      FILE* manifest_fd = fopen(manifest_file, "a");
+      if (manifest_fd) {
+        lilv_plugin_write_manifest_entry(
+          world, p, base, manifest_fd, plugin_file);
+        fclose(manifest_fd);
+      } else {
+        fprintf(stderr, "error: Failed to open %s\n", manifest_file);
+      }
+    }
+    lilv_node_free(base);
+  } else if (p) {
+    print_plugin(world, p);
+  } else {
+    fprintf(stderr, "Plugin not found.\n");
+  }
+
+  ret = (p != NULL ? 0 : -1);
+
+  lilv_node_free(uri);
+
+  lilv_node_free(supports_event_pred);
+  lilv_node_free(designation_pred);
+  lilv_node_free(preset_class);
+  lilv_node_free(label_pred);
+  lilv_node_free(group_pred);
+  lilv_node_free(event_class);
+  lilv_node_free(control_class);
+  lilv_node_free(applies_to_pred);
+
+  lilv_world_free(world);
+  return ret;
 }
-
diff --git a/utils/lv2ls.c b/utils/lv2ls.c
index 90ae1eb..e5df2b3 100644
--- a/utils/lv2ls.c
+++ b/utils/lv2ls.c
@@ -25,70 +25,70 @@
 static void
 list_plugins(const LilvPlugins* list, bool show_names)
 {
-	LILV_FOREACH(plugins, i, list) {
-		const LilvPlugin* p = lilv_plugins_get(list, i);
-		if (show_names) {
-			LilvNode* n = lilv_plugin_get_name(p);
-			printf("%s\n", lilv_node_as_string(n));
-			lilv_node_free(n);
-		} else {
-			printf("%s\n", lilv_node_as_uri(lilv_plugin_get_uri(p)));
-		}
-	}
+  LILV_FOREACH (plugins, i, list) {
+    const LilvPlugin* p = lilv_plugins_get(list, i);
+    if (show_names) {
+      LilvNode* n = lilv_plugin_get_name(p);
+      printf("%s\n", lilv_node_as_string(n));
+      lilv_node_free(n);
+    } else {
+      printf("%s\n", lilv_node_as_uri(lilv_plugin_get_uri(p)));
+    }
+  }
 }
 
 static void
 print_version(void)
 {
-	printf(
-		"lv2ls (lilv) " LILV_VERSION "\n"
-		"Copyright 2007-2019 David Robillard <http://drobilla.net>\n"
-		"License: <http://www.opensource.org/licenses/isc-license>\n"
-		"This is free software: you are free to change and redistribute it.\n"
-		"There is NO WARRANTY, to the extent permitted by law.\n");
+  printf("lv2ls (lilv) " LILV_VERSION "\n"
+         "Copyright 2007-2019 David Robillard <http://drobilla.net>\n"
+         "License: <http://www.opensource.org/licenses/isc-license>\n"
+         "This is free software: you are free to change and redistribute it.\n"
+         "There is NO WARRANTY, to the extent permitted by law.\n");
 }
 
 static void
 print_usage(void)
 {
-	printf("Usage: lv2ls [OPTION]...\n");
-	printf("List all installed LV2 plugins.\n");
-	printf("\n");
-	printf("  -n, --names    Show names instead of URIs\n");
-	printf("  --help         Display this help and exit\n");
-	printf("  --version      Display version information and exit\n");
-	printf("\n");
-	printf("The environment variable LV2_PATH can be used to control where\n");
-	printf("this (and all other lilv based LV2 hosts) will search for plugins.\n");
+  printf("Usage: lv2ls [OPTION]...\n");
+  printf("List all installed LV2 plugins.\n");
+  printf("\n");
+  printf("  -n, --names    Show names instead of URIs\n");
+  printf("  --help         Display this help and exit\n");
+  printf("  --version      Display version information and exit\n");
+  printf("\n");
+  printf("The environment variable LV2_PATH can be used to control where\n");
+  printf(
+    "this (and all other lilv based LV2 hosts) will search for plugins.\n");
 }
 
 int
 main(int argc, char** argv)
 {
-	bool show_names = false;
-	for (int i = 1; i < argc; ++i) {
-		if (!strcmp(argv[i], "--names") || !strcmp(argv[i], "-n")) {
-			show_names = true;
-		} else if (!strcmp(argv[i], "--version")) {
-			print_version();
-			return 0;
-		} else if (!strcmp(argv[i], "--help")) {
-			print_usage();
-			return 0;
-		} else {
-			print_usage();
-			return 1;
-		}
-	}
+  bool show_names = false;
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp(argv[i], "--names") || !strcmp(argv[i], "-n")) {
+      show_names = true;
+    } else if (!strcmp(argv[i], "--version")) {
+      print_version();
+      return 0;
+    } else if (!strcmp(argv[i], "--help")) {
+      print_usage();
+      return 0;
+    } else {
+      print_usage();
+      return 1;
+    }
+  }
 
-	LilvWorld* world = lilv_world_new();
-	lilv_world_load_all(world);
+  LilvWorld* world = lilv_world_new();
+  lilv_world_load_all(world);
 
-	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+  const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
 
-	list_plugins(plugins, show_names);
+  list_plugins(plugins, show_names);
 
-	lilv_world_free(world);
+  lilv_world_free(world);
 
-	return 0;
+  return 0;
 }
diff --git a/utils/uri_table.h b/utils/uri_table.h
index 70635a3..78d3916 100644
--- a/utils/uri_table.h
+++ b/utils/uri_table.h
@@ -29,54 +29,52 @@
 #include <string.h>
 
 typedef struct {
-	char** uris;
-	size_t n_uris;
+  char** uris;
+  size_t n_uris;
 } URITable;
 
 static void
 uri_table_init(URITable* table)
 {
-	table->uris   = NULL;
-	table->n_uris = 0;
+  table->uris   = NULL;
+  table->n_uris = 0;
 }
 
 static void
 uri_table_destroy(URITable* table)
 {
-	for (size_t i = 0; i < table->n_uris; ++i) {
-		free(table->uris[i]);
-	}
+  for (size_t i = 0; i < table->n_uris; ++i) {
+    free(table->uris[i]);
+  }
 
-	free(table->uris);
+  free(table->uris);
 }
 
 static LV2_URID
-uri_table_map(LV2_URID_Map_Handle handle,
-              const char*         uri)
+uri_table_map(LV2_URID_Map_Handle handle, const char* uri)
 {
-	URITable* table = (URITable*)handle;
-	for (size_t i = 0; i < table->n_uris; ++i) {
-		if (!strcmp(table->uris[i], uri)) {
-			return i + 1;
-		}
-	}
+  URITable* table = (URITable*)handle;
+  for (size_t i = 0; i < table->n_uris; ++i) {
+    if (!strcmp(table->uris[i], uri)) {
+      return i + 1;
+    }
+  }
 
-	const size_t len = strlen(uri);
-	table->uris = (char**)realloc(table->uris, ++table->n_uris * sizeof(char*));
-	table->uris[table->n_uris - 1] = (char*)malloc(len + 1);
-	memcpy(table->uris[table->n_uris - 1], uri, len + 1);
-	return table->n_uris;
+  const size_t len = strlen(uri);
+  table->uris = (char**)realloc(table->uris, ++table->n_uris * sizeof(char*));
+  table->uris[table->n_uris - 1] = (char*)malloc(len + 1);
+  memcpy(table->uris[table->n_uris - 1], uri, len + 1);
+  return table->n_uris;
 }
 
 static const char*
-uri_table_unmap(LV2_URID_Map_Handle handle,
-                LV2_URID            urid)
+uri_table_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)
 {
-	URITable* table = (URITable*)handle;
-	if (urid > 0 && urid <= table->n_uris) {
-		return table->uris[urid - 1];
-	}
-	return NULL;
+  URITable* table = (URITable*)handle;
+  if (urid > 0 && urid <= table->n_uris) {
+    return table->uris[urid - 1];
+  }
+  return NULL;
 }
 
-#endif  /* URI_TABLE_H */
+#endif /* URI_TABLE_H */