Enumerate devices darwin (#4)

* first pass at Devices with CoreMIDI

* clean up a few linting errors

* darwin: free endpoints and midi struct pointer in Midi_close

* darwin: defer CFRelease of the device name in Devices

* add Err to Packet

Author: briansorahan

launchpad_test.go

@@ -15,7 +15,19 @@ func TestLaunchpad(t *testing.T) {
 	// For the launchpad MIDI reference, see https://d19ulaff0trnck.cloudfront.net/sites/default/files/novation/downloads/4080/launchpad-programmers-reference.pdf
 	t.SkipNow()
 
-	device := &Device{ID: "hw:0"}
+	devices, err := Devices()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var device *Device
+	for _, d := range devices {
+		if d.Name == "Launchpad Mini" {
+			device = d
+		}
+	}
+	if device == nil {
+		t.Fatal("getting device Launchpad Mini")
+	}
 	if err := device.Open(); err != nil {
 		t.Fatal(err)
 	}
@@ -44,6 +56,9 @@ func TestLaunchpad(t *testing.T) {
 
 	fmt.Println("waiting for packet")
 	packet := <-packets
+	if packet.Err != nil {
+		t.Fatal(err)
+	}
 	fmt.Printf("packet %#v\n", packet)
 
 	if err := device.Close(); err != nil {

midi.go

@@ -0,0 +1,18 @@
+// Package midi is a package for talking to midi devices in Go.
+package midi
+
+// Packet is a MIDI packet.
+type Packet struct {
+	Data [3]byte
+	Err  error
+}
+
+// DeviceType is a flag that says if a device is an input, an output, or duplex.
+type DeviceType int
+
+// Device types.
+const (
+	DeviceInput DeviceType = iota
+	DeviceOutput
+	DeviceDuplex
+)

midi_darwin.c

@@ -12,9 +12,6 @@
 
 extern void SendPacket(Midi midi, unsigned char c1, unsigned char c2, unsigned char c3);
 
-Midi_device_endpoints  find_device_endpoints(const char *device);
-char                  *CFStringToUTF8(CFStringRef aString);
-
 // Midi represents a MIDI connection that uses the ALSA RawMidi API.
 struct Midi {
 	MIDIClientRef   client;
@@ -26,19 +23,14 @@ struct Midi {
 
 // Midi_open opens a MIDI connection to the specified device.
 // If there is an error it returns NULL.
-Midi_open_result Midi_open(const char *name) {
-	Midi           midi;
-	OSStatus       rc;
+Midi_open_result Midi_open(MIDIEndpointRef input, MIDIEndpointRef output) {
+	Midi     midi;
+	OSStatus rc;
 
 	NEW(midi);
 
-	// Read input and output endpoints.
-	Midi_device_endpoints device_endpoints = find_device_endpoints(name);
-	if (device_endpoints.error != 0) {
-		return (Midi_open_result) { .midi = NULL, .error = device_endpoints.error };
-	}
-	midi->input  = device_endpoints.input;
-	midi->output = device_endpoints.output;
+	midi->input  = input;
+	midi->output = output;
 
 	rc = MIDIClientCreate(CFSTR("scgolang"), NULL, NULL, &midi->client);
 	if (rc != 0) {
@@ -52,7 +44,7 @@ Midi_open_result Midi_open(const char *name) {
 	if (rc != 0) {
 		return (Midi_open_result) { .midi = NULL, .error = rc };
 	}
-	rc = MIDIPortConnectSource(midi->inputPort, midi->input, midi);
+	rc = MIDIPortConnectSource(midi->inputPort, input, midi);
 	if (rc != 0) {
 		return (Midi_open_result) { .midi = NULL, .error = rc };
 	}
@@ -102,63 +94,34 @@ Midi_write_result Midi_write(Midi midi, const char *buffer, size_t buffer_size)
 int Midi_close(Midi midi) {
 	assert(midi);
 
-	OSStatus rc1, rc2, rc3;
+	OSStatus rc1, rc2, rc3, rc4, rc5;
 
 	rc1 = MIDIPortDispose(midi->inputPort);
 	rc2 = MIDIPortDispose(midi->outputPort);
 	rc3 = MIDIClientDispose(midi->client);
+	rc4 = MIDIEndpointDispose(midi->input);
+	rc5 = MIDIEndpointDispose(midi->output);
+
+	FREE(midi);
 
 	if      (rc1 != 0) return rc1;
 	else if (rc2 != 0) return rc2;
 	else if (rc3 != 0) return rc3;
+	else if (rc4 != 0) return rc4;
+	else if (rc5 != 0) return rc5;
 	else               return 0;
 }
 
-Midi_device_endpoints find_device_endpoints(const char *name) {
-	ItemCount numDevices = MIDIGetNumberOfDevices();
-	OSStatus  rc;
-
-	for (int i = 0; i < numDevices; i++) {
-		CFStringRef   deviceName;
-		MIDIDeviceRef deviceRef = MIDIGetDevice(i);
-		
-		rc = MIDIObjectGetStringProperty(deviceRef, kMIDIPropertyName, &deviceName);
-		if (rc != 0) {
-			return (Midi_device_endpoints) { .device = 0, .input = 0, .output = 0, .error = rc };
-		}
-		if (strcmp(CFStringToUTF8(deviceName), name) != 0) {
-			continue;
-		}
-		ItemCount numEntities = MIDIDeviceGetNumberOfEntities(deviceRef);
-		
-		for (int i = 0; i < numEntities; i++) {
-			MIDIEntityRef entityRef       = MIDIDeviceGetEntity(deviceRef, i);
-			ItemCount     numDestinations = MIDIGetNumberOfDestinations(entityRef);
-			ItemCount     numSources      = MIDIGetNumberOfSources(entityRef);
-
-			if (numDestinations < 1 || numSources < 1) {
-				continue;
-			}
-			MIDIEndpointRef input  = MIDIGetSource(0);
-			MIDIEndpointRef output = MIDIGetDestination(0);
-
-			return (Midi_device_endpoints) { .device = deviceRef, .input = input, .output = output, .error = 0 };
-		}
-	}
-	return (Midi_device_endpoints) { .device = 0, .input = 0, .output = 0, .error = -10901 };
-}
-
+// CFStringToUTF8 converts a CoreFoundation string to a UTF-encoded C string.
+// Callers are responsible for free'ing the returned string.
 char *CFStringToUTF8(CFStringRef aString) {
 	if (aString == NULL) {
 		return NULL;
 	}
-
-	CFIndex length = CFStringGetLength(aString);
-	CFIndex maxSize =
-		CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
-	char *buffer = (char *)malloc(maxSize);
-	if (CFStringGetCString(aString, buffer, maxSize,
-			       kCFStringEncodingUTF8)) {
+	CFIndex length  = CFStringGetLength(aString);
+	CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
+	char   *buffer  = (char *)malloc(maxSize);
+	if (CFStringGetCString(aString, buffer, maxSize, kCFStringEncodingUTF8)) {
 		return buffer;
 	}
 	free(buffer); // If we failed

midi_darwin.go

@@ -1,5 +1,3 @@
-// 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>
@@ -11,37 +9,39 @@ import "C"
 
 import (
 	"sync"
+	"unsafe"
 
 	"github.com/pkg/errors"
 )
 
 // Common errors.
 var (
-	ErrDeviceNotFound = errors.New("device not found, did you open the device?")
+	ErrNotOpen = errors.New("Did you remember to open the device?")
 )
 
-// Packet is a MIDI packet.
-type Packet [3]byte
-
 var (
 	packetChans      = map[*Device]chan Packet{}
 	packetChansMutex sync.RWMutex
 )
 
 // Device provides an interface for MIDI devices.
 type Device struct {
+	ID   string
 	Name string
+	Type DeviceType
 
 	// QueueSize controls the buffer size of the read channel. Use 0 for blocking reads.
 	QueueSize int
 
-	conn C.Midi
+	conn   C.Midi
+	input  C.MIDIEndpointRef
+	output C.MIDIEndpointRef
 }
 
 // Open opens a MIDI device.
 // queueSize is the number of packets to buffer in the channel associated with the device.
 func (d *Device) Open() error {
-	result := C.Midi_open(C.CString(d.Name))
+	result := C.Midi_open(d.input, d.output)
 	if result.error != 0 {
 		return coreMidiError(result.error)
 	}
@@ -58,6 +58,7 @@ func (d *Device) Close() error {
 }
 
 // Packets emits MIDI packets.
+// If the device has not been opened it will return ErrNotOpen.
 func (d *Device) Packets() (<-chan Packet, error) {
 	packetChansMutex.RLock()
 	for device, packetChan := range packetChans {
@@ -67,7 +68,7 @@ func (d *Device) Packets() (<-chan Packet, error) {
 		}
 	}
 	packetChansMutex.RUnlock()
-	return nil, ErrDeviceNotFound
+	return nil, ErrNotOpen
 }
 
 // Write writes data to a MIDI device.
@@ -84,7 +85,9 @@ func SendPacket(conn C.Midi, c1 C.uchar, c2 C.uchar, c3 C.uchar) {
 	packetChansMutex.RLock()
 	for device, packetChan := range packetChans {
 		if device.conn == conn {
-			packetChan <- Packet{byte(c1), byte(c2), byte(c3)}
+			packetChan <- Packet{
+				Data: [3]byte{byte(c1), byte(c2), byte(c3)},
+			}
 		}
 	}
 	packetChansMutex.RUnlock()
@@ -141,3 +144,61 @@ func coreMidiError(code C.OSStatus) error {
 		return errors.Errorf("unknown CoreMIDI error: %d", code)
 	}
 }
+
+// Devices returns a list of devices.
+func Devices() ([]*Device, error) {
+	var (
+		maxEndpoints    C.ItemCount
+		devices                     = []*Device{}
+		numDestinations C.ItemCount = C.MIDIGetNumberOfDestinations()
+		numSources      C.ItemCount = C.MIDIGetNumberOfSources()
+	)
+	if numDestinations > numSources {
+		maxEndpoints = numDestinations
+	} else {
+		maxEndpoints = numSources
+	}
+	for i := C.ItemCount(0); i < maxEndpoints; i++ {
+		var (
+			d   *Device
+			obj C.MIDIObjectRef
+		)
+		if i < numDestinations && i < numSources {
+			d = &Device{
+				Type:   DeviceDuplex,
+				input:  C.MIDIGetSource(i),
+				output: C.MIDIGetDestination(i),
+			}
+			obj = C.MIDIObjectRef(d.output)
+		} else if i < numDestinations {
+			d = &Device{
+				Type:   DeviceOutput,
+				output: C.MIDIGetDestination(i),
+			}
+			obj = C.MIDIObjectRef(d.output)
+		} else {
+			d = &Device{
+				Type:  DeviceInput,
+				input: C.MIDIGetSource(i),
+			}
+			obj = C.MIDIObjectRef(d.input)
+		}
+		var name C.CFStringRef
+		if rc := C.MIDIObjectGetStringProperty(obj, C.kMIDIPropertyName, &name); rc != 0 {
+			return nil, coreMidiError(rc)
+		}
+		d.Name = fromCFString(name)
+		C.CFRelease(C.CFTypeRef(name))
+		devices = append(devices, d)
+	}
+	return devices, nil
+}
+
+func fromCFString(cfs C.CFStringRef) string {
+	var (
+		cs = C.CFStringToUTF8(cfs)
+		gs = C.GoString(cs)
+	)
+	C.free(unsafe.Pointer(cs))
+	return gs
+}

midi_darwin.h

@@ -30,7 +30,7 @@ typedef struct Midi_device_endpoints {
 } Midi_device_endpoints;
 
 // Midi_open opens a MIDI connection to the specified device.
-Midi_open_result Midi_open(const char *name);
+Midi_open_result Midi_open(MIDIEndpointRef input, MIDIEndpointRef output);
 
 // Midi_read_proc is the callback that gets invoked when MIDI data comes in.
 void Midi_read_proc(const MIDIPacketList *pkts, void *readProcRefCon, void *srcConnRefCon);
@@ -47,4 +47,7 @@ Midi_write_result Midi_write(Midi midi, const char *buffer, size_t buffer_size);
 // Midi_close closes a MIDI connection.
 int Midi_close(Midi midi);
 
+// CFStringToUTF8 converts a CFStringRef to a UTF8-encoded C string.
+char *CFStringToUTF8(CFStringRef aString);
+
 #endif // MIDI_DARWIN_H defined

midi_linux.go

@@ -1,5 +1,3 @@
-// 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 <alsa/asoundlib.h>
@@ -11,24 +9,11 @@ import "C"
 
 import (
 	"fmt"
-	"os"
 	"unsafe"
 
 	"github.com/pkg/errors"
 )
 
-// Packet is a MIDI packet.
-type Packet [3]byte
-
-// DeviceType is a flag that says if a device is an input, an output, or duplex.
-type DeviceType int
-
-const (
-	DeviceInput DeviceType = iota
-	DeviceOutput
-	DeviceDuplex
-)
-
 // Device provides an interface for MIDI devices.
 type Device struct {
 	ID        string
@@ -69,11 +54,12 @@ func (d *Device) Packets() (<-chan Packet, error) {
 	go func() {
 		for {
 			if _, err := d.Read(buf); err != nil {
-				fmt.Fprintf(os.Stderr, "could not read from device: %s", err)
-				close(ch)
+				ch <- Packet{Err: err}
 				return
 			}
-			ch <- Packet{buf[0], buf[1], buf[2]}
+			ch <- Packet{
+				Data: [3]byte{buf[0], buf[1], buf[2]},
+			}
 		}
 	}()
 	return ch, nil
@@ -98,10 +84,7 @@ func (d *Device) Write(buf []byte) (int, error) {
 	return int(n), err
 }
 
-type Stream struct {
-	Name string
-}
-
+// Devices returns a list of devices.
 func Devices() ([]*Device, error) {
 	var card C.int = -1