Add "Jalv", a stand-alone version of lv2jack that supports plugin UIs via Suil

git-svn-id: http://svn.drobilla.net/lad/trunk/jalv@3344 a436a847-0d15-0410-975c-d299462d15a1

10 files changed, 875 insertions, 0 deletions

diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..9a13e9e
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,8 @@
+Author:
+	David Robillard <d@drobilla.net>
+
+GTK2 GUI and I18N support:
+	Lars Luthman <lars.luthman@gmail.com>
+
+Dynamic manifest support:
+	Stefano D'Angelo
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..a739216
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,13 @@
+Copyright 2011 David Robillard <http://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.
\ No newline at end of file
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..f6e4dd4
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,35 @@
+This software requires only Python to build.
+
+Like an auto* project, building has three phases:
+
+
+* Configure:       ./waf configure [OPTIONS]
+
+  Example:
+    ./waf configure --prefix=/some/where --debug --strict
+
+  If --debug is not given, the flags from the environment variables
+  CFLAGS and CXXFLAGS will be used.
+
+  The default prefix is /usr/local
+
+
+* Build:           ./waf [OPTIONS]
+
+  Example:
+    ./waf -j4
+
+
+* Install:         ./waf install [OPTIONS]
+
+  The environment variable DESTDIR can be used to add any prefix to
+  the install paths (useful for packaging).  Example:
+
+  DESTDIR=/home/drobilla/packages ./waf install
+
+
+*** IMPORTANT: You must use absolute paths everywhere
+
+
+Run './waf --help' for detailed option information.
+
diff --git a/src/jalv.c b/src/jalv.c
new file mode 100644
index 0000000..f2c3a1f
--- /dev/null
+++ b/src/jalv.c
@@ -0,0 +1,469 @@
+/*
+  Copyright 2007-2011 David Robillard <http://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.
+*/
+
+#define _XOPEN_SOURCE 500
+
+#include <math.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <jack/jack.h>
+#include <jack/midiport.h>
+#include <jack/session.h>
+
+#include "lv2/lv2plug.in/ns/ext/event/event-helpers.h"
+#include "lv2/lv2plug.in/ns/ext/event/event.h"
+#include "lv2/lv2plug.in/ns/ext/uri-map/uri-map.h"
+
+#include "lilv/lilv.h"
+
+#include "suil/suil.h"
+
+#include "jalv_internal.h"
+#include "jalv-config.h"
+
+sem_t exit_sem;  /**< Exit semaphore */
+
+#define MIDI_BUFFER_SIZE 1024
+
+enum PortType {
+	CONTROL,
+	AUDIO,
+	EVENT
+};
+
+struct Port {
+	const LilvPort*   lilv_port;
+	enum PortType     type;
+	jack_port_t*      jack_port; /**< For audio/MIDI ports, otherwise NULL */
+	float             control;   /**< For control ports, otherwise 0.0f */
+	LV2_Event_Buffer* ev_buffer; /**< For MIDI ports, otherwise NULL */
+	bool              is_input;
+};
+
+/** URI map feature, for event types (we use only MIDI) */
+#define MIDI_EVENT_ID 1
+uint32_t
+uri_to_id(LV2_URI_Map_Callback_Data callback_data,
+          const char*               map,
+          const char*               uri)
+{
+	/* Note a non-trivial host needs to use an actual dictionary here */
+	if (!strcmp(map, LV2_EVENT_URI) && !strcmp(uri, LILV_URI_MIDI_EVENT))
+		return MIDI_EVENT_ID;
+	else
+		return 0;  /* Refuse to map ID */
+}
+
+#define NS_EXT "http://lv2plug.in/ns/ext/"
+
+static LV2_URI_Map_Feature uri_map         = { NULL, &uri_to_id };
+static const LV2_Feature   uri_map_feature = { NS_EXT "uri-map", &uri_map };
+
+const LV2_Feature* features[2] = { &uri_map_feature, NULL };
+
+/** Abort and exit on error */
+static void
+die(const char* msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(EXIT_FAILURE);
+}
+
+/** Creates a port and connects the plugin instance to its data location.
+ *
+ * For audio ports, creates a jack port and connects plugin port to buffer.
+ *
+ * For control ports, sets controls array to default value and connects plugin
+ * port to that element.
+ */
+void
+create_port(Jalv*    host,
+            uint32_t port_index,
+            float    default_value)
+{
+	struct Port* const port = &host->ports[port_index];
+
+	port->lilv_port = lilv_plugin_get_port_by_index(host->plugin, port_index);
+	port->jack_port = NULL;
+	port->control   = 0.0f;
+	port->ev_buffer = NULL;
+
+	lilv_instance_connect_port(host->instance, port_index, NULL);
+
+	/* Get the port symbol for console printing */
+	const LilvNode* symbol     = lilv_port_get_symbol(host->plugin, port->lilv_port);
+	const char*     symbol_str = lilv_node_as_string(symbol);
+
+	enum JackPortFlags jack_flags = 0;
+	if (lilv_port_is_a(host->plugin, port->lilv_port, host->input_class)) {
+		jack_flags     = JackPortIsInput;
+		port->is_input = true;
+	} else if (lilv_port_is_a(host->plugin, port->lilv_port, host->output_class)) {
+		jack_flags     = JackPortIsOutput;
+		port->is_input = false;
+	} else if (lilv_port_has_property(host->plugin, port->lilv_port, host->optional)) {
+		lilv_instance_connect_port(host->instance, port_index, NULL);
+	} else {
+		die("Mandatory port has unknown type (neither input or output)");
+	}
+
+	/* Set control values */
+	if (lilv_port_is_a(host->plugin, port->lilv_port, host->control_class)) {
+		port->type    = CONTROL;
+		port->control = isnan(default_value) ? 0.0 : default_value;
+		printf("%s = %f\n", symbol_str, host->ports[port_index].control);
+	} else if (lilv_port_is_a(host->plugin, port->lilv_port, host->audio_class)) {
+		port->type = AUDIO;
+	} else if (lilv_port_is_a(host->plugin, port->lilv_port, host->event_class)) {
+		port->type = EVENT;
+	}
+
+	/* Connect the port based on its type */
+	switch (port->type) {
+	case CONTROL:
+		lilv_instance_connect_port(host->instance, port_index, &port->control);
+		break;
+	case AUDIO:
+		port->jack_port = jack_port_register(
+			host->jack_client, symbol_str, JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0);
+		break;
+	case EVENT:
+		port->jack_port = jack_port_register(
+			host->jack_client, symbol_str, JACK_DEFAULT_MIDI_TYPE, jack_flags, 0);
+		port->ev_buffer = lv2_event_buffer_new(MIDI_BUFFER_SIZE, LV2_EVENT_AUDIO_STAMP);
+		lilv_instance_connect_port(host->instance, port_index, port->ev_buffer);
+		break;
+	default:
+		/* FIXME: check if port connection is optional and die if not */
+		lilv_instance_connect_port(host->instance, port_index, NULL);
+		fprintf(stderr, "WARNING: Unknown port type, port not connected.\n");
+	}
+}
+
+/** Jack process callback. */
+int
+jack_process_cb(jack_nframes_t nframes, void* data)
+{
+	Jalv* const host = (Jalv*)data;
+
+	/* Prepare port buffers */
+	for (uint32_t p = 0; p < host->num_ports; ++p) {
+		if (!host->ports[p].jack_port)
+			continue;
+
+		if (host->ports[p].type == AUDIO) {
+			/* Connect plugin port directly to Jack port buffer. */
+			lilv_instance_connect_port(
+				host->instance, p,
+				jack_port_get_buffer(host->ports[p].jack_port, nframes));
+
+		} else if (host->ports[p].type == EVENT) {
+			/* Clear Jack event port buffer. */
+			lv2_event_buffer_reset(host->ports[p].ev_buffer,
+			                       LV2_EVENT_AUDIO_STAMP,
+			                       (uint8_t*)(host->ports[p].ev_buffer + 1));
+
+			if (host->ports[p].is_input) {
+				void* buf = jack_port_get_buffer(host->ports[p].jack_port,
+				                                 nframes);
+
+				LV2_Event_Iterator iter;
+				lv2_event_begin(&iter, host->ports[p].ev_buffer);
+
+				for (uint32_t i = 0; i < jack_midi_get_event_count(buf); ++i) {
+					jack_midi_event_t ev;
+					jack_midi_event_get(&ev, buf, i);
+					lv2_event_write(&iter,
+					                ev.time, 0,
+					                MIDI_EVENT_ID, ev.size, ev.buffer);
+				}
+			}
+		}
+	}
+
+	/* Run plugin for this cycle */
+	lilv_instance_run(host->instance, nframes);
+
+	/* Deliver MIDI output */
+	for (uint32_t p = 0; p < host->num_ports; ++p) {
+		if (host->ports[p].jack_port
+		    && !host->ports[p].is_input
+		    && host->ports[p].type == EVENT) {
+
+			void* buf = jack_port_get_buffer(host->ports[p].jack_port,
+			                                 nframes);
+
+			jack_midi_clear_buffer(buf);
+
+			LV2_Event_Iterator iter;
+			lv2_event_begin(&iter, host->ports[p].ev_buffer);
+
+			for (uint32_t i = 0; i < iter.buf->event_count; ++i) {
+				uint8_t*   data;
+				LV2_Event* ev = lv2_event_get(&iter, &data);
+				jack_midi_event_write(buf, ev->frames, data, ev->size);
+				lv2_event_increment(&iter);
+			}
+		}
+	}
+
+	return 0;
+}
+
+#ifdef JALV_JACK_SESSION
+void
+jack_session_cb(jack_session_event_t* event, void* arg)
+{
+	Jalv* host = (Jalv*)arg;
+
+	char cmd[256];
+	snprintf(cmd, sizeof(cmd), "jalv %s %s",
+	         lilv_node_as_uri(lilv_plugin_get_uri(host->plugin)),
+	         event->client_uuid);
+
+	event->command_line = strdup(cmd);
+	jack_session_reply(host->jack_client, event);
+
+	switch (event->type) {
+	case JackSessionSave:
+		break;
+	case JackSessionSaveAndQuit:
+		sem_post(&exit_sem);
+		break;
+	case JackSessionSaveTemplate:
+		break;
+	}
+
+	jack_session_event_free(event);
+}
+#endif /* JALV_JACK_SESSION */
+
+static void
+lv2_ui_write(SuilController controller,
+             uint32_t       port_index,
+             uint32_t       buffer_size,
+             uint32_t       format,
+             const void*    buffer)
+{
+	fprintf(stderr, "UI WRITE\n");
+}
+
+static void
+signal_handler(int ignored)
+{
+	sem_post(&exit_sem);
+}
+
+int
+main(int argc, char** argv)
+{
+	jalv_init(&argc, &argv);
+
+	Jalv host;
+	host.jack_client = NULL;
+	host.num_ports   = 0;
+	host.ports       = NULL;
+
+	sem_init(&exit_sem, 0, 0);
+	host.done = &exit_sem;
+
+	signal(SIGINT, signal_handler);
+	signal(SIGTERM, signal_handler);
+
+	/* Find all installed plugins */
+	LilvWorld* world = lilv_world_new();
+	lilv_world_load_all(world);
+	host.world = world;
+	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+
+	/* Set up the port classes this app supports */
+	host.input_class   = lilv_new_uri(world, LILV_URI_INPUT_PORT);
+	host.output_class  = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
+	host.control_class = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
+	host.audio_class   = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
+	host.event_class   = lilv_new_uri(world, LILV_URI_EVENT_PORT);
+	host.midi_class    = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
+	host.optional      = lilv_new_uri(world, LILV_NS_LV2
+	                                  "connectionOptional");
+
+#ifdef JALV_JACK_SESSION
+	if (argc != 2 && argc != 3) {
+		fprintf(stderr, "Usage: %s PLUGIN_URI [JACK_UUID]\n", argv[0]);
+#else
+	if (argc != 2) {
+		fprintf(stderr, "Usage: %s PLUGIN_URI\n", argv[0]);
+#endif
+		lilv_world_free(world);
+		return EXIT_FAILURE;
+	}
+
+	const char* const plugin_uri_str = argv[1];
+
+	printf("Plugin:    %s\n", plugin_uri_str);
+
+	/* Get the plugin */
+	LilvNode* plugin_uri = lilv_new_uri(world, plugin_uri_str);
+	host.plugin = lilv_plugins_get_by_uri(plugins, plugin_uri);
+	lilv_node_free(plugin_uri);
+	if (!host.plugin) {
+		fprintf(stderr, "Failed to find plugin %s.\n", plugin_uri_str);
+		lilv_world_free(world);
+		return EXIT_FAILURE;
+	}
+
+	/* Get a plugin UI */
+	LilvNode*       native_ui_type = jalv_native_ui_type(&host);
+	const LilvUI*   ui             = NULL;
+	const LilvNode* ui_type        = NULL;
+	if (native_ui_type) {
+		LilvUIs* uis = lilv_plugin_get_uis(host.plugin); // FIXME: leak
+		LILV_FOREACH(uis, u, uis) {
+			const LilvUI* this_ui = lilv_uis_get(uis, u);
+			if (lilv_ui_is_supported(this_ui,
+			                         suil_ui_supported,
+			                         native_ui_type,
+			                         &ui_type)) {
+				// TODO: Multiple UI support
+				ui = this_ui;
+				break;
+			}
+		}
+	}
+
+	if (ui) {
+		fprintf(stderr, "UI:        %s\n",
+		        lilv_node_as_uri(lilv_ui_get_uri(ui)));
+	} else {
+		fprintf(stderr, "No appropriate UI found\n");
+	}
+
+	/* Get the plugin's name */
+	LilvNode*   name     = lilv_plugin_get_name(host.plugin);
+	const char* name_str = lilv_node_as_string(name);
+
+	/* Truncate plugin name to suit JACK (if necessary) */
+	char* jack_name = NULL;
+	if (strlen(name_str) >= (unsigned)jack_client_name_size() - 1) {
+		jack_name = calloc(jack_client_name_size(), sizeof(char));
+		strncpy(jack_name, name_str, jack_client_name_size() - 1);
+	} else {
+		jack_name = strdup(name_str);
+	}
+
+	/* Connect to JACK */
+	printf("JACK Name: %s\n\n", jack_name);
+#ifdef JALV_JACK_SESSION
+	const char* const jack_uuid_str = (argc > 2) ? argv[2] : NULL;
+	if (jack_uuid_str) {
+		host.jack_client = jack_client_open(jack_name, JackSessionID, NULL,
+		                                    jack_uuid_str);
+	}
+#endif
+
+	if (!host.jack_client) {
+		host.jack_client = jack_client_open(jack_name, JackNullOption, NULL);
+	}
+
+	free(jack_name);
+	lilv_node_free(name);
+
+	if (!host.jack_client)
+		die("Failed to connect to JACK.\n");
+
+	/* Instantiate the plugin */
+	host.instance = lilv_plugin_instantiate(
+		host.plugin, jack_get_sample_rate(host.jack_client), features);
+	if (!host.instance)
+		die("Failed to instantiate plugin.\n");
+
+	/* Set Jack callbacks */
+	jack_set_process_callback(host.jack_client, &jack_process_cb, (void*)(&host));
+#ifdef JALV_JACK_SESSION
+	jack_set_session_callback(host.jack_client, &jack_session_cb, (void*)(&host));
+#endif
+
+	/* Create ports */
+	host.num_ports = lilv_plugin_get_num_ports(host.plugin);
+	host.ports     = calloc((size_t)host.num_ports, sizeof(struct Port));
+	float* default_values = calloc(lilv_plugin_get_num_ports(host.plugin),
+	                               sizeof(float));
+	lilv_plugin_get_port_ranges_float(host.plugin, NULL, NULL, default_values);
+
+	for (uint32_t i = 0; i < host.num_ports; ++i)
+		create_port(&host, i, default_values[i]);
+
+	free(default_values);
+
+	/* Activate plugin and JACK */
+	lilv_instance_activate(host.instance);
+	jack_activate(host.jack_client);
+
+	SuilHost* ui_host = suil_host_new(lv2_ui_write, NULL, NULL, NULL);
+
+	/* Instantiate the UI */
+	SuilInstance* instance = suil_instance_new(
+		ui_host,
+		&host,
+		lilv_node_as_uri(native_ui_type),
+		lilv_node_as_uri(lilv_plugin_get_uri(host.plugin)),
+		lilv_node_as_uri(lilv_ui_get_uri(ui)),
+		lilv_node_as_uri(ui_type),
+		lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_bundle_uri(ui))),
+		lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_binary_uri(ui))),
+		NULL);
+
+	/* Run UI */
+	jalv_open_ui(&host, instance);
+
+	/* Wait for finish signal from UI or signal handler */
+	sem_wait(&exit_sem);
+
+	fprintf(stderr, "Exiting...\n");
+
+	/* Deactivate JACK */
+	jack_deactivate(host.jack_client);
+	for (uint32_t i = 0; i < host.num_ports; ++i) {
+		if (host.ports[i].ev_buffer) {
+			free(host.ports[i].ev_buffer);
+		}
+	}
+	jack_client_close(host.jack_client);
+
+	/* Deactivate plugin */
+	lilv_instance_deactivate(host.instance);
+	lilv_instance_free(host.instance);
+
+	/* Clean up */
+	free(host.ports);
+	lilv_node_free(native_ui_type);
+	lilv_node_free(host.input_class);
+	lilv_node_free(host.output_class);
+	lilv_node_free(host.control_class);
+	lilv_node_free(host.audio_class);
+	lilv_node_free(host.event_class);
+	lilv_node_free(host.midi_class);
+	lilv_node_free(host.optional);
+	suil_host_free(ui_host);
+	lilv_world_free(world);
+
+	sem_destroy(&exit_sem);
+
+	return 0;
+}
diff --git a/src/jalv_console.c b/src/jalv_console.c
new file mode 100644
index 0000000..48c3ed3
--- /dev/null
+++ b/src/jalv_console.c
@@ -0,0 +1,50 @@
+/*
+  Copyright 2007-2011 David Robillard <http://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 <stdio.h>
+
+#include "jalv-config.h"
+#include "jalv_internal.h"
+
+void
+jalv_init(int* argc, char*** argv)
+{
+}
+
+LilvNode*
+jalv_native_ui_type(Jalv* jalv)
+{
+	return NULL;
+}
+
+int
+jalv_open_ui(Jalv*         jalv,
+             SuilInstance* instance)
+{
+#ifdef JALV_JACK_SESSION
+	printf("\nPress Ctrl-C to quit: ");
+	fflush(stdout);
+	//g_cond_wait(exit_cond, exit_mutex);
+#else
+	printf("\nPress enter to quit: ");
+	fflush(stdout);
+	getc(stdin);
+	sem_post(jalv->done);
+#endif
+	printf("\n");
+
+	return 0;
+}
diff --git a/src/jalv_gtk2.c b/src/jalv_gtk2.c
new file mode 100644
index 0000000..72c8a1a
--- /dev/null
+++ b/src/jalv_gtk2.c
@@ -0,0 +1,76 @@
+/*
+  Copyright 2007-2011 David Robillard <http://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 <gtk/gtk.h>
+
+#include "jalv_internal.h"
+
+static void destroy(GtkWidget* widget,
+                    gpointer   data)
+{
+	gtk_main_quit();
+}
+
+void
+jalv_init(int* argc, char*** argv)
+{
+	GError* error = NULL;
+	gtk_init_with_args(
+		argc, argv,
+		"PLUGIN_URI [JACK_UUID] - Run an LV2 plugin as a Jack application",
+		NULL, NULL, &error);
+}
+
+LilvNode*
+jalv_native_ui_type(Jalv* jalv)
+{
+	return lilv_new_uri(jalv->world,
+	                    "http://lv2plug.in/ns/extensions/ui#GtkUI");
+}
+
+int
+jalv_open_ui(Jalv*         jalv,
+             SuilInstance* instance)
+{
+	GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    
+	g_signal_connect(window, "destroy",
+	                 G_CALLBACK(destroy), NULL);
+    
+	gtk_container_set_border_width(GTK_CONTAINER(window), 8);
+
+	if (instance) {
+		GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(instance);
+		gtk_container_add(GTK_CONTAINER(window), widget);
+	} else {
+		GtkWidget* button = gtk_button_new_with_label("Close");
+    
+		g_signal_connect_swapped(button, "clicked",
+		                         G_CALLBACK(gtk_widget_destroy),
+		                         window);
+    
+		gtk_container_add(GTK_CONTAINER(window), button);
+	}
+
+	// TODO: Check UI properties for resizable
+	gtk_window_set_resizable(GTK_WINDOW(window), false);
+
+	gtk_widget_show_all(window);
+    
+	gtk_main();
+	sem_post(jalv->done);
+	return 0;
+}
diff --git a/src/jalv_internal.h b/src/jalv_internal.h
new file mode 100644
index 0000000..f4dc6d4
--- /dev/null
+++ b/src/jalv_internal.h
@@ -0,0 +1,64 @@
+/*
+  Copyright 2007-2011 David Robillard <http://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.
+*/
+
+#ifndef JALV_INTERNAL_H
+#define JALV_INTERNAL_H
+
+#include <semaphore.h>
+
+#include <jack/jack.h>
+
+#include "lilv/lilv.h"
+
+#include "suil/suil.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	LilvWorld*        world;         /**< Lilv World */
+	jack_client_t*    jack_client;   /**< Jack client */
+	sem_t*            done;          /**< Exit semaphore */
+	const LilvPlugin* plugin;        /**< Plugin class (RDF data) */
+	LilvInstance*     instance;      /**< Plugin instance (shared library) */
+	uint32_t          num_ports;     /**< Size of the two following arrays: */
+	struct Port*      ports;         /**< Port array of size num_ports */
+	LilvNode*         input_class;   /**< Input port class (URI) */
+	LilvNode*         output_class;  /**< Output port class (URI) */
+	LilvNode*         control_class; /**< Control port class (URI) */
+	LilvNode*         audio_class;   /**< Audio port class (URI) */
+	LilvNode*         event_class;   /**< Event port class (URI) */
+	LilvNode*         midi_class;    /**< MIDI event class (URI) */
+	LilvNode*         optional;      /**< lv2:connectionOptional port property */
+} Jalv;
+
+void
+jalv_init(int* argc, char*** argv);
+
+LilvNode*
+jalv_native_ui_type(Jalv* jalv);
+
+int
+jalv_open_ui(Jalv*         jalv,
+             SuilInstance* instance);
+
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // JALV_INTERNAL_H
diff --git a/src/jalv_qt4.cpp b/src/jalv_qt4.cpp
new file mode 100644
index 0000000..79cf985
--- /dev/null
+++ b/src/jalv_qt4.cpp
@@ -0,0 +1,59 @@
+/*
+  Copyright 2007-2011 David Robillard <http://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 "jalv_internal.h"
+
+#include <QApplication>
+#include <QPushButton>
+#include <QMainWindow>
+
+static QApplication* app = NULL;
+
+extern "C" {
+
+void
+jalv_init(int* argc, char*** argv)
+{
+	app = new QApplication(*argc, *argv, true);
+}
+
+LilvNode*
+jalv_native_ui_type(Jalv* jalv)
+{
+	return lilv_new_uri(jalv->world,
+	                    "http://lv2plug.in/ns/extensions/ui#Qt4UI");
+}
+
+int
+jalv_open_ui(Jalv*         jalv,
+             SuilInstance* instance)
+{
+	if (instance) {
+		QWidget* widget = (QWidget*)suil_instance_get_widget(instance);
+		widget->show();
+	} else {
+		QPushButton* button = new QPushButton("Close");
+		button->show();
+		QObject::connect(button, SIGNAL(clicked()), app, SLOT(quit()));
+	}
+	app->connect(app, SIGNAL(lastWindowClosed()), app, SLOT(quit()));
+
+	int ret = app->exec();
+	sem_post(jalv->done);
+	return ret;
+}
+
+} // extern "C"
diff --git a/waf b/waf
new file mode 100755
index 0000000..686fe2b
--- /dev/null
+++ b/waf
diff --git a/wscript b/wscript
new file mode 100644
index 0000000..0c1d33b
--- /dev/null
+++ b/wscript
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+import os
+import sys
+import subprocess
+
+from waflib.extras import autowaf as autowaf
+import waflib.Options as Options
+import waflib.Logs as Logs
+
+# Version of this package (even if built as a child)
+JALV_VERSION       = '0.0.0'
+JALV_MAJOR_VERSION = '0'
+
+# Variables for 'waf dist'
+APPNAME = 'jalv'
+VERSION = JALV_VERSION
+
+# Mandatory variables
+top = '.'
+out = 'build'
+
+def options(opt):
+    autowaf.set_options(opt)
+    opt.add_option('--no-jack-session', action='store_true', default=False,
+                   dest='no_jack_session',
+                   help="Do not build JACK session support")
+
+def configure(conf):
+    conf.line_just = 63
+    autowaf.configure(conf)
+    autowaf.display_header('Jalv Configuration')
+    conf.load('compiler_cc')
+
+    autowaf.check_pkg(conf, 'lv2core', uselib_store='LV2CORE', mandatory=True)
+    autowaf.check_pkg(conf, 'glib-2.0', uselib_store='GLIB',
+                      atleast_version='2.0.0', mandatory=True)
+    autowaf.check_pkg(conf, 'gthread-2.0', uselib_store='GTHREAD',
+                      atleast_version='2.0.0', mandatory=False)
+    autowaf.check_pkg(conf, 'lilv-0', uselib_store='LILV',
+                      atleast_version='0.4.0', mandatory=True)
+    autowaf.check_pkg(conf, 'suil-0', uselib_store='SUIL',
+                      atleast_version='0.4.0', mandatory=True)
+    autowaf.check_pkg(conf, 'jack', uselib_store='JACK',
+                      atleast_version='0.120.0', mandatory=True)
+    autowaf.check_pkg(conf, 'gtk+-2.0', uselib_store='GTK2',
+                      atleast_version='2.18.0', mandatory=False)
+    autowaf.check_pkg(conf, 'QtGui', uselib_store='QT4',
+                      atleast_version='4.0.0', mandatory=False)
+
+    autowaf.check_header(conf, 'lv2/lv2plug.in/ns/lv2core/lv2.h')
+    autowaf.check_header(conf, 'lv2/lv2plug.in/ns/ext/event/event.h')
+    autowaf.check_header(conf, 'lv2/lv2plug.in/ns/ext/event/event-helpers.h')
+    autowaf.check_header(conf, 'lv2/lv2plug.in/ns/ext/uri-map/uri-map.h')
+
+    if not Options.options.no_jack_session:
+        autowaf.define(conf, 'JALV_JACK_SESSION', 1)
+
+    conf.env.append_value('CFLAGS', '-std=c99')
+    autowaf.define(conf, 'JALV_VERSION', JALV_VERSION)
+
+    conf.write_config_header('jalv-config.h', remove=False)
+
+    autowaf.display_msg(conf, "Gtk 2.0 support",
+                        conf.is_defined('HAVE_GTK2'))
+    autowaf.display_msg(conf, "Qt 4.0 support",
+                        conf.is_defined('HAVE_QT4'))
+    print('')
+
+def build(bld):
+    libs = 'LILV SUIL JACK'
+    if bld.is_defined('JALV_JACK_SESSION'):
+        libs += ' GLIB GTHREAD'
+
+    # Non-GUI version
+    obj = bld(features     = 'c cprogram',
+              source       = 'src/jalv.c src/jalv_console.c',
+              target       = 'jalv',
+              install_path = '${BINDIR}')
+    autowaf.use_lib(bld, obj, libs)
+
+    # Gtk version
+    if bld.is_defined('HAVE_GTK2'):
+        obj = bld(features     = 'c cprogram',
+                  source       = 'src/jalv.c src/jalv_gtk2.c',
+                  target       = 'jalv.gtk',
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTK2')
+
+    # Qt version
+    if bld.is_defined('HAVE_QT4'):
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = 'src/jalv.c src/jalv_qt4.cpp',
+                  target       = 'jalv.qt',
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' QT4')
+
+    # Man pages
+    bld.install_files('${MANDIR}/man1', bld.path.ant_glob('doc/*.1'))
+
+def lint(ctx):
+    subprocess.call('cpplint.py --filter=+whitespace/comments,-whitespace/tab,-whitespace/braces,-whitespace/labels,-build/header_guard,-readability/casting,-readability/todo,-build/include src/* jalv/*', shell=True)