Switch to meson build system

8 files changed, 1473 insertions, 0 deletions

diff --git a/tools/bench.h b/tools/bench.h
new file mode 100644
index 0000000..33e37f6
--- /dev/null
+++ b/tools/bench.h
@@ -0,0 +1,51 @@
+/*
+  Copyright 2011-2019 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/**
+   @file bench.h A simple real-time benchmarking API.
+*/
+
+#ifndef BENCH_H
+#define BENCH_H
+
+#include <time.h>
+
+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));
+}
+
+static inline BenchmarkTime
+bench_start(void)
+{
+  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);
+}
+
+#endif /* BENCH_H */
diff --git a/tools/lilv.bash_completion b/tools/lilv.bash_completion
new file mode 100644
index 0000000..4a553a7
--- /dev/null
+++ b/tools/lilv.bash_completion
@@ -0,0 +1,59 @@
+# Bash auto-completion script written for lv2info and lv2jack.
+# Could be adapted to any other program that takes an
+# LV2 plugin URI as parameter.
+
+# Updated for Lilv by David Robillard <d@drobilla.net> on 2012-01-08.
+# Written by Lars Luthman <lars.luthman@gmail.com> on 2009-10-12. 
+# No copyright claimed for this script. Do what you want with it.
+
+# For some reason Bash splits the command line not only at whitespace
+# but also at ':' signs before putting the parts into COMP_WORDS.
+# Since ':' is used in all URIs, which are what we want to complete,
+# we have to put the URI back together before we can complete it
+# and then cut off the parts we prepended from the completions.
+# It probably breaks in some special cases but for most common uses
+# it should work fine.
+
+function _lv2info() {
+    local uri cur opts w wn raw_reply len type
+    opts=`lv2ls | xargs -n1 echo -n " "`
+    
+    # This is the last "word", as split by Bash.
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    w="$cur"
+    
+    # Add the previous word while it or this one is a word break character
+    for i in `seq $(( $COMP_CWORD - 1 )) -1 1`; do
+	wn="${COMP_WORDS[i]}"
+	if expr "$COMP_WORDBREAKS" : ".*$wn" > /dev/null; then
+	    if expr "$COMP_WORDBREAKS" : ".*$w" > /dev/null; then
+		break
+	    fi
+	fi
+	w="$wn"
+	uri="$w$uri"
+    done
+    
+    # Check the length of the words we prepend
+    len=${#uri}
+    uri="$uri$cur"
+    raw_reply="$(compgen -W "${opts}" -- ${uri})"
+    
+    # If we are listing alternatives, just print the full URIs.
+    type=`echo $COMP_TYPE | awk '{ printf "%c", $1 }'`
+    if expr "?!@%" : ".*$type" > /dev/null; then
+	COMPREPLY=( $raw_reply )
+	return 0
+    fi
+    
+    # Otherwise, strip the prepended words from all completion suggestions.
+    COMPREPLY=()
+    for i in $raw_reply; do
+	COMPREPLY=( ${COMPREPLY[@]} ${i:len} )
+    done
+}
+
+complete -F _lv2info lv2info
+
+# And the same for lv2jack.
+complete -F _lv2info lv2jack
diff --git a/tools/lv2apply.c b/tools/lv2apply.c
new file mode 100644
index 0000000..e042999
--- /dev/null
+++ b/tools/lv2apply.c
@@ -0,0 +1,368 @@
+/*
+  Copyright 2007-2019 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "lilv/lilv.h"
+
+#include "lv2/core/lv2.h"
+
+#include <math.h>
+#include <sndfile.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__GNUC__)
+#  define LILV_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+#else
+#  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
+} Param;
+
+/** Port type (only float ports are supported) */
+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
+} 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;
+} LV2Apply;
+
+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;
+}
+
+/** 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));
+  }
+}
+
+/**
+   Read a single frame from a file into an interleaved buffer.
+
+   If more channels are required than are available in the file, the remaining
+   channels are distributed in a round-robin fashion (LRLRL).
+*/
+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;
+}
+
+/** 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;
+}
+
+/** Print a fatal error and clean up for exit. */
+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;
+}
+
+/**
+   Create port structures from data (via create_port()) for all ports.
+*/
+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;
+}
+
+static void
+print_version(void)
+{
+  printf("lv2apply (lilv) " LILV_VERSION "\n"
+         "Copyright 2007-2021 David Robillard <d@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;
+}
+
+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);
+}
diff --git a/tools/lv2bench.c b/tools/lv2bench.c
new file mode 100644
index 0000000..f0746cb
--- /dev/null
+++ b/tools/lv2bench.c
@@ -0,0 +1,282 @@
+/*
+  Copyright 2012-2019 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "lilv/lilv.h"
+#include "lv2/atom/atom.h"
+#include "lv2/core/lv2.h"
+#include "lv2/urid/urid.h"
+
+#include "bench.h"
+#include "lilv_config.h"
+#include "uri_table.h"
+
+#include <math.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+static LilvNode* atom_AtomPort   = NULL;
+static LilvNode* atom_Sequence   = NULL;
+static LilvNode* lv2_AudioPort   = NULL;
+static LilvNode* lv2_CVPort      = NULL;
+static LilvNode* lv2_ControlPort = NULL;
+static LilvNode* lv2_InputPort   = NULL;
+static LilvNode* lv2_OutputPort  = NULL;
+static LilvNode* urid_map        = NULL;
+
+static bool full_output = false;
+
+static void
+print_version(void)
+{
+  printf("lv2bench (lilv) " LILV_VERSION "\n"
+         "Copyright 2012-2021 David Robillard <d@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");
+}
+
+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 * 2ul, 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;
+}
diff --git a/tools/lv2info.c b/tools/lv2info.c
new file mode 100644
index 0000000..81a3ed4
--- /dev/null
+++ b/tools/lv2info.c
@@ -0,0 +1,456 @@
+/*
+  Copyright 2007-2019 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "lilv_config.h"
+
+#include "lilv/lilv.h"
+#include "lv2/core/lv2.h"
+#include "lv2/event/event.h"
+#include "lv2/port-groups/port-groups.h"
+#include "lv2/presets/presets.h"
+
+#include <math.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static LilvNode* applies_to_pred     = NULL;
+static LilvNode* control_class       = NULL;
+static LilvNode* event_class         = NULL;
+static LilvNode* group_pred          = NULL;
+static LilvNode* label_pred          = NULL;
+static LilvNode* preset_class        = NULL;
+static LilvNode* designation_pred    = NULL;
+static LilvNode* supports_event_pred = NULL;
+
+static void
+print_port(const LilvPlugin* p,
+           uint32_t          index,
+           float*            mins,
+           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);
+}
+
+static void
+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);
+}
+
+static void
+print_version(void)
+{
+  printf("lv2info (lilv) " LILV_VERSION "\n"
+         "Copyright 2007-2021 David Robillard <d@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");
+}
+
+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;
+}
diff --git a/tools/lv2ls.c b/tools/lv2ls.c
new file mode 100644
index 0000000..9226b89
--- /dev/null
+++ b/tools/lv2ls.c
@@ -0,0 +1,94 @@
+/*
+  Copyright 2007-2019 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "lilv_config.h"
+
+#include "lilv/lilv.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+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)));
+    }
+  }
+}
+
+static void
+print_version(void)
+{
+  printf("lv2ls (lilv) " LILV_VERSION "\n"
+         "Copyright 2007-2021 David Robillard <d@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");
+}
+
+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;
+    }
+  }
+
+  LilvWorld* world = lilv_world_new();
+  lilv_world_load_all(world);
+
+  const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+
+  list_plugins(plugins, show_names);
+
+  lilv_world_free(world);
+
+  return 0;
+}
diff --git a/tools/meson.build b/tools/meson.build
new file mode 100644
index 0000000..59249f2
--- /dev/null
+++ b/tools/meson.build
@@ -0,0 +1,83 @@
+# Copyright 2021-2022 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: CC0-1.0 OR ISC
+
+include_dirs = include_directories('../src')
+
+#############################
+# "Basic" (Lilv-Only) Tools #
+#############################
+
+basic_tools = [
+  'lv2info',
+  'lv2ls',
+]
+
+foreach tool : basic_tools
+  executable(
+    tool,
+    files(tool + '.c'),
+    c_args: c_suppressions,
+    dependencies: lilv_dep,
+    include_directories: include_dirs,
+    install: true,
+  )
+
+  install_man(files('..' / 'doc' / tool + '.1'))
+endforeach
+
+install_data(
+  files('lilv.bash_completion'),
+  install_dir: get_option('sysconfdir') / 'bash_completion.d',
+  rename: 'lilv',
+)
+
+###########################
+# lv2apply (uses sndfile) #
+###########################
+
+sndfile_dep = dependency(
+  'sndfile',
+  version: '>= 1.0.0',
+  required: get_option('tools'),
+)
+
+if sndfile_dep.found()
+  executable(
+    'lv2apply',
+    files('lv2apply.c'),
+    c_args: c_suppressions,
+    dependencies: [lilv_dep, sndfile_dep],
+    include_directories: include_dirs,
+    install: true,
+  )
+
+  install_man(files('..' / 'doc' / 'lv2apply.1'))
+endif
+
+#################################
+# lv2bench (uses clock_gettime) #
+#################################
+
+if host_machine.system() != 'windows'
+  rt_dep = cc.find_library('rt', required: false)
+
+  clock_gettime_code = '''#include <time.h>
+int main(void) { struct timespec t; return clock_gettime(CLOCK_MONOTONIC, &t); }
+'''
+
+  if cc.compiles(clock_gettime_code,
+                 args: platform_defines,
+                 dependencies: [rt_dep],
+                 name: 'clock_gettime')
+    executable(
+      'lv2bench',
+      files('lv2bench.c'),
+      c_args: c_suppressions,
+      dependencies: [lilv_dep, rt_dep, sndfile_dep],
+      include_directories: include_dirs,
+      install: true,
+    )
+
+    install_man(files('..' / 'doc' / 'lv2bench.1'))
+  endif
+endif
diff --git a/tools/uri_table.h b/tools/uri_table.h
new file mode 100644
index 0000000..5a337a3
--- /dev/null
+++ b/tools/uri_table.h
@@ -0,0 +1,80 @@
+/*
+  Copyright 2011-2019 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/**
+   @file uri_table.h A toy URI map/unmap implementation.
+
+   This file contains function definitions and must only be included once.
+*/
+
+#ifndef URI_TABLE_H
+#define URI_TABLE_H
+
+#include "lv2/urid/urid.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+  char** uris;
+  size_t n_uris;
+} URITable;
+
+static void
+uri_table_init(URITable* table)
+{
+  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]);
+  }
+
+  free(table->uris);
+}
+
+static LV2_URID
+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;
+    }
+  }
+
+  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)
+{
+  URITable* table = (URITable*)handle;
+  if (urid > 0 && urid <= table->n_uris) {
+    return table->uris[urid - 1];
+  }
+  return NULL;
+}
+
+#endif /* URI_TABLE_H */