diff options
Diffstat (limited to 'examples')
| -rw-r--r-- | examples/hosts/Makefile.am | 31 | ||||
| -rw-r--r-- | examples/hosts/host.c | 341 | ||||
| -rw-r--r-- | examples/hosts/lv2-midifunctions.h | 161 | ||||
| -rw-r--r-- | examples/hosts/lv2-miditype.h | 170 | ||||
| -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, ×tamp, &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 |