initial commit. linux-only for now

Author: briansorahan

mem.c

@@ -0,0 +1,38 @@
+// +build cgo
+#include <assert.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "mem.h"
+
+void *midi_mem_alloc(long nbytes, const char *file, int line) {
+    void *p;
+    assert(nbytes > 0);
+    p = malloc(nbytes);
+    // crash if oom
+    assert(p != NULL);
+    return p;
+}
+
+void *midi_mem_calloc(int count, long nbytes, const char *file, int line) {
+    void *p;
+    assert(count > 0);
+    assert(nbytes > 0);
+    p = calloc(count, nbytes);
+    assert(p != NULL);
+    return p;
+}
+
+void midi_mem_free(void * ptr, const char *file, int line) {
+    if (ptr)
+        free(ptr);
+}
+
+void *midi_mem_resize(void *ptr, long nbytes, const char *file, int line) {
+    assert(ptr);
+    assert(nbytes > 0);
+    ptr = realloc(ptr, nbytes);
+    assert(ptr != NULL);
+    return ptr;
+}
+

mem.h

@@ -0,0 +1,17 @@
+#ifndef MEM_H_INCLUDED
+#define MEM_H_INCLUDED
+
+extern void *midi_mem_alloc(long nbytes, const char * file, int line);
+extern void *midi_mem_calloc(int count, long nbytes, const char * file, int line);
+extern void  midi_mem_free(void *ptr, const char *file, int line);
+extern void *midi_mem_resize(void *ptr, long nbytes, const char *file, int line);
+
+#define ALLOC(nbytes)         midi_mem_alloc((nbytes), __FILE__, __LINE__)
+#define CALLOC(count, nbytes) midi_mem_calloc((count), (nbytes), __FILE__, __LINE__)
+
+#define NEW(p) ((p) = ALLOC((long) sizeof *(p)))
+#define NEW0(p) ((p) = CALLOC(1, (long) sizeof *(p)))
+#define FREE(p) ((void) (midi_mem_free((p), __FILE__, __LINE__), (p) = 0))
+#define RESIZE(p, nbytes) ((p) = midi_mem_resize((p), (nbytes), __FILE__, __LINE__))
+
+#endif // MEM_H_INCLUDED

midi.go

@@ -0,0 +1,38 @@
+// Package midi is a self-contained (i.e. doesn't depend on a C library)
+// package for talking to midi devices in Go.
+package midi
+
+// #include <stddef.h>
+// #include <stdlib.h>
+// #include "midi.h"
+// #cgo linux LDFLAGS: -lasound
+import "C"
+
+// Midi provides an interface for raw MIDI devices.
+type Midi struct {
+	conn C.Midi
+	buf  []byte
+}
+
+// Open opens a MIDI device.
+func Open(device string) (*Midi, error) {
+	conn := C.Midi_open(C.CString(device))
+	return &Midi{conn: conn}, nil
+}
+
+// Close closes the MIDI connection.
+func (midi *Midi) Close() error {
+	return nil
+}
+
+// Read reads data from a MIDI device.
+func (midi *Midi) Read(buf []byte) (int, error) {
+	n, err := C.Midi_read(midi.conn, C.CString(string(buf)), C.size_t(len(buf)))
+	return int(n), err
+}
+
+// Write writes data to a MIDI device.
+func (midi *Midi) Write(buf []byte) (int, error) {
+	n, err := C.Midi_write(midi.conn, C.CString(string(buf)), C.size_t(len(buf)))
+	return int(n), err
+}

midi.h

@@ -0,0 +1,23 @@
+// +build cgo
+#ifndef MIDI_H
+#define MIDI_H
+
+#include <stddef.h>
+#include <stdlib.h>
+
+// Midi represents a connection to a MIDI device.
+typedef struct Midi *Midi;
+
+// Midi_open opens a MIDI connection to the specified device.
+Midi Midi_open(const char *device_name);
+
+// Midi_read reads bytes from the provided MIDI connection.
+ssize_t Midi_read(Midi midi, char *buffer, size_t buffer_size);
+
+// Midi_write writes bytes to the provided MIDI connection.
+ssize_t Midi_write(Midi midi, const char *buffer, size_t buffer_size);
+
+// Midi_close closes a MIDI connection.
+int Midi_close(Midi midi);
+
+#endif

midi_linux.c

@@ -0,0 +1,58 @@
+// +build cgo
+#include <assert.h>
+#include <errno.h>
+#include <stddef.h>
+
+#include <alsa/asoundlib.h>
+
+#include "mem.h"
+#include "midi.h"
+
+// Midi represents a MIDI connection that uses the ALSA RawMidi API.
+struct Midi {
+	snd_rawmidi_t *in;
+	snd_rawmidi_t *out;
+};
+
+// Midi_open opens a MIDI connection to the specified device.
+// If there is an error it returns NULL.
+Midi Midi_open(const char *device_name) {
+	Midi midi;
+	int rc;
+	NEW(midi);
+	rc = snd_rawmidi_open(&midi->in, &midi->out, device_name, SND_RAWMIDI_SYNC);
+	errno = rc; // Not sure if the rawmidi return codes map to errno values.
+	if (rc != 0) return NULL;
+	return midi;
+}
+
+// Midi_read reads bytes from the provided MIDI connection.
+ssize_t Midi_read(Midi midi, char *buffer, size_t buffer_size) {
+	assert(midi);
+	assert(midi->in);
+	return snd_rawmidi_read(midi->in, (void *) buffer, buffer_size);
+}
+
+// Midi_write writes bytes to the provided MIDI connection.
+ssize_t Midi_write(Midi midi, const char *buffer, size_t buffer_size) {
+	assert(midi);
+	assert(midi->out);
+	return snd_rawmidi_write(midi->out, (void *) buffer, buffer_size);
+}
+
+// Midi_close closes a MIDI connection.
+int Midi_close(Midi midi) {
+	assert(midi);
+	assert(midi->in);
+	assert(midi->out);
+	
+	int inrc, outrc;
+	
+	inrc = snd_rawmidi_close(midi->in);
+	outrc = snd_rawmidi_close(midi->out);
+
+	if (inrc != 0) {
+		return inrc;
+	}
+	return outrc;
+}

midi_linux_test.go

@@ -0,0 +1,39 @@
+package midi
+
+import (
+	"testing"
+	"time"
+)
+
+func TestLaunchpad(t *testing.T) {
+	// This test can be run if you have a MIDI device with ID "hw:1,0,0"
+	// It will tell you if this package is able to talk to your device.
+	// The messages that are sent here are specific to the Novation Launchpad Mini.
+	// The reason this package exists is because of issues that popped up when
+	// trying to use github.com/rakyll/portmidi to talk to the launchpad on Linux.
+	// For the launchpad MIDI reference, see https://d19ulaff0trnck.cloudfront.net/sites/default/files/novation/downloads/4080/launchpad-programmers-reference.pdf
+	// t.SkipNow()
+
+	conn, err := Open("hw:1,0,0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := conn.Write([]byte{0xB0, 0x00, 0x00}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := conn.Write([]byte{0xB0, 0x00, 0x7D}); err != nil {
+		t.Fatal(err)
+	}
+
+	time.Sleep(2 * time.Second)
+
+	if _, err := conn.Write([]byte{0xB0, 0x00, 0x00}); err != nil {
+		t.Fatal(err)
+	}
+
+	// Test hangs here until you send some MIDI data!
+	buf := make([]byte, 3)
+	if _, err := conn.Read(buf); err != nil {
+		t.Fatal(err)
+	}
+}