This plugin implements the Central role of MIDI over Bluetooth
Low-Energy (BLE-MIDI) 1.0 specification as published by MMA in
November/2015.
It was implmemented as a bluetoothd plugin because of latency requirements
of MIDI. There are still room for improvements on this regard.
Like previsouly mentioned, it only implements the Central role, but
since all parsing and state-machine code is in libmidi.[hc] it should be
simple to implement the Peripheral role as a GATT service as well.
I have also implemented several unit-tests that can be easily extended
without adding any code, just use-cases.
Files added:
* profiles/midi/midi.c: Actual GATT plugin
* profiles/midi/libmidi.[ch]: MIDI parsers
* unit/test-midi.c: Unit-tests
Techinal notes
==============
This plugin doesn't require any new threads. It relies on notifications
from a device to parse and render proper events that are queued in the
kernel, causing no blocks at all. Even if an error occur, it will be
handled and returned control to bluetoothd.
It also adds a new file descriptor to be read using struct io. That is
necessary to read events from applications and render raw BLE packets to
be sent to the device with a write without response command. It doesn't
block as well.
ALSA dependency was added since there is no other way of doing it,
sorry for it. :/ But this can be easily disabled with --disable-alsa
configure flag.
Even though this introduces ALSA dependency, it is not an audio plugin.
It is rather a MIDI plugin, which is a byte stream protocol with low
throughput but requires low-latency.
Observations
============
I have tested on a normal laptop Arch-linux (x86_64) and a Raspberry Pi 2
(ARM Cortex-A8) and it works very well. As I mentioned, the latency can
always be improved.
I will still maintain a personal branch on my github[1] so others can
contribute there and I can test before sending to bluez.
IMPORTAT: the timestamp support is incomplete since ALSA doesn't support the
way MIDI over BLE expects (asign timestamp to an event without scheduling).
We are working on ALSA to improve this.
Credits
=======
I would like to send kudos to ROLI Ltd. which allowed my to work
on this as part of my full-time job.
[1] https://github.com/ftonello/bluez/
---
Changes from v2:
* Removed _GNU_SOURCE (not used)
* Appended " Bluetooth" to the ALSA-Seq port name
* Changed configuration from alsa to midi (--disable-midi)
Changes from v1:
* Fixed typos in commit message
* Minor improves on the SysEx parser
Makefile.am | 13 +-
Makefile.plugins | 8 +
configure.ac | 11 ++
profiles/midi/libmidi.c | 385 ++++++++++++++++++++++++++++++++++++++
profiles/midi/libmidi.h | 140 ++++++++++++++
profiles/midi/midi.c | 489 ++++++++++++++++++++++++++++++++++++++++++++++++
unit/test-midi.c | 464 +++++++++++++++++++++++++++++++++++++++++++++
7 files changed, 1509 insertions(+), 1 deletion(-)
create mode 100644 profiles/midi/libmidi.c
create mode 100644 profiles/midi/libmidi.h
create mode 100644 profiles/midi/midi.c
create mode 100644 unit/test-midi.c
diff --git a/Makefile.am b/Makefile.am
index c469a6caf83a..b7ae2a31d671 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -147,6 +147,7 @@ gobex_sources = gobex/gobex.h gobex/gobex.c \
builtin_modules =
builtin_sources =
builtin_nodist =
+builtin_ldadd =
include Makefile.plugins
@@ -191,7 +192,8 @@ src_bluetoothd_SOURCES = $(builtin_sources) \
src_bluetoothd_LDADD = lib/libbluetooth-internal.la \
gdbus/libgdbus-internal.la \
src/libshared-glib.la \
- @BACKTRACE_LIBS@ @GLIB_LIBS@ @DBUS_LIBS@ -ldl -lrt
+ @BACKTRACE_LIBS@ @GLIB_LIBS@ @DBUS_LIBS@ -ldl -lrt \
+ $(builtin_ldadd)
src_bluetoothd_LDFLAGS = $(AM_LDFLAGS) -Wl,--export-dynamic \
-Wl,--version-script=$(srcdir)/src/bluetooth.ver
@@ -421,6 +423,15 @@ unit_test_gattrib_LDADD = lib/libbluetooth-internal.la \
src/libshared-glib.la \
@GLIB_LIBS@ @DBUS_LIBS@ -ldl -lrt
+if MIDI
+unit_tests += unit/test-midi
+unit_test_midi_SOURCES = unit/test-midi.c \
+ profiles/midi/libmidi.h \
+ profiles/midi/libmidi.c
+unit_test_midi_LDADD = src/libshared-glib.la \
+ @GLIB_LIBS@ @ALSA_LIBS@
+endif
+
if MAINTAINER_MODE
noinst_PROGRAMS += $(unit_tests)
endif
diff --git a/Makefile.plugins b/Makefile.plugins
index 59342c0cb803..3a9e27c653dd 100644
--- a/Makefile.plugins
+++ b/Makefile.plugins
@@ -95,6 +95,14 @@ builtin_sources += profiles/scanparam/scan.c
builtin_modules += deviceinfo
builtin_sources += profiles/deviceinfo/deviceinfo.c
+if MIDI
+builtin_modules += midi
+builtin_sources += profiles/midi/midi.c \
+ profiles/midi/libmidi.h \
+ profiles/midi/libmidi.c
+builtin_ldadd += @ALSA_LIBS@
+endif
+
if SIXAXIS
plugin_LTLIBRARIES += plugins/sixaxis.la
plugins_sixaxis_la_SOURCES = plugins/sixaxis.c
diff --git a/configure.ac b/configure.ac
index fe4103c19037..a0641de98c1d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -212,6 +212,17 @@ AC_ARG_ENABLE(cups, AC_HELP_STRING([--disable-cups],
[disable CUPS printer support]), [enable_cups=${enableval}])
AM_CONDITIONAL(CUPS, test "${enable_cups}" != "no")
+AC_ARG_ENABLE(midi, AC_HELP_STRING([--disable-midi],
+ [disable MIDI support]), [enable_alsa=${enableval}])
+AM_CONDITIONAL(MIDI, test "${enable_midi}" != "no")
+
+if (test "${enable_midi}" != "no"); then
+ PKG_CHECK_MODULES(ALSA, alsa, dummy=yes,
+ AC_MSG_ERROR(ALSA lib is required for MIDI support))
+ AC_SUBST(ALSA_CFLAGS)
+ AC_SUBST(ALSA_LIBS)
+fi
+
AC_ARG_ENABLE(obex, AC_HELP_STRING([--disable-obex],
[disable OBEX profile support]), [enable_obex=${enableval}])
if (test "${enable_obex}" != "no"); then
diff --git a/profiles/midi/libmidi.c b/profiles/midi/libmidi.c
new file mode 100644
index 000000000000..001444b9c700
--- /dev/null
+++ b/profiles/midi/libmidi.c
@@ -0,0 +1,385 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2015,2016 Felipe F. Tonello <[email protected]>
+ * Copyright (C) 2016 ROLI Ltd.
+ *
+ * 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 "libmidi.h"
+
+inline static void append_timestamp_high_maybe(struct midi_write_parser *parser)
+{
+ if (!midi_write_has_data(parser)) {
+ guint8 timestamp_high = 0x80;
+ parser->rtime = g_get_monotonic_time() / 1000; /* convert µs to ms */
+ timestamp_high |= (parser->rtime & 0x1F80) >> 7;
+ /* set timestampHigh */
+ g_byte_array_append(parser->midi_stream, ×tamp_high,
+ sizeof(timestamp_high));
+ }
+}
+
+inline static void append_timestamp_low(struct midi_write_parser *parser)
+{
+ const guint8 timestamp_low = 0x80 | (parser->rtime & 0x7F);
+ g_byte_array_append(parser->midi_stream, ×tamp_low,
+ sizeof(timestamp_low));
+}
+
+void midi_read_ev(struct midi_write_parser *parser, const snd_seq_event_t *ev,
+ midi_read_ev_cb write_cb, gpointer user_data)
+{
+ g_assert(write_cb);
+
+#define GET_AVAILABLE_SIZE (parser->stream_size - parser->midi_stream->len)
+
+ if (GET_AVAILABLE_SIZE == 0) {
+ write_cb(parser->midi_stream->data, parser->midi_stream->len,
+ user_data);
+ midi_write_reset(parser);
+ }
+
+ append_timestamp_high_maybe(parser);
+
+ /* SysEx is special case:
+ SysEx has two timestampLow bytes, before F0 and F7
+ */
+ if (ev->type == SND_SEQ_EVENT_SYSEX) {
+
+ unsigned int used_sysex = 0;
+
+ /* Algorithm:
+ 1) check initial timestampLow:
+ if used_sysex == 0, then tsLow = 1, else tsLow = 0
+ 2) calculate sysex size of current packet:
+ 2a) first check special case:
+ if midi->out_length - 1 (tsHigh) - tsLow ==
+ sysex_length - used_sysex
+ size is: min(midi->out_length - 1 - tsLow,
+ sysex_length - used_sysex - 1)
+ 2b) else size is: min(midi->out_length - 1 - tsLow,
+ sysex_length - used_sysex)
+ 3) check if packet contains F7: fill respective tsLow byte
+ */
+
+#define GET_SYSEX_IDX(_i) (((guint8*)ev->data.ext.ptr)[_i])
+#define GET_DATA_REVERSE_IDX(_i) (parser->midi_stream->data \
+ [parser->midi_stream->len - ((_i) + 1)])
+
+ /* We need at least 2 bytes (timestampLow + F0) */
+ if (GET_AVAILABLE_SIZE < 2) {
+ /* send current message and start new one */
+ write_cb(parser->midi_stream->data, parser->midi_stream->len,
+ user_data);
+ midi_write_reset(parser);
+ append_timestamp_high_maybe(parser);
+ }
+
+ /* timestampLow on initial F0 */
+ if (GET_SYSEX_IDX(0) == 0xF0)
+ append_timestamp_low(parser);
+
+ do {
+ unsigned int size_of_sysex;
+
+ append_timestamp_high_maybe(parser);
+
+ size_of_sysex = MIN(GET_AVAILABLE_SIZE,
+ ev->data.ext.len - used_sysex);
+
+ if (GET_AVAILABLE_SIZE == ev->data.ext.len - used_sysex)
+ size_of_sysex--;
+
+ g_byte_array_append(parser->midi_stream,
+ ev->data.ext.ptr + used_sysex,
+ size_of_sysex);
+ used_sysex += size_of_sysex;
+
+ if (GET_AVAILABLE_SIZE <= 1 && GET_DATA_REVERSE_IDX(0) != 0xF7) {
+ write_cb(parser->midi_stream->data, parser->midi_stream->len,
+ user_data);
+ midi_write_reset(parser);
+ }
+ } while (used_sysex < ev->data.ext.len);
+
+ /* check for F7 and update respective timestampLow byte */
+ if (GET_DATA_REVERSE_IDX(0) == 0xF7) {
+ guint8 tmp;
+ append_timestamp_low(parser);
+ tmp = GET_DATA_REVERSE_IDX(0);
+ GET_DATA_REVERSE_IDX(0) = 0xF7;
+ GET_DATA_REVERSE_IDX(1) = tmp;
+ }
+
+#undef GET_DATA_REVERSE_IDX
+#undef GET_SYSEX_IDX
+
+ } else {
+ int length;
+
+ /* check for running status */
+ if (parser->rstate != ev->type) {
+ snd_midi_event_reset_decode(parser->midi_ev);
+ append_timestamp_low(parser);
+ }
+
+ /* each midi message has timestampLow byte to follow */
+ length = snd_midi_event_decode(parser->midi_ev,
+ parser->midi_stream->data +
+ parser->midi_stream->len,
+ GET_AVAILABLE_SIZE,
+ ev);
+
+ if (length == -ENOMEM) {
+ /* remove previously added timestampLow */
+ g_byte_array_remove_index_fast(parser->midi_stream,
+ parser->midi_stream->len -1);
+ write_cb(parser->midi_stream->data, parser->midi_stream->len,
+ user_data);
+ /* cleanup state for next packet */
+ snd_midi_event_reset_decode(parser->midi_ev);
+ midi_write_reset(parser);
+ append_timestamp_high_maybe(parser);
+ append_timestamp_low(parser);
+ length = snd_midi_event_decode(parser->midi_ev,
+ parser->midi_stream->data +
+ parser->midi_stream->len,
+ GET_AVAILABLE_SIZE,
+ ev);
+ }
+
+ if (length > 0)
+ parser->midi_stream->len += length;
+ }
+
+ parser->rstate = ev->type;
+
+ if (GET_AVAILABLE_SIZE <= 1) {
+ write_cb(parser->midi_stream->data, parser->midi_stream->len,
+ user_data);
+ midi_write_reset(parser);
+ }
+#undef GET_AVAILABLE_SIZE
+}
+
+static void update_ev_timestamp(struct midi_read_parser *parser, snd_seq_event_t *ev,
+ guint16 ts_low)
+{
+ int delta_timestamp;
+ int delta_rtime;
+ gint64 rtime_current;
+ guint16 timestamp;
+
+ /* time_low overwflow results on time_high to increment by one */
+ if (parser->timestamp_low > ts_low)
+ parser->timestamp_high++;
+
+ timestamp = (parser->timestamp_high << 7) | parser->timestamp_low;
+
+ rtime_current = g_get_monotonic_time() / 1000; /* convert µs to ms */
+ delta_timestamp = timestamp - (int)parser->timestamp;
+ delta_rtime = rtime_current - parser->rtime;
+
+ if (delta_rtime > MIDI_MAX_TIMESTAMP)
+ parser->rtime = rtime_current;
+ else {
+
+ /* If delta_timestamp is way to big than delta_rtime,
+ this means that the device sent a message in the past,
+ so we have to compensate for this. */
+ if (delta_timestamp > 7000 && delta_rtime < 1000)
+ delta_timestamp = 0;
+
+ /* check if timestamp did overflow */
+ if (delta_timestamp < 0) {
+ /* same timestamp in the past problem */
+ if ((delta_timestamp + MIDI_MAX_TIMESTAMP) > 7000 &&
+ delta_rtime < 1000)
+ delta_timestamp = 0;
+ else
+ delta_timestamp = delta_timestamp + MIDI_MAX_TIMESTAMP;
+ }
+
+ parser->rtime += delta_timestamp;
+ }
+
+ parser->timestamp += delta_timestamp;
+ if (parser->timestamp > MIDI_MAX_TIMESTAMP)
+ parser->timestamp %= MIDI_MAX_TIMESTAMP + 1;
+
+ /* set event timestamp */
+ /* TODO: update event timestamp here! */
+}
+
+gsize midi_read_raw(struct midi_read_parser *parser, const guint8 *data,
+ gsize size, snd_seq_event_t *ev /* OUT */)
+{
+ guint8 midi_size = 0;
+ gsize i = 0;
+ gboolean err = FALSE;
+ guint8 time_low = 0;
+
+ if (parser->timestamp_high == 0)
+ parser->timestamp_high = data[i++] & 0x3F;
+
+ snd_midi_event_reset_encode(parser->midi_ev);
+
+ /* timestamp byte */
+ if (data[i] & 0x80) {
+ update_ev_timestamp(parser, ev, data[i] & 0x7F);
+
+ /* check for wrong BLE-MIDI message size */
+ if (++i == size) {
+ err = TRUE;
+ goto _finish;
+ }
+ }
+
+ /* cleanup sysex_stream if message is broken or is a new SysEx */
+ if (data[i] >= 0x80 && data[i] != 0xF7 && parser->sysex_stream->len > 0) {
+ g_byte_array_remove_range(parser->sysex_stream,
+ 0,
+ parser->sysex_stream->len);
+ }
+
+ switch (data[i]) {
+ case 0xF8 ... 0XFF:
+ /* System Real-Time Messages */
+ midi_size = 1;
+ break;
+
+ /* System Common Messages */
+ case 0xF0: /* SysEx Start */ {
+ guint8 *pos;
+
+ /* Avoid parsing if SysEx is contained in one BLE packet */
+ if ((pos = memchr(data + i, 0xF7, size - i))) {
+ const gsize sysex_length = pos - (data + i);
+
+ g_byte_array_append(parser->sysex_stream, data + i, sysex_length);
+
+ time_low = parser->sysex_stream->data[sysex_length - 1] & 0x7F;
+ /* Remove timestamp byte */
+ parser->sysex_stream->data[sysex_length - 1] = 0xF7;
+ update_ev_timestamp(parser, ev, time_low);
+ snd_seq_ev_set_sysex(ev, parser->sysex_stream->len,
+ parser->sysex_stream->data);
+
+ midi_size = sysex_length + 1; /* +1 because of timestampLow */
+ } else {
+ g_byte_array_append(parser->sysex_stream, data + i, size - i);
+ err = TRUE; /* Not an actual error, just incomplete message */
+ midi_size = size - i;
+ }
+
+ goto _finish;
+ }
+
+ case 0xF1:
+ case 0xF3:
+ midi_size = 2;
+ break;
+ case 0xF2:
+ midi_size = 3;
+ break;
+ case 0xF4:
+ case 0xF5: /* Ignore */
+ i++;
+ err = TRUE;
+ goto _finish;
+ break;
+ case 0xF6:
+ midi_size = 1;
+ break;
+ case 0xF7: /* SysEx End */
+ g_byte_array_append(parser->sysex_stream, data + i, 1);
+ snd_seq_ev_set_sysex(ev, parser->sysex_stream->len,
+ parser->sysex_stream->data);
+
+ midi_size = 1; /* timestampLow was alredy processed */
+ goto _finish;
+
+ case 0x80 ... 0xEF:
+ /*
+ * Channel Voice Messages, Channel Mode Messages
+ * and Control Change Messages.
+ */
+ parser->rstatus = data[i];
+ midi_size = (data[i] >= 0xC0 && data[i] <= 0xDF) ? 2 : 3;
+ break;
+
+ case 0x00 ... 0x7F:
+
+ /* Check for SysEx messages */
+ if (parser->sysex_stream->len > 0) {
+ guint8 *pos;
+
+ if ((pos = memchr(data + i, 0xF7, size - i))) {
+ const gsize sysex_length = pos - (data + i);
+
+ g_byte_array_append(parser->sysex_stream, data + i, sysex_length);
+
+#define GET_DATA_REVERSE_IDX(_i) (parser->sysex_stream->data \
+ [parser->sysex_stream->len - ((_i) + 1)])
+
+ time_low = GET_DATA_REVERSE_IDX(0) & 0x7F;
+ /* Remove timestamp byte */
+ GET_DATA_REVERSE_IDX(0) = 0xF7;
+ update_ev_timestamp(parser, ev, time_low);
+ snd_seq_ev_set_sysex(ev, parser->sysex_stream->len,
+ parser->sysex_stream->data);
+
+#undef GET_DATA_REVERSE_IDX
+
+ midi_size = sysex_length + 1; /* +1 because of timestampLow */
+ } else {
+ g_byte_array_append(parser->sysex_stream, data + i, size - i);
+ err = TRUE; /* Not an actual error, just incomplete message */
+ midi_size = size - i;
+ }
+
+ goto _finish;
+ }
+
+ /* Running State Message */
+ if (parser->rstatus == 0) {
+ midi_size = 1;
+ err = TRUE;
+ goto _finish;
+ }
+
+ snd_midi_event_encode_byte(parser->midi_ev, parser->rstatus, ev);
+ midi_size = (parser->rstatus >= 0xC0 && parser->rstatus <= 0xDF) ? 1 : 2;
+ break;
+ }
+
+ if ((i + midi_size) > size) {
+ err = TRUE;
+ goto _finish;
+ }
+
+ snd_midi_event_encode(parser->midi_ev, data + i, midi_size, ev);
+
+_finish:
+ if (err)
+ ev->type = SND_SEQ_EVENT_NONE;
+
+ return i + midi_size;
+}
diff --git a/profiles/midi/libmidi.h b/profiles/midi/libmidi.h
new file mode 100644
index 000000000000..cc6e13f6c44a
--- /dev/null
+++ b/profiles/midi/libmidi.h
@@ -0,0 +1,140 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2015,2016 Felipe F. Tonello <[email protected]>
+ * Copyright (C) 2016 ROLI Ltd.
+ *
+ * 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
+ *
+ *
+ */
+
+#ifndef LIBMIDI_H
+#define LIBMIDI_H
+
+#include <glib.h>
+#include <alsa/asoundlib.h>
+
+#define MIDI_MAX_TIMESTAMP 8191
+#define MIDI_MSG_MAX_SIZE 12
+#define MIDI_SYSEX_MAX_SIZE (4 * 1024)
+
+/* MIDI I/O Write parser */
+
+struct midi_write_parser {
+ gint64 rtime; /* last writer's real time */
+ snd_seq_event_type_t rstate; /* running status event type */
+ GByteArray *midi_stream; /* MIDI I/O byte stream */
+ gsize stream_size; /* what is the maximum size of the midi_stream array */
+ snd_midi_event_t *midi_ev; /* midi<->seq event */
+};
+
+static inline int midi_write_init(struct midi_write_parser *parser, gsize buffer_size)
+{
+ parser->rtime = 0;
+ parser->rstate = SND_SEQ_EVENT_NONE;
+ parser->stream_size = buffer_size;
+
+ parser->midi_stream = g_byte_array_sized_new(buffer_size);
+ if (!parser->midi_stream)
+ return -ENOMEM;
+
+ return snd_midi_event_new(buffer_size, &parser->midi_ev);
+}
+
+static inline void midi_write_free(struct midi_write_parser *parser)
+{
+ g_byte_array_free(parser->midi_stream, TRUE);
+ snd_midi_event_free(parser->midi_ev);
+}
+
+static inline void midi_write_reset(struct midi_write_parser *parser)
+{
+ parser->rstate = SND_SEQ_EVENT_NONE;
+ g_byte_array_remove_range(parser->midi_stream, 0, parser->midi_stream->len);
+}
+
+static inline gboolean midi_write_has_data(struct midi_write_parser *parser)
+{
+ return parser->midi_stream->len > 0;
+}
+
+static inline const guint8 * midi_write_data(struct midi_write_parser *parser)
+{
+ return parser->midi_stream->data;
+}
+
+static inline guint midi_write_data_size(struct midi_write_parser *parser)
+{
+ return parser->midi_stream->len;
+}
+
+typedef void (*midi_read_ev_cb)(const guint8 *, guint, gpointer);
+
+/* It creates BLE-MIDI raw packets from the a sequencer event. If the packet
+ is full, then it calls write_cb and resets its internal state as many times
+ as necessary.
+ */
+void midi_read_ev(struct midi_write_parser *parser, const snd_seq_event_t *ev,
+ midi_read_ev_cb write_cb, gpointer user_data);
+
+/* MIDI I/O Read parser */
+
+struct midi_read_parser {
+ guint8 rstatus; /* running status byte */
+ gint64 rtime; /* last reader's real time */
+ gint16 timestamp; /* last MIDI-BLE timestamp */
+ gint8 timestamp_low; /* MIDI-BLE timestampLow from the current packet */
+ gint8 timestamp_high; /* MIDI-BLE timestampHigh from the current packet */
+ GByteArray *sysex_stream; /* SysEx stream */
+ snd_midi_event_t *midi_ev; /* midi<->seq event */
+};
+
+static inline int midi_read_init(struct midi_read_parser *parser)
+{
+ parser->rstatus = 0;
+ parser->rtime = -1;
+ parser->timestamp = 0;
+ parser->timestamp_low = 0;
+ parser->timestamp_high = 0;
+
+ parser->sysex_stream = g_byte_array_sized_new(MIDI_SYSEX_MAX_SIZE);
+ if (!parser->sysex_stream)
+ return -ENOMEM;
+
+ return snd_midi_event_new(MIDI_MSG_MAX_SIZE, &parser->midi_ev);
+}
+
+static inline void midi_read_free(struct midi_read_parser *parser)
+{
+ g_byte_array_free(parser->sysex_stream, TRUE);
+ snd_midi_event_free(parser->midi_ev);
+}
+
+static inline void midi_read_reset(struct midi_read_parser *parser)
+{
+ parser->rstatus = 0;
+ parser->timestamp_low = 0;
+ parser->timestamp_high = 0;
+}
+
+/* Parses raw BLE-MIDI messages and populates a sequencer event representing the
+ current MIDI message. It returns how much raw data was processed.
+ */
+gsize midi_read_raw(struct midi_read_parser *parser, const guint8 *data, gsize size,
+ snd_seq_event_t *ev /* OUT */);
+
+#endif /* LIBMIDI_H */
diff --git a/profiles/midi/midi.c b/profiles/midi/midi.c
new file mode 100644
index 000000000000..93a3023e8ba5
--- /dev/null
+++ b/profiles/midi/midi.c
@@ -0,0 +1,489 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2015,2016 Felipe F. Tonello <[email protected]>
+ * Copyright (C) 2016 ROLI Ltd.
+ *
+ * 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
+ *
+ * Information about this plugin:
+ *
+ * This plugin implements the MIDI over Bluetooth Low-Energy (BLE-MIDI) 1.0
+ * specification as published by MMA in November/2015.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <glib.h>
+#include <alsa/asoundlib.h>
+
+#include "lib/bluetooth.h"
+#include "lib/sdp.h"
+#include "lib/uuid.h"
+
+#include "src/plugin.h"
+#include "src/adapter.h"
+#include "src/device.h"
+#include "src/profile.h"
+#include "src/service.h"
+#include "src/shared/util.h"
+#include "src/shared/att.h"
+#include "src/shared/queue.h"
+#include "src/shared/gatt-db.h"
+#include "src/shared/gatt-client.h"
+#include "src/shared/io.h"
+#include "src/log.h"
+#include "attrib/att.h"
+
+#include "libmidi.h"
+
+#define MIDI_UUID "03B80E5A-EDE8-4B33-A751-6CE34EC4C700"
+#define MIDI_IO_UUID "7772E5DB-3868-4112-A1A9-F2669D106BF3"
+
+struct midi {
+ struct btd_device *dev;
+ struct gatt_db *db;
+ struct bt_gatt_client *client;
+ guint io_cb_id;
+ struct io *io;
+ uint16_t midi_io_handle;
+
+ /* ALSA handlers */
+ snd_seq_t *seq_handle;
+ int seq_client_id;
+ int seq_port_id;
+
+ /* MIDI parser*/
+ struct midi_read_parser midi_in;
+ struct midi_write_parser midi_out;
+};
+
+static bool midi_write_cb(struct io *io, gpointer user_data)
+{
+ struct midi *midi = user_data;
+ int err;
+
+ void foreach_cb(const guint8 *data, guint size, gpointer user_data) {
+ struct midi *midi = user_data;
+ bt_gatt_client_write_without_response(midi->client,
+ midi->midi_io_handle,
+ FALSE,
+ data,
+ size);
+ };
+
+ do {
+ snd_seq_event_t *event = NULL;
+
+ err = snd_seq_event_input(midi->seq_handle, &event);
+
+ if (err < 0 || !event)
+ break;
+
+ midi_read_ev(&midi->midi_out, event, foreach_cb, midi);
+
+ } while (err > 0);
+
+ if (midi_write_has_data(&midi->midi_out))
+ bt_gatt_client_write_without_response(midi->client,
+ midi->midi_io_handle,
+ FALSE,
+ midi_write_data(&midi->midi_out),
+ midi_write_data_size(&midi->midi_out));
+
+ midi_write_reset(&midi->midi_out);
+
+ return TRUE;
+}
+
+static void midi_io_value_cb(uint16_t value_handle, const uint8_t *value,
+ uint16_t length, gpointer user_data)
+{
+ struct midi *midi = user_data;
+ snd_seq_event_t ev;
+ guint i = 0;
+
+ if (length < 3) {
+ warn("MIDI I/O: Wrong packet format: length is %u bytes but it should "
+ "be at least 3 bytes", length);
+ return;
+ }
+
+ snd_seq_ev_clear(&ev);
+ snd_seq_ev_set_source(&ev, midi->seq_port_id);
+ snd_seq_ev_set_subs(&ev);
+ snd_seq_ev_set_direct(&ev);
+
+ midi_read_reset(&midi->midi_in);
+
+ while (i < length) {
+ gsize count = midi_read_raw(&midi->midi_in, value + i, length - i, &ev);
+
+ if (count == 0)
+ goto _err;
+
+ if (ev.type != SND_SEQ_EVENT_NONE)
+ snd_seq_event_output_direct(midi->seq_handle, &ev);
+
+ i += count;
+ }
+
+ return;
+
+_err:
+ error("Wrong BLE-MIDI message");
+}
+
+static void midi_io_ccc_written_cb(uint16_t att_ecode, gpointer user_data)
+{
+ if (att_ecode != 0) {
+ error("MIDI I/O: notifications not enabled %s",
+ att_ecode2str(att_ecode));
+ return;
+ }
+
+ DBG("MIDI I/O: notification enabled");
+}
+
+static void midi_io_initial_read_cb(bool success, uint8_t att_ecode,
+ const uint8_t *value, uint16_t length,
+ gpointer user_data)
+{
+ struct midi *midi = user_data;
+
+ if (!success) {
+ error("MIDI I/O: Failed to read initial request");
+ return;
+ }
+
+ /* request notify */
+ midi->io_cb_id =
+ bt_gatt_client_register_notify(midi->client,
+ midi->midi_io_handle,
+ midi_io_ccc_written_cb,
+ midi_io_value_cb,
+ midi,
+ NULL);
+}
+
+static void handle_midi_io(struct midi *midi, uint16_t value_handle)
+{
+ DBG("MIDI I/O handle: 0x%04x", value_handle);
+
+ midi->midi_io_handle = value_handle;
+
+ /*
+ * The BLE-MIDI 1.0 spec specifies that The Central shall attempt to
+ * read the MIDI I/O characteristic of the Peripheral right after
+ * estrablhishing a connection with the accessory.
+ */
+ if (!bt_gatt_client_read_value(midi->client,
+ value_handle,
+ midi_io_initial_read_cb,
+ midi,
+ NULL))
+ DBG("MIDI I/O: Failed to send request to read initial value");
+}
+
+static void handle_characteristic(struct gatt_db_attribute *attr,
+ gpointer user_data)
+{
+ struct midi *midi = user_data;
+ uint16_t value_handle;
+ bt_uuid_t uuid, midi_io_uuid;
+
+ if (!gatt_db_attribute_get_char_data(attr, NULL, &value_handle, NULL,
+ NULL, &uuid)) {
+ error("Failed to obtain characteristic data");
+ return;
+ }
+
+ bt_string_to_uuid(&midi_io_uuid, MIDI_IO_UUID);
+
+ if (bt_uuid_cmp(&midi_io_uuid, &uuid) == 0)
+ handle_midi_io(midi, value_handle);
+ else {
+ char uuid_str[MAX_LEN_UUID_STR];
+
+ bt_uuid_to_string(&uuid, uuid_str, sizeof(uuid_str));
+ DBG("Unsupported characteristic: %s", uuid_str);
+ }
+}
+
+static void foreach_midi_service(struct gatt_db_attribute *attr,
+ gpointer user_data)
+{
+ struct midi *midi = user_data;
+
+ gatt_db_service_foreach_char(attr, handle_characteristic, midi);
+}
+
+static int midi_device_probe(struct btd_service *service)
+{
+ struct btd_device *device = btd_service_get_device(service);
+ struct midi *midi;
+ char addr[18];
+
+ ba2str(device_get_address(device), addr);
+ DBG("MIDI GATT Driver profile probe (%s)", addr);
+
+ /* Ignore, if we were probed for this device already */
+ midi = btd_service_get_user_data(service);
+ if (midi) {
+ error("Profile probed twice for the same device!");
+ return -EADDRINUSE;
+ }
+
+ midi = g_new0(struct midi, 1);
+ if (!midi)
+ return -ENOMEM;
+
+ midi->dev = btd_device_ref(device);
+
+ btd_service_set_user_data(service, midi);
+
+ return 0;
+}
+
+static void midi_device_remove(struct btd_service *service)
+{
+ struct btd_device *device = btd_service_get_device(service);
+ struct midi *midi;
+ char addr[18];
+
+ ba2str(device_get_address(device), addr);
+ DBG("MIDI GATT Driver profile remove (%s)", addr);
+
+ midi = btd_service_get_user_data(service);
+ if (!midi) {
+ error("MIDI Service not handled by profile");
+ return;
+ }
+
+ btd_device_unref(midi->dev);
+ g_free(midi);
+}
+
+static int midi_accept(struct btd_service *service)
+{
+ struct btd_device *device = btd_service_get_device(service);
+ struct gatt_db *db = btd_device_get_gatt_db(device);
+ struct bt_gatt_client *client = btd_device_get_gatt_client(device);
+ bt_uuid_t midi_uuid;
+ struct pollfd pfd;
+ struct midi *midi;
+ char addr[18];
+ char device_name[MAX_NAME_LENGTH + 11]; /* 11 = " Bluetooth\0"*/
+ int err;
+ snd_seq_client_info_t *info;
+
+ ba2str(device_get_address(device), addr);
+ DBG("MIDI GATT Driver profile accept (%s)", addr);
+
+ midi = btd_service_get_user_data(service);
+ if (!midi) {
+ error("MIDI Service not handled by profile");
+ return -ENODEV;
+ }
+
+ /* Port Name */
+ memset(device_name, 0, sizeof(device_name));
+ if (device_name_known(device))
+ device_get_name(device, device_name, sizeof(device_name));
+ else
+ strncpy(device_name, addr, sizeof(addr));
+
+ /* ALSA Sequencer Client and Port Setup */
+ err = snd_seq_open(&midi->seq_handle, "default", SND_SEQ_OPEN_DUPLEX, 0);
+ if (err < 0) {
+ error("Could not open ALSA Sequencer: %s (%d)", snd_strerror(err), err);
+ return err;
+ }
+
+ err = snd_seq_nonblock(midi->seq_handle, SND_SEQ_NONBLOCK);
+ if (err < 0) {
+ error("Could not set nonblock mode: %s (%d)", snd_strerror(err), err);
+ goto _err_handle;
+ }
+
+ err = snd_seq_set_client_name(midi->seq_handle, device_name);
+ if (err < 0) {
+ error("Could not configure ALSA client: %s (%d)", snd_strerror(err), err);
+ goto _err_handle;
+ }
+
+ err = snd_seq_client_id(midi->seq_handle);
+ if (err < 0) {
+ error("Could retreive ALSA client: %s (%d)", snd_strerror(err), err);
+ goto _err_handle;
+ }
+ midi->seq_client_id = err;
+
+ err = snd_seq_create_simple_port(midi->seq_handle, strcat(device_name, " Bluetooth"),
+ SND_SEQ_PORT_CAP_READ |
+ SND_SEQ_PORT_CAP_WRITE |
+ SND_SEQ_PORT_CAP_SUBS_READ |
+ SND_SEQ_PORT_CAP_SUBS_WRITE,
+ SND_SEQ_PORT_TYPE_MIDI_GENERIC |
+ SND_SEQ_PORT_TYPE_HARDWARE);
+ if (err < 0) {
+ error("Could not create ALSA port: %s (%d)", snd_strerror(err), err);
+ goto _err_handle;
+ }
+ midi->seq_port_id = err;
+
+ snd_seq_client_info_alloca(&info);
+ err = snd_seq_get_client_info(midi->seq_handle, info);
+ if (err < 0)
+ goto _err_port;
+
+ /* list of relevant sequencer events */
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_NOTEOFF);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_NOTEON);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_KEYPRESS);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_CONTROLLER);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_PGMCHANGE);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_CHANPRESS);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_PITCHBEND);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_SYSEX);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_QFRAME);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_SONGPOS);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_SONGSEL);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_TUNE_REQUEST);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_CLOCK);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_START);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_CONTINUE);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_STOP);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_SENSING);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_RESET);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_CONTROL14);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_NONREGPARAM);
+ snd_seq_client_info_event_filter_add(info, SND_SEQ_EVENT_REGPARAM);
+
+ err = snd_seq_set_client_info(midi->seq_handle, info);
+ if (err < 0)
+ goto _err_port;
+
+
+ /* Input file descriptors */
+ snd_seq_poll_descriptors(midi->seq_handle, &pfd, 1, POLLIN);
+
+ midi->io = io_new(pfd.fd);
+ if (!midi->io) {
+ error("Could not allocate I/O eventloop");
+ goto _err_port;
+ }
+
+ io_set_read_handler(midi->io, midi_write_cb, midi, NULL);
+
+ midi->db = gatt_db_ref(db);
+ midi->client = bt_gatt_client_ref(client);
+
+ err = midi_read_init(&midi->midi_in);
+ if (err < 0) {
+ error("Could not initialise MIDI input parser");
+ goto _err_port;
+ }
+
+ err = midi_write_init(&midi->midi_out, bt_gatt_client_get_mtu(midi->client) - 3);
+ if (err < 0) {
+ error("Could not initialise MIDI output parser");
+ goto _err_midi;
+ }
+
+ bt_string_to_uuid(&midi_uuid, MIDI_UUID);
+ gatt_db_foreach_service(db, &midi_uuid, foreach_midi_service, midi);
+
+ btd_service_connecting_complete(service, 0);
+
+ return 0;
+
+_err_midi:
+ midi_read_free(&midi->midi_in);
+
+_err_port:
+ snd_seq_delete_simple_port(midi->seq_handle, midi->seq_port_id);
+
+_err_handle:
+ snd_seq_close(midi->seq_handle);
+ midi->seq_handle = NULL;
+
+ return err;
+}
+
+static int midi_disconnect(struct btd_service *service)
+{
+ struct btd_device *device = btd_service_get_device(service);
+ struct midi *midi;
+ char addr[18];
+
+ ba2str(device_get_address(device), addr);
+ DBG("MIDI GATT Driver profile disconnect (%s)", addr);
+
+ midi = btd_service_get_user_data(service);
+ if (!midi) {
+ error("MIDI Service not handled by profile");
+ return -ENODEV;
+ }
+
+ midi_read_free(&midi->midi_in);
+ midi_write_free(&midi->midi_out);
+ io_destroy(midi->io);
+ snd_seq_delete_simple_port(midi->seq_handle, midi->seq_port_id);
+ midi->seq_port_id = 0;
+ snd_seq_close(midi->seq_handle);
+ midi->seq_handle = NULL;
+
+ /* Clean-up any old client/db */
+ bt_gatt_client_unregister_notify(midi->client, midi->io_cb_id);
+ bt_gatt_client_unref(midi->client);
+ gatt_db_unref(midi->db);
+
+ btd_service_disconnecting_complete(service, 0);
+
+ return 0;
+}
+
+static struct btd_profile midi_profile = {
+ .name = "MIDI GATT Driver",
+ .remote_uuid = MIDI_UUID,
+ .priority = BTD_PROFILE_PRIORITY_HIGH,
+ .auto_connect = TRUE,
+
+ .device_probe = midi_device_probe,
+ .device_remove = midi_device_remove,
+
+ .accept = midi_accept,
+
+ .disconnect = midi_disconnect,
+};
+
+static int midi_init(void)
+{
+ return btd_profile_register(&midi_profile);
+}
+
+static void midi_exit(void)
+{
+ btd_profile_unregister(&midi_profile);
+}
+
+BLUETOOTH_PLUGIN_DEFINE(midi, VERSION, BLUETOOTH_PLUGIN_PRIORITY_HIGH,
+ midi_init, midi_exit);
diff --git a/unit/test-midi.c b/unit/test-midi.c
new file mode 100644
index 000000000000..f786c767d7df
--- /dev/null
+++ b/unit/test-midi.c
@@ -0,0 +1,464 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2015,2016 Felipe F. Tonello <[email protected]>
+ * Copyright (C) 2016 ROLI Ltd.
+ *
+ * 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
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define NUM_WRITE_TESTS 10
+
+#include "src/shared/tester.h"
+#include "profiles/midi/libmidi.h"
+
+struct ble_midi_packet {
+ const guint8 *data;
+ gsize size;
+};
+
+#define BLE_MIDI_PACKET_INIT(_packet) \
+ { \
+ .data = _packet, \
+ .size = sizeof(_packet), \
+ }
+
+struct midi_read_test {
+ const struct ble_midi_packet *ble_packet;
+ gsize ble_packet_size;
+ const snd_seq_event_t *event;
+ gsize event_size;
+};
+
+#define BLE_READ_TEST_INIT(_ble_packet, _event) \
+ { \
+ .ble_packet = _ble_packet, \
+ .ble_packet_size = G_N_ELEMENTS(_ble_packet), \
+ .event = _event, \
+ .event_size = G_N_ELEMENTS(_event), \
+ }
+
+struct midi_write_test {
+ const snd_seq_event_t *event;
+ gsize event_size;
+};
+
+#define BLE_WRITE_TEST_INIT(_event) \
+ { \
+ .event = _event, \
+ .event_size = G_N_ELEMENTS(_event), \
+ }
+
+
+#define NOTE_EVENT(_event, _channel, _note, _velocity) \
+ { \
+ .type = SND_SEQ_EVENT_##_event, \
+ .data = { \
+ .note = { \
+ .channel = (_channel), \
+ .note = (_note), \
+ .velocity = (_velocity), \
+ }, \
+ }, \
+ }
+
+#define CONTROL_EVENT(_event, _channel, _value, _param) \
+ { \
+ .type = SND_SEQ_EVENT_##_event, \
+ .data = { \
+ .control = { \
+ .channel = (_channel), \
+ .value = (_value), \
+ .param = (_param), \
+ }, \
+ }, \
+ }
+
+#define SYSEX_EVENT(_message) \
+ { \
+ .type = SND_SEQ_EVENT_SYSEX, \
+ .data = { \
+ .ext = { \
+ .ptr = (void *)_message, \
+ .len = sizeof(_message), \
+ }, \
+ }, \
+ }
+
+/* Multiple messages in one packet */
+static const guint8 packet1_1[] = {
+ 0xa6, 0x88, 0xe8, 0x00, 0x40, 0x88, 0xb8, 0x4a,
+ 0x3f, 0x88, 0x98, 0x3e, 0x0e
+};
+
+/* Several one message per packet */
+static const guint8 packet1_2[] = {
+ 0xa6, 0xaa, 0xd8, 0x71
+};
+
+static const guint8 packet1_3[] = {
+ 0xa6, 0xb7, 0xb8, 0x4a, 0x43
+};
+
+/* This message contains a running status message */
+static const guint8 packet1_4[] = {
+ 0xa6, 0xc4, 0xe8, 0x7e, 0x3f, 0x7d, 0x3f, 0xc4,
+ 0x7c, 0x3f
+};
+
+/* This message contain a running status message misplaced */
+static const guint8 packet1_5[] = {
+ 0xa6, 0xd9, 0x3e, 0x00, 0x88, 0x3e, 0x00
+};
+
+static const struct ble_midi_packet packet1[] = {
+ BLE_MIDI_PACKET_INIT(packet1_1),
+ BLE_MIDI_PACKET_INIT(packet1_2),
+ BLE_MIDI_PACKET_INIT(packet1_3),
+ BLE_MIDI_PACKET_INIT(packet1_4),
+ BLE_MIDI_PACKET_INIT(packet1_5),
+};
+
+static const snd_seq_event_t event1[] = {
+ CONTROL_EVENT(PITCHBEND, 8, 0, 0), /* Pitch Bend */
+ CONTROL_EVENT(CONTROLLER, 8, 63, 74), /* Control Change */
+ NOTE_EVENT(NOTEON, 8, 62, 14), /* Note On */
+ CONTROL_EVENT(CHANPRESS, 8, 113, 0), /* Channel Aftertouch */
+ CONTROL_EVENT(CONTROLLER, 8, 67, 74), /* Control Change*/
+ CONTROL_EVENT(PITCHBEND, 8, -2, 0), /* Pitch Bend */
+ CONTROL_EVENT(PITCHBEND, 8, -3, 0), /* Pitch Bend */
+ CONTROL_EVENT(PITCHBEND, 8, -4, 0), /* Pitch Bend */
+ NOTE_EVENT(NOTEOFF, 8, 62, 0), /* Note Off */
+};
+
+static const struct midi_read_test midi1 = BLE_READ_TEST_INIT(packet1, event1);
+
+/* Basic SysEx in one packet */
+static const guint8 packet2_1[] = {
+ 0xa6, 0xda, 0xf0, 0x01, 0x02, 0x03, 0xda, 0xf7
+};
+
+/* SysEx across two packets */
+static const guint8 packet2_2[] = {
+ 0xa6, 0xda, 0xf0, 0x01, 0x02, 0x03, 0x04, 0x05
+};
+
+static const guint8 packet2_3[] = {
+ 0xa6, 0x06, 0x07, 0x08, 0x09, 0x0a, 0xdb, 0xf7
+};
+
+/* SysEx across multiple packets */
+static const guint8 packet2_4[] = {
+ 0xa6, 0xda, 0xf0, 0x01, 0x02, 0x03, 0x04, 0x05
+};
+
+static const guint8 packet2_5[] = {
+ 0xa6, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c
+};
+static const guint8 packet2_6[] = {
+ 0xa6, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
+};
+
+static const guint8 packet2_7[] = {
+ 0xa6, 0x14, 0x15, 0x16, 0x17, 0x18, 0xdb, 0xf7
+};
+
+/* Two SysEx interleaved in two packets */
+static const guint8 packet2_8[] = {
+ 0xa6, 0xda, 0xf0, 0x01, 0x02, 0x03, 0xda, 0xf7,
+ 0xda, 0xf0
+};
+
+static const guint8 packet2_9[] = {
+ 0xa6, 0x06, 0x07, 0x08, 0x09, 0x0a, 0xdb, 0xf7
+};
+
+
+static const struct ble_midi_packet packet2[] = {
+ BLE_MIDI_PACKET_INIT(packet2_1),
+ BLE_MIDI_PACKET_INIT(packet2_2),
+ BLE_MIDI_PACKET_INIT(packet2_3),
+ BLE_MIDI_PACKET_INIT(packet2_4),
+ BLE_MIDI_PACKET_INIT(packet2_5),
+ BLE_MIDI_PACKET_INIT(packet2_6),
+ BLE_MIDI_PACKET_INIT(packet2_7),
+ BLE_MIDI_PACKET_INIT(packet2_8),
+ BLE_MIDI_PACKET_INIT(packet2_9),
+};
+
+static const guint8 sysex2_1[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0xf7
+};
+
+static const guint8 sysex2_2[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0xf7
+};
+
+static const guint8 sysex2_3[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0xf7
+};
+
+static const guint8 sysex2_4[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0xf7
+};
+
+static const guint8 sysex2_5[] = {
+ 0xf0, 0x06, 0x07, 0x08, 0x09, 0x0a, 0xf7
+};
+
+static const snd_seq_event_t event2[] = {
+ SYSEX_EVENT(sysex2_1),
+ SYSEX_EVENT(sysex2_2),
+ SYSEX_EVENT(sysex2_3),
+ SYSEX_EVENT(sysex2_4),
+ SYSEX_EVENT(sysex2_5),
+};
+
+static const struct midi_read_test midi2 = BLE_READ_TEST_INIT(packet2, event2);
+
+static void compare_events(const snd_seq_event_t *ev1,
+ const snd_seq_event_t *ev2)
+{
+ g_assert_cmpint(ev1->type, ==, ev2->type);
+
+ switch (ev1->type) {
+ case SND_SEQ_EVENT_NOTEON:
+ case SND_SEQ_EVENT_NOTEOFF:
+ case SND_SEQ_EVENT_KEYPRESS:
+ g_assert_cmpint(ev1->data.note.channel,
+ ==,
+ ev2->data.note.channel);
+ g_assert_cmpint(ev1->data.note.note,
+ ==,
+ ev2->data.note.note);
+ g_assert_cmpint(ev1->data.note.velocity,
+ ==,
+ ev2->data.note.velocity);
+ break;
+ case SND_SEQ_EVENT_CONTROLLER:
+ g_assert_cmpint(ev1->data.control.param,
+ ==,
+ ev2->data.control.param);
+ case SND_SEQ_EVENT_PITCHBEND:
+ case SND_SEQ_EVENT_CHANPRESS:
+ case SND_SEQ_EVENT_PGMCHANGE:
+ g_assert_cmpint(ev1->data.control.channel,
+ ==,
+ ev2->data.control.channel);
+ g_assert_cmpint(ev1->data.control.value,
+ ==,
+ ev2->data.control.value);
+ break;
+ case SND_SEQ_EVENT_SYSEX:
+ g_assert_cmpmem(ev1->data.ext.ptr, ev1->data.ext.len,
+ ev2->data.ext.ptr, ev2->data.ext.len);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+}
+
+static void test_midi_reader(gconstpointer data)
+{
+ const struct midi_read_test *midi_test = data;
+ struct midi_read_parser midi;
+ int err;
+ gsize i; /* ble_packet counter */
+ gsize j; /* ble_packet length counter */
+ gsize k = 0; /* event counter */
+
+ err = midi_read_init(&midi);
+ g_assert_cmpint(err, ==, 0);
+
+ for (i = 0; i < midi_test->ble_packet_size; i++) {
+ const gsize length = midi_test->ble_packet[i].size;
+ j = 0;
+ midi_read_reset(&midi);
+ while (j < length) {
+ snd_seq_event_t ev;
+ const snd_seq_event_t *ev_expect = &midi_test->event[k];
+ gsize count;
+
+ g_assert_cmpint(k, <, midi_test->event_size);
+
+ snd_seq_ev_clear(&ev);
+
+ count = midi_read_raw(&midi,
+ midi_test->ble_packet[i].data + j,
+ length - j,
+ &ev);
+
+ g_assert_cmpuint(count, >, 0);
+
+ if (ev.type == SND_SEQ_EVENT_NONE)
+ goto _continue_loop;
+ else
+ k++;
+
+ compare_events(ev_expect, &ev);
+
+ _continue_loop:
+ j += count;
+ }
+ }
+
+ midi_read_free(&midi);
+
+ tester_test_passed();
+}
+
+static const snd_seq_event_t event3[] = {
+ CONTROL_EVENT(PITCHBEND, 8, 0, 0), /* Pitch Bend */
+ CONTROL_EVENT(CONTROLLER, 8, 63, 74), /* Control Change */
+ NOTE_EVENT(NOTEON, 8, 62, 14), /* Note On */
+ CONTROL_EVENT(CHANPRESS, 8, 113, 0), /* Channel Aftertouch */
+ CONTROL_EVENT(CONTROLLER, 8, 67, 74), /* Control Change*/
+ CONTROL_EVENT(PITCHBEND, 8, -2, 0), /* Pitch Bend */
+ CONTROL_EVENT(PITCHBEND, 8, -3, 0), /* Pitch Bend */
+ CONTROL_EVENT(PITCHBEND, 8, -4, 0), /* Pitch Bend */
+ NOTE_EVENT(NOTEOFF, 8, 62, 0), /* Note Off */
+};
+
+static const struct midi_write_test midi3 = BLE_WRITE_TEST_INIT(event3);
+
+static const guint8 sysex4_1[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0xf7
+};
+
+static const guint8 sysex4_2[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0xf7
+};
+
+static const guint8 sysex4_3[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0xf7
+};
+
+static const guint8 sysex4_4[] = {
+ 0xf0, 0x01, 0x02, 0x03, 0xf7
+};
+
+static const guint8 sysex4_5[] = {
+ 0xf0, 0x06, 0x07, 0x08, 0x09, 0x0a, 0xf7
+};
+
+static const snd_seq_event_t event4[] = {
+ SYSEX_EVENT(sysex4_1),
+ SYSEX_EVENT(sysex4_2),
+ SYSEX_EVENT(sysex4_3),
+ SYSEX_EVENT(sysex4_4),
+ SYSEX_EVENT(sysex4_5),
+};
+
+static const struct midi_write_test midi4 = BLE_WRITE_TEST_INIT(event4);
+
+static void test_midi_writer(gconstpointer data)
+{
+ const struct midi_write_test *midi_test = data;
+ struct midi_write_parser midi_out;
+ struct midi_read_parser midi_in;
+ gsize i; /* event counter */
+ gsize j; /* test counter */
+ static struct midi_data {
+ gsize events_tested;
+ const struct midi_write_test *midi_test;
+ struct midi_read_parser *midi_in;
+ } midi_data;
+
+ void compare_events_cb(const guint8 *data, guint size, gpointer user_data) {
+ struct midi_data *midi_data = user_data;
+ const struct midi_write_test *midi_test = midi_data->midi_test;
+ struct midi_read_parser *midi_in = midi_data->midi_in;
+ gsize i = 0;
+
+ midi_read_reset(midi_in);
+
+ while (i < size) {
+ snd_seq_event_t ev;
+ gsize count;
+
+ snd_seq_ev_clear(&ev);
+
+ count = midi_read_raw(midi_in, data + i,
+ size - i, &ev);
+
+ g_assert_cmpuint(count, >, 0);
+
+ if (ev.type != SND_SEQ_EVENT_NONE){
+ g_assert_cmpint(midi_data->events_tested,
+ <,
+ midi_test->event_size);
+ compare_events(&midi_test->event[midi_data->events_tested],
+ &ev);
+ midi_data->events_tested++;
+ }
+
+ i += count;
+ }
+ };
+
+ midi_read_init(&midi_in);
+
+ for (j = 0; j < NUM_WRITE_TESTS; j++) {
+
+ /* Range of test for different MTU sizes. The spec specifies
+ sizes of packet as MTU - 3 */
+ midi_write_init(&midi_out, g_random_int_range(5, 40));
+
+ midi_data.events_tested = 0;
+ midi_data.midi_test = midi_test;
+ midi_data.midi_in = &midi_in;
+
+ for (i = 0; i < midi_test->event_size; i++)
+ midi_read_ev(&midi_out, &midi_test->event[i],
+ compare_events_cb, &midi_data);
+
+ if (midi_write_has_data(&midi_out))
+ compare_events_cb(midi_write_data(&midi_out),
+ midi_write_data_size(&midi_out),
+ &midi_data);
+
+ midi_write_free(&midi_out);
+ }
+ midi_read_free(&midi_in);
+
+ tester_test_passed();
+}
+
+int main(int argc, char *argv[])
+{
+ tester_init(&argc, &argv);
+
+ tester_add("/midi/1", &midi1, NULL, test_midi_reader, NULL);
+ tester_add("/midi/2", &midi2, NULL, test_midi_reader, NULL);
+ tester_add("/midi/3", &midi3, NULL, test_midi_writer, NULL);
+ tester_add("/midi/4", &midi4, NULL, test_midi_writer, NULL);
+
+ return tester_run();
+}
--
2.10.2