summaryrefslogtreecommitdiffstats
path: root/examples
diff options
context:
space:
mode:
Diffstat (limited to 'examples')
-rw-r--r--examples/hosts/Makefile.am31
-rw-r--r--examples/hosts/host.c341
-rw-r--r--examples/hosts/lv2-midifunctions.h161
-rw-r--r--examples/hosts/lv2-miditype.h170
-rw-r--r--examples/hosts/simple_jack_host.c (renamed from examples/hosts/jack_host.c)0
5 files changed, 693 insertions, 10 deletions
diff --git a/examples/hosts/Makefile.am b/examples/hosts/Makefile.am
index 340c962..a5ffd44 100644
--- a/examples/hosts/Makefile.am
+++ b/examples/hosts/Makefile.am
@@ -1,24 +1,35 @@
AM_CFLAGS = -std=c99 -I. -I$(top_srcdir)/include -I$(top_srcdir) `pkg-config --cflags rasqal`
AM_LDFLAGS = `pkg-config --libs rasqal`
-bin_PROGRAMS = test_host jack_host
+bin_PROGRAMS = slv2_test_host slv2_simple_jack_host slv2_host
-test_host_DEPENDENCIES = ../../src/libslv2.la
-test_host_LDADD = ../../src/libslv2.la
+slv2_test_host_DEPENDENCIES = ../../src/libslv2.la
+slv2_test_host_LDADD = ../../src/libslv2.la
-test_host_SOURCES = \
+slv2_test_host_SOURCES = \
test_host.c
if WITH_JACK
-jack_host_CFLAGS = @JACK_CFLAGS@ $(AM_CFLAGS)
-#jack_host_LIBS = @JACK_LIBS@
+slv2_simple_jack_host_CFLAGS = @JACK_CFLAGS@ $(AM_CFLAGS)
+#simple_jack_host_LIBS = @JACK_LIBS@
-jack_host_DEPENDENCIES = ../../src/libslv2.la
-jack_host_LDADD = ../../src/libslv2.la @JACK_LIBS@
+slv2_simple_jack_host_DEPENDENCIES = ../../src/libslv2.la
+slv2_simple_jack_host_LDADD = ../../src/libslv2.la @JACK_LIBS@
+
+slv2_simple_jack_host_SOURCES = \
+ simple_jack_host.c
+
+
+slv2_host_CFLAGS = @JACK_CFLAGS@ $(AM_CFLAGS)
+#host_LIBS = @JACK_LIBS@
+
+slv2_host_DEPENDENCIES = ../../src/libslv2.la
+slv2_host_LDADD = ../../src/libslv2.la @JACK_LIBS@
+
+slv2_host_SOURCES = \
+ host.c
-jack_host_SOURCES = \
- jack_host.c
endif # WITH_JACK
diff --git a/examples/hosts/host.c b/examples/hosts/host.c
new file mode 100644
index 0000000..97937a8
--- /dev/null
+++ b/examples/hosts/host.c
@@ -0,0 +1,341 @@
+/* LibSLV2 Jack Example Host
+ * Copyright (C) 2006 Dave Robillard <drobilla@connect.carleton.ca>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <slv2/slv2.h>
+#include <jack/jack.h>
+
+#define WITH_MIDI 1
+#define MIDI_BUFFER_SIZE 1024
+
+#ifdef WITH_MIDI
+#include <jack/midiport.h>
+#include "lv2-miditype.h"
+#include "lv2-midifunctions.h"
+#endif // WITH_MIDI
+
+struct Port {
+ enum Direction { INPUT, OUTPUT} direction;
+ enum Type { UNKNOWN, FLOAT, MIDI } type;
+
+ jack_port_t* jack_port; /**< For audio and MIDI ports, otherwise NULL */
+ float control; /**< For control ports, otherwise 0.0f */
+ LV2_MIDI* midi_buffer; /**< For midi ports, otherwise NULL */
+};
+
+
+/** This program's data */
+struct JackHost {
+ jack_client_t* jack_client; /**< Jack client */
+ SLV2Plugin* plugin; /**< Plugin "class" (actually just a few strings) */
+ SLV2Instance* instance; /**< Plugin "instance" (loaded shared lib) */
+ uint32_t num_ports; /**< Size of the two following arrays: */
+ struct Port* ports; /** Port array of size num_ports */
+};
+
+
+void die(const char* msg);
+void create_port(struct JackHost* host, uint32_t port_index);
+int jack_process_cb(jack_nframes_t nframes, void* data);
+void list_plugins(SLV2List list);
+
+
+int
+main(int argc, char** argv)
+{
+ struct JackHost host;
+ host.jack_client = NULL;
+ host.num_ports = 0;
+ host.ports = NULL;
+
+ /* Find all installed plugins */
+ SLV2List plugins = slv2_list_new();
+ slv2_list_load_all(plugins);
+ //slv2_list_load_bundle(plugins, "http://www.scs.carleton.ca/~drobilla/files/Amp-swh.lv2");
+
+ /* Find the plugin to run */
+ const char* plugin_uri = (argc == 2) ? argv[1] : NULL;
+
+ if (!plugin_uri) {
+ fprintf(stderr, "\nYou must specify a plugin URI to load.\n");
+ fprintf(stderr, "\nKnown plugins:\n\n");
+ list_plugins(plugins);
+ return EXIT_FAILURE;
+ }
+
+ printf("URI:\t%s\n", plugin_uri);
+ host.plugin = slv2_list_get_plugin_by_uri(plugins, plugin_uri);
+
+ if (!host.plugin) {
+ fprintf(stderr, "Failed to find plugin %s.\n", plugin_uri);
+ slv2_list_free(plugins);
+ return EXIT_FAILURE;
+ }
+
+ /* Get the plugin's name */
+ char* name = slv2_plugin_get_name(host.plugin);
+ printf("Name:\t%s\n", name);
+
+ /* Connect to JACK (with plugin name as client name) */
+ host.jack_client = jack_client_open(name, JackNullOption, NULL);
+ free(name);
+ if (!host.jack_client)
+ die("Failed to connect to JACK.");
+ else
+ printf("Connected to JACK.\n");
+
+ /* Instantiate the plugin */
+ host.instance = slv2_plugin_instantiate(
+ host.plugin, jack_get_sample_rate(host.jack_client), NULL);
+ if (!host.instance)
+ die("Failed to instantiate plugin.\n");
+ else
+ printf("Succesfully instantiated plugin.\n");
+
+ jack_set_process_callback(host.jack_client, &jack_process_cb, (void*)(&host));
+
+ /* Create ports */
+ host.num_ports = slv2_plugin_get_num_ports(host.plugin);
+ host.ports = calloc((size_t)host.num_ports, sizeof(struct Port));
+
+ for (uint32_t i=0; i < host.num_ports; ++i)
+ create_port(&host, i);
+
+ /* Activate plugin and JACK */
+ slv2_instance_activate(host.instance);
+ jack_activate(host.jack_client);
+
+ /* Run */
+ printf("Press enter to quit: ");
+ getc(stdin);
+ printf("\n");
+
+ /* Deactivate plugin and JACK */
+ slv2_instance_free(host.instance);
+ slv2_list_free(plugins);
+
+ printf("Shutting down JACK.\n");
+ for (unsigned long i=0; i < host.num_ports; ++i) {
+ if (host.ports[i].jack_port != NULL) {
+ jack_port_unregister(host.jack_client, host.ports[i].jack_port);
+ host.ports[i].jack_port = NULL;
+ }
+ if (host.ports[i].midi_buffer != NULL) {
+ lv2midi_free(host.ports[i].midi_buffer);
+ }
+ }
+ jack_client_close(host.jack_client);
+
+ return 0;
+}
+
+
+/** Abort and exit on error */
+void
+die(const char* msg)
+{
+ fprintf(stderr, "%s\n", msg);
+ exit(EXIT_FAILURE);
+}
+
+
+/** Creates a port and connects the plugin instance to it's 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(struct JackHost* host,
+ uint32_t port_index)
+{
+ //struct Port* port = (Port*)malloc(sizeof(Port));
+ struct Port* const port = &host->ports[port_index];
+
+ port->type = UNKNOWN;
+ port->jack_port = NULL;
+ port->control = 0.0f;
+ port->midi_buffer = NULL;
+
+ slv2_instance_connect_port(host->instance, port_index, NULL);
+
+ char* type_str = slv2_port_get_data_type(host->plugin, port_index);
+ if (!strcmp(type_str, SLV2_DATA_TYPE_FLOAT))
+ port->type = FLOAT;
+ else if (!strcmp(type_str, SLV2_DATA_TYPE_MIDI))
+ port->type = MIDI;
+
+ /* Get the port symbol (label) for console printing */
+ char* symbol = slv2_port_get_symbol(host->plugin, port_index);
+
+ /* Get the 'class' (not data type) of the port (control input, audio output, etc) */
+ enum SLV2PortClass class = slv2_port_get_class(host->plugin, port_index);
+
+ if (port->type == FLOAT) {
+
+ /* Connect the port based on it's 'class' */
+ switch (class) {
+ case SLV2_CONTROL_RATE_INPUT:
+ port->direction = INPUT;
+ port->control = slv2_port_get_default_value(host->plugin, port_index);
+ slv2_instance_connect_port(host->instance, port_index, &port->control);
+ printf("Set %s to %f\n", symbol, host->ports[port_index].control);
+ break;
+ case SLV2_CONTROL_RATE_OUTPUT:
+ port->direction = OUTPUT;
+ slv2_instance_connect_port(host->instance, port_index, &port->control);
+ break;
+ case SLV2_AUDIO_RATE_INPUT:
+ printf("AI!\n");
+ port->direction = INPUT;
+ port->jack_port = jack_port_register(host->jack_client,
+ symbol, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+ break;
+ case SLV2_AUDIO_RATE_OUTPUT:
+ printf("AO!\n");
+ port->direction = OUTPUT;
+ port->jack_port = jack_port_register(host->jack_client,
+ symbol, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+ break;
+ default:
+ fprintf(stderr, "ERROR: Unknown port class\n");
+ }
+
+ } else if (port->type == MIDI) {
+
+ printf("MIDI! %s\n", symbol);
+ if (class == SLV2_CONTROL_RATE_INPUT) {
+ port->direction = INPUT;
+ port->jack_port = jack_port_register(host->jack_client,
+ symbol, JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
+ port->midi_buffer = lv2midi_new(MIDI_BUFFER_SIZE);
+ slv2_instance_connect_port(host->instance, port_index, port->midi_buffer);
+ } else if (class == SLV2_CONTROL_RATE_OUTPUT) {
+ port->direction = OUTPUT;
+ port->jack_port = jack_port_register(host->jack_client,
+ symbol, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
+ port->midi_buffer = lv2midi_new(MIDI_BUFFER_SIZE);
+ slv2_instance_connect_port(host->instance, port_index, port->midi_buffer);
+ } else {
+ fprintf(stderr, "ERROR: Audio rate MIDI port?? Ignoring.\n");
+ }
+
+ } else {
+
+ fprintf(stderr, "Unrecognized data type %s for port %s, ignored.\n",
+ type_str, symbol);
+ fprintf(stderr, " %s\n",
+ SLV2_DATA_TYPE_MIDI);
+
+ }
+
+ free(symbol);
+ free(type_str);
+}
+
+
+/** Jack process callback. */
+int
+jack_process_cb(jack_nframes_t nframes, void* data)
+{
+ struct JackHost* const host = (struct JackHost*)data;
+
+ /* Connect inputs */
+ for (uint32_t p=0; p < host->num_ports; ++p) {
+ if (!host->ports[p].jack_port)
+ continue;
+
+ if (host->ports[p].type == FLOAT) {
+ slv2_instance_connect_port(host->instance, p,
+ jack_port_get_buffer(host->ports[p].jack_port, nframes));
+ } else if (host->ports[p].type == MIDI) {
+
+ void* jack_buffer = jack_port_get_buffer(host->ports[p].jack_port, nframes);
+
+ LV2_MIDIState state;
+ lv2midi_reset_state(&state, host->ports[p].midi_buffer, nframes);
+ lv2midi_reset_buffer(state.midi);
+
+ if (host->ports[p].direction == INPUT) {
+ jack_midi_event_t ev;
+
+ const jack_nframes_t event_count
+ = jack_midi_get_event_count(jack_buffer, nframes);
+
+ for (jack_nframes_t e=0; e < event_count; ++e) {
+
+ jack_midi_event_get(&ev, jack_buffer, e, nframes);
+
+ state.midi = host->ports[p].midi_buffer;
+ lv2midi_put_event(&state, (double)ev.time, ev.size, ev.buffer);
+ }
+ }
+ }
+ }
+
+
+ /* Run plugin for this cycle */
+ slv2_instance_run(host->instance, nframes);
+
+
+ /* Deliver output */
+ for (uint32_t p=0; p < host->num_ports; ++p) {
+ if (host->ports[p].jack_port
+ && host->ports[p].type == MIDI
+ && host->ports[p].direction == OUTPUT) {
+
+ void* jack_buffer = jack_port_get_buffer(host->ports[p].jack_port, nframes);
+
+ jack_midi_clear_buffer(jack_buffer, nframes);
+
+ LV2_MIDIState state;
+ lv2midi_reset_state(&state, host->ports[p].midi_buffer, nframes);
+
+ double timestamp = 0.0f;
+ uint32_t size = 0;
+ unsigned char* data = NULL;
+
+ const uint32_t event_count = state.midi->event_count;
+
+ for (uint32_t i=0; i < event_count; ++i) {
+ lv2midi_get_event(&state, &timestamp, &size, &data);
+
+ jack_midi_event_write(jack_buffer,
+ (jack_nframes_t)timestamp, data, size, nframes);
+
+ lv2midi_increment(&state);
+ }
+
+ }
+ }
+
+ return 0;
+}
+
+
+void
+list_plugins(SLV2List list)
+{
+ for (size_t i=0; i < slv2_list_get_length(list); ++i) {
+ const SLV2Plugin* const p = slv2_list_get_plugin_by_index(list, i);
+ printf("%s\n", slv2_plugin_get_uri(p));
+ }
+}
diff --git a/examples/hosts/lv2-midifunctions.h b/examples/hosts/lv2-midifunctions.h
new file mode 100644
index 0000000..68691f3
--- /dev/null
+++ b/examples/hosts/lv2-midifunctions.h
@@ -0,0 +1,161 @@
+/****************************************************************************
+
+ lv2-midifunctions.h - support file for using MIDI in LV2 plugins
+
+ Copyright (C) 2006 Lars Luthman <lars.luthman@gmail.com>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307 USA
+
+****************************************************************************/
+
+#ifndef LV2_MIDIFUNCTIONS
+#define LV2_MIDIFUNCTIONS
+
+#include <string.h>
+
+#include "lv2-miditype.h"
+
+
+/** This structure contains information about a MIDI port buffer, the
+ current period size, and the position in the MIDI data buffer that
+ we are currently reading from or writing to. It needs to be recreated
+ or at least reinitialised every process() call. */
+typedef struct {
+
+ /** The MIDI port structure that we want to read or write. */
+ LV2_MIDI* midi;
+
+ /** The number of frames in this process cycle. */
+ uint32_t frame_count;
+
+ /** The current position in the data buffer. Should be initialised to 0. */
+ uint32_t position;
+
+} LV2_MIDIState;
+
+
+static LV2_MIDI* lv2midi_new(uint32_t capacity)
+{
+ LV2_MIDI* midi = malloc(sizeof(LV2_MIDI));
+
+ midi->event_count = 0;
+ midi->capacity = capacity;
+ midi->size = 0;
+ midi->data = malloc(sizeof(char) * capacity);
+
+ return midi;
+}
+
+
+static void lv2midi_free(LV2_MIDI* midi)
+{
+ free(midi->data);
+ free(midi);
+}
+
+
+static void lv2midi_reset_buffer(LV2_MIDI* midi)
+{
+ midi->event_count = 0;
+ midi->size = 0;
+}
+
+static void lv2midi_reset_state(LV2_MIDIState* state, LV2_MIDI* midi, uint32_t frame_count)
+{
+ state->midi = midi;
+ state->frame_count = frame_count;
+ state->position = 0;
+}
+
+
+/** This function advances the read/write position in @c state to the next
+ event and returns its timestamp, or the @c frame_count member of @c state
+ is there are no more events. */
+static double lv2midi_increment(LV2_MIDIState* state) {
+
+ if (state->position + sizeof(double) + sizeof(size_t) >= state->midi->size) {
+ state->position = state->midi->size;
+ return state->frame_count;
+ }
+
+ state->position += sizeof(double);
+ size_t size = *(size_t*)(state->midi->data + state->position);
+ state->position += sizeof(size_t);
+ state->position += size;
+
+ if (state->position >= state->midi->size)
+ return state->frame_count;
+
+ return *(double*)(state->midi->data + state->position);
+}
+
+
+/** This function reads one event from the port associated with the @c state
+ parameter and writes its timestamp, size and a pointer to its data bytes
+ into the parameters @c timestamp, @c size and @c data, respectively.
+ It does not advance the read position in the MIDI data buffer, two
+ subsequent calls to lv2midi_get_event() will read the same event.
+
+ The function returns the timestamp for the read event, or the @c frame_count
+ member of @c state if there are no more events in the buffer. */
+static double lv2midi_get_event(LV2_MIDIState* state,
+ double* timestamp,
+ uint32_t* size,
+ unsigned char** data) {
+
+ if (state->position >= state->midi->size) {
+ state->position = state->midi->size;
+ *timestamp = state->frame_count;
+ *size = 0;
+ *data = NULL;
+ return *timestamp;
+ }
+
+ *timestamp = *(double*)(state->midi->data + state->position);
+ *size = *(size_t*)(state->midi->data + state->position + sizeof(double));
+ *data = state->midi->data + state->position +
+ sizeof(double) + sizeof(size_t);
+ return *timestamp;
+}
+
+
+/** This function writes one MIDI event to the port buffer associated with
+ @c state. It returns 0 when the event was written successfully to the
+ buffer, and -1 when there was not enough room. The read/write position
+ is advanced automatically. */
+static int lv2midi_put_event(LV2_MIDIState* state,
+ double timestamp,
+ uint32_t size,
+ const unsigned char* data) {
+
+ if (state->midi->capacity - state->midi->size <
+ sizeof(double) + sizeof(size_t) + size)
+ return -1;
+
+ *(double*)(state->midi->data + state->midi->size) = timestamp;
+ state->midi->size += sizeof(double);
+ *(size_t*)(state->midi->data + state->midi->size) = size;
+ state->midi->size += sizeof(size_t);
+ memcpy(state->midi->data + state->midi->size, data, size);
+ state->midi->size += size;
+
+ ++state->midi->event_count;
+
+ return 0;
+}
+
+
+#endif
+
diff --git a/examples/hosts/lv2-miditype.h b/examples/hosts/lv2-miditype.h
new file mode 100644
index 0000000..465d5d5
--- /dev/null
+++ b/examples/hosts/lv2-miditype.h
@@ -0,0 +1,170 @@
+/****************************************************************************
+
+ lv2-miditype.h - header file for using MIDI in LV2 plugins
+
+ Copyright (C) 2006 Lars Luthman <lars.luthman@gmail.com>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307 USA
+
+****************************************************************************/
+
+#ifndef LV2_MIDITYPE_H
+#define LV2_MIDITYPE_H
+
+
+/** This data structure is used to contain the MIDI events for one run()
+ cycle. The port buffer for a LV2 port that has the datatype
+ <http://ll-plugins.nongnu.org/lv2/ext/miditype> should be a pointer
+ to an instance of this struct.
+
+ To store two Note On events on MIDI channel 0 in a buffer, with timestamps
+ 12 and 35.5, you could use something like this code (assuming that
+ midi_data is a variable of type LV2_MIDI):
+ @code
+
+ size_t buffer_offset = 0;
+ *(double*)(midi_data->data + buffer_offset) = 12;
+ buffer_offset += sizeof(double);
+ *(size_t*)(midi_data->data + buffer_offset) = 3;
+ buffer_offset += sizeof(size_t);
+ midi_data->data[buffer_offset++] = 0x90;
+ midi_data->data[buffer_offset++] = 0x48;
+ midi_data->data[buffer_offset++] = 0x64;
+ ++midi_data->event_count;
+
+ *(double*)(midi_data->data + buffer_offset) = 35.5;
+ buffer_offset += sizeof(double);
+ *(size_t*)(midi_data->data + buffer_offset) = 3;
+ buffer_offset += sizeof(size_t);
+ midi_data->data[buffer_offset++] = 0x90;
+ midi_data->data[buffer_offset++] = 0x55;
+ midi_data->data[buffer_offset++] = 0x64;
+ ++midi_data->event_count;
+
+ midi_data->size = buffer_offset;
+
+ @endcode
+
+ This would be done by the host in the case of an input port, and by the
+ plugin in the case of an output port. Whoever is writing events to the
+ buffer must also take care not to exceed the capacity of the data buffer.
+
+ To read events from a buffer, you could do something like this:
+ @code
+
+ size_t buffer_offset = 0;
+ uint32_t i;
+ for (i = 0; i < midi_data->event_count; ++i) {
+ double timestamp = *(double*)(midi_data->data + buffer_offset);
+ buffer_offset += sizeof(double);
+ size_t size = *(size_t*)(midi_data->data + buffer_offset);
+ buffer_offset += sizeof(size_t);
+ do_something_with_event(timestamp, size,
+ midi_data->data + buffer_offset);
+ buffer_offset += size;
+ }
+
+ @endcode
+*/
+typedef struct {
+
+ /** The number of MIDI events in the data buffer.
+ INPUT PORTS: It's the host's responsibility to set this field to the
+ number of MIDI events contained in the data buffer before calling the
+ plugin's run() function. The plugin may not change this field.
+ OUTPUT PORTS: It's the plugin's responsibility to set this field to the
+ number of MIDI events it has stored in the data buffer before returning
+ from the run() function. Any initial value should be ignored by the
+ plugin.
+ */
+ uint32_t event_count;
+
+ /** The size of the data buffer in bytes. It is set by the host and may not
+ be changed by the plugin. The host is allowed to change this between
+ run() calls.
+ */
+ uint32_t capacity;
+
+ /** The size of the initial part of the data buffer that actually contains
+ data.
+ INPUT PORTS: It's the host's responsibility to set this field to the
+ number of bytes used by all MIDI events it has written to the buffer
+ (including timestamps and size fields) before calling the plugin's
+ run() function. The plugin may not change this field.
+ OUTPUT PORTS: It's the plugin's responsibility to set this field to
+ the number of bytes used by all MIDI events it has written to the
+ buffer (including timestamps and size fields) before returning from
+ the run() function. Any initial value should be ignored by the plugin.
+ */
+ uint32_t size;
+
+ /** The data buffer that is used to store MIDI events. The events are packed
+ after each other, and the format of each event is as follows:
+
+ First there is a timestamp, which should have the type "double",
+ i.e. have the same bit size as a double and the same bit layout as a
+ double (whatever that is on the current platform). This timestamp gives
+ the offset from the beginning of the current cycle, in frames, that
+ the MIDI event occurs on. It must be strictly smaller than the 'nframes'
+ parameter to the current run() call. The MIDI events in the buffer must
+ be ordered by their timestamp, e.g. an event with a timestamp of 123.23
+ must be stored after an event with a timestamp of 65.0.
+
+ The second part of the event is a size field, which should have the type
+ "size_t" (as defined in the standard C header stddef.h). It should
+ contain the size of the MIDI data for this event, i.e. the number of
+ bytes used to store the actual MIDI event. The bytes used by the
+ timestamp and the size field should not be counted.
+
+ The third part of the event is the actual MIDI data. There are some
+ requirements that must be followed:
+
+ * Running status is not allowed. Every event must have its own status
+ byte.
+ * Note On events with velocity 0 are not allowed. These events are
+ equivalent to Note Off in standard MIDI streams, but in order to make
+ plugins and hosts easier to write, as well as more efficient, only
+ proper Note Off events are allowed as Note Off.
+ * "Realtime events" (status bytes 0xF8 to 0xFF) are allowed, but may not
+ occur inside other events like they are allowed to in hardware MIDI
+ streams.
+ * All events must be fully contained in a single data buffer, i.e. events
+ may not "wrap around" by storing the first few bytes in one buffer and
+ then wait for the next run() call to store the rest of the event. If
+ there isn't enough space in the current data buffer to store an event,
+ the event will either have to wait until next run() call, be ignored,
+ or compensated for in some more clever way.
+ * All events must be valid MIDI events. This means for example that
+ only the first byte in each event (the status byte) may have the eighth
+ bit set, that Note On and Note Off events are always 3 bytes long etc.
+ The MIDI writer (host or plugin) is responsible for writing valid MIDI
+ events to the buffer, and the MIDI reader (plugin or host) can assume
+ that all events are valid.
+
+ On a platform where double is 8 bytes and size_t is 4 bytes, the data
+ buffer layout for a 3-byte event followed by a 4-byte event may look
+ something like this:
+ _______________________________________________________________
+ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ...
+ |TIMESTAMP 1 |SIZE 1 |DATA |TIMESTAMP 2 |SIZE 2 |DATA | ...
+
+ */
+ unsigned char* data;
+
+} LV2_MIDI;
+
+
+
+#endif
diff --git a/examples/hosts/jack_host.c b/examples/hosts/simple_jack_host.c
index 655c939..655c939 100644
--- a/examples/hosts/jack_host.c
+++ b/examples/hosts/simple_jack_host.c