ios/WALT/MIDIClient.m - platform/external/walt - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #import "MIDIClient.h"

 #include <CoreMIDI/CoreMIDI.h>

 #import "MIDIEndpoint.h"
 #import "MIDIMessage.h"

 NSString * const MIDIClientErrorDomain = @"MIDIClientErrorDomain";

 @interface MIDIClient ()
 @property (readwrite, nonatomic) MIDISource *source;
 @property (readwrite, nonatomic) MIDIDestination *destination;
 // Used by midiRead() for SysEx messages spanning multiple packets.
 @property (readwrite, nonatomic) NSMutableData *sysExBuffer;

 /** Returns whether the client's source or destination is attached to a particular device. */
 - (BOOL)attachedToDevice:(MIDIDeviceRef)device;
 @end

 // Note: These functions (midiStateChanged and midiRead) are not called on the main thread!
 static void midiStateChanged(const MIDINotification *message, void *context) {
   MIDIClient *client = (__bridge MIDIClient *)context;

   switch (message->messageID) {
     case kMIDIMsgObjectAdded: {
       const MIDIObjectAddRemoveNotification *notification =
           (const MIDIObjectAddRemoveNotification *)message;

       @autoreleasepool {
         if ((notification->childType & (kMIDIObjectType_Source|kMIDIObjectType_Destination)) != 0 &&
             [client.delegate respondsToSelector:@selector(MIDIClientEndpointAdded:)]) {
           [client.delegate MIDIClientEndpointAdded:client];
         }
       }
       break;
     }

     case kMIDIMsgObjectRemoved: {
       const MIDIObjectAddRemoveNotification *notification =
           (const MIDIObjectAddRemoveNotification *)message;

       @autoreleasepool {
         if ((notification->childType & (kMIDIObjectType_Source|kMIDIObjectType_Destination)) != 0 &&
             [client.delegate respondsToSelector:@selector(MIDIClientEndpointRemoved:)]) {
           [client.delegate MIDIClientEndpointRemoved:client];
         }
       }
       break;
     }

     case kMIDIMsgSetupChanged:
     case kMIDIMsgPropertyChanged:
     case kMIDIMsgSerialPortOwnerChanged:
     case kMIDIMsgThruConnectionsChanged: {
       @autoreleasepool {
         if ([client.delegate respondsToSelector:@selector(MIDIClientConfigurationChanged:)]) {
           [client.delegate MIDIClientConfigurationChanged:client];
         }
       }
       break;
     }

     case kMIDIMsgIOError: {
       const MIDIIOErrorNotification *notification = (const MIDIIOErrorNotification *)message;

       if ([client attachedToDevice:notification->driverDevice]) {
         @autoreleasepool {
           NSError *error = [NSError errorWithDomain:NSOSStatusErrorDomain
                                                code:notification->errorCode
                                            userInfo:nil];
           if ([client.delegate respondsToSelector:@selector(MIDIClient:receivedError:)]) {
             [client.delegate MIDIClient:client receivedError:error];
           }
         }
       }
       break;
     }

     default: {
       NSLog(@"Unhandled MIDI state change: %d", (int)message->messageID);
     }
   }
 }

 static void midiRead(const MIDIPacketList *packets, void *portContext, void *sourceContext) {
   MIDIClient *client = (__bridge MIDIClient *)portContext;

   // Read the data out of each packet and forward it to the client's delegate.
   // Each MIDIPacket will contain either some MIDI commands, or the start/continuation of a SysEx
   // command. The start of a command is detected with a byte greater than or equal to 0x80 (all data
   // must be 7-bit friendly). The end of a SysEx command is marked with 0x7F.

   // TODO(pquinn): Should something be done with the timestamp data?

   UInt32 packetCount = packets->numPackets;
   const MIDIPacket *packet = &packets->packet[0];
   @autoreleasepool {
     while (packetCount--) {
       if (packet->length == 0) {
         continue;
       }

       const Byte firstByte = packet->data[0];
       const Byte lastByte = packet->data[packet->length - 1];

       if (firstByte >= 0x80 && firstByte != MIDIMessageSysEx && firstByte != MIDIMessageSysExEnd) {
         // Packet describes non-SysEx MIDI messages.
         NSMutableData *data = nil;
         for (UInt16 i = 0; i < packet->length; ++i) {
           // Packets can contain multiple MIDI messages.
           if (packet->data[i] >= 0x80) {
             if (data.length > 0) {  // Tell the delegate about the last extracted command.
               [client.delegate MIDIClient:client receivedData:data];
             }
             data = [[NSMutableData alloc] init];
           }
           [data appendBytes:&packet->data[i] length:1];
         }

         if (data.length > 0) {
           [client.delegate MIDIClient:client receivedData:data];
         }
       }

       if (firstByte == MIDIMessageSysEx) {
         // The start of a SysEx message; collect data into sysExBuffer.
         client.sysExBuffer = [[NSMutableData alloc] initWithBytes:packet->data
                                                            length:packet->length];
       } else if (firstByte < 0x80 || firstByte == MIDIMessageSysExEnd) {
         // Continuation or end of a SysEx message.
         [client.sysExBuffer appendBytes:packet->data length:packet->length];
       }

       if (lastByte == MIDIMessageSysExEnd) {
         // End of a SysEx message.
         [client.delegate MIDIClient:client receivedData:client.sysExBuffer];
         client.sysExBuffer = nil;
       }

       packet = MIDIPacketNext(packet);
     }
   }
 }

 @implementation MIDIClient {
   NSString *_name;
   MIDIClientRef _client;
   MIDIPortRef _input;
   MIDIPortRef _output;
 }

 - (instancetype)initWithName:(NSString *)name error:(NSError **)error {
   if ((self = [super init])) {
     _name = name;  // Hold onto the name because MIDIClientCreate() doesn't retain it.
     OSStatus result = MIDIClientCreate((__bridge CFStringRef)name,
                                        midiStateChanged,
                                        (__bridge void *)self,
                                        &_client);
     if (result != noErr) {
       if (error) {
         *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
       }
       self = nil;
     }
   }
   return self;
 }

 - (void)dealloc {
   MIDIClientDispose(_client);  // Automatically disposes of the ports too.
 }

 - (BOOL)connectToSource:(MIDISource *)source error:(NSError **)error {
   OSStatus result = noErr;
   if (!_input) {  // Lazily create the input port.
     result = MIDIInputPortCreate(_client,
                                  (__bridge CFStringRef)_name,
                                  midiRead,
                                  (__bridge void *)self,
                                  &_input);
     if (result != noErr) {
       if (error) {
         *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
       }
       return NO;
     }
   }

   // Connect the source to the port.
   result = MIDIPortConnectSource(_input, source.endpoint, (__bridge void *)self);
   if (result != noErr) {
     if (error) {
       *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
     }
     return NO;
   }

   self.source = source;
   return YES;
 }

 - (BOOL)connectToDestination:(MIDIDestination *)destination error:(NSError **)error {
   if (!_output) {  // Lazily create the output port.
     OSStatus result = MIDIOutputPortCreate(_client,
                                            (__bridge CFStringRef)_name,
                                            &_output);
     if (result != noErr) {
       if (error) {
         *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
       }
       return NO;
     }
   }

   self.destination = destination;
   return YES;
 }

 - (BOOL)sendData:(NSData *)data error:(NSError **)error {
   if (data.length > sizeof(((MIDIPacket *)0)->data)) {
     // TODO(pquinn): Dynamically allocate a buffer.
     if (error) {
       *error = [NSError errorWithDomain:MIDIClientErrorDomain
                                    code:0
                                userInfo:@{NSLocalizedDescriptionKey:
                                             @"Too much data for a basic MIDIPacket."}];
     }
     return NO;
   }

   MIDIPacketList packetList;
   MIDIPacket *packet = MIDIPacketListInit(&packetList);
   packet = MIDIPacketListAdd(&packetList, sizeof(packetList), packet, 0, data.length, data.bytes);
   if (!packet) {
     if (error) {
       *error = [NSError errorWithDomain:MIDIClientErrorDomain
                                    code:0
                                userInfo:@{NSLocalizedDescriptionKey:
                                             @"Packet too large for buffer."}];
     }
     return NO;
   }

   OSStatus result = MIDISend(_output, self.destination.endpoint, &packetList);
   if (result != noErr) {
     if (error) {
       *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
     }
     return NO;
   }
   return YES;
 }

 - (BOOL)attachedToDevice:(MIDIDeviceRef)device {
   MIDIDeviceRef sourceDevice = 0, destinationDevice = 0;
   MIDIEntityGetDevice(self.source.endpoint, &sourceDevice);
   MIDIEntityGetDevice(self.destination.endpoint, &destinationDevice);

   SInt32 sourceID = 0, destinationID = 0, deviceID = 0;
   MIDIObjectGetIntegerProperty(sourceDevice, kMIDIPropertyUniqueID, &sourceID);
   MIDIObjectGetIntegerProperty(destinationDevice, kMIDIPropertyUniqueID, &destinationID);
   MIDIObjectGetIntegerProperty(device, kMIDIPropertyUniqueID, &deviceID);

   return (deviceID == sourceID || deviceID == destinationID);
 }
 @end
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#import "MIDIClient.h"

	#include <CoreMIDI/CoreMIDI.h>

	#import "MIDIEndpoint.h"
	#import "MIDIMessage.h"

	NSString * const MIDIClientErrorDomain = @"MIDIClientErrorDomain";

	@interface MIDIClient ()
	@property (readwrite, nonatomic) MIDISource *source;
	@property (readwrite, nonatomic) MIDIDestination *destination;
	// Used by midiRead() for SysEx messages spanning multiple packets.
	@property (readwrite, nonatomic) NSMutableData *sysExBuffer;

	/** Returns whether the client's source or destination is attached to a particular device. */
	- (BOOL)attachedToDevice:(MIDIDeviceRef)device;
	@end

	// Note: These functions (midiStateChanged and midiRead) are not called on the main thread!
	static void midiStateChanged(const MIDINotification message, void context) {
	MIDIClient client = (__bridge MIDIClient )context;

	switch (message->messageID) {
	case kMIDIMsgObjectAdded: {
	const MIDIObjectAddRemoveNotification *notification =
	(const MIDIObjectAddRemoveNotification *)message;

	@autoreleasepool {
	if ((notification->childType & (kMIDIObjectType_Source\|kMIDIObjectType_Destination)) != 0 &&
	[client.delegate respondsToSelector:@selector(MIDIClientEndpointAdded:)]) {
	[client.delegate MIDIClientEndpointAdded:client];
	}
	}
	break;
	}

	case kMIDIMsgObjectRemoved: {
	const MIDIObjectAddRemoveNotification *notification =
	(const MIDIObjectAddRemoveNotification *)message;

	@autoreleasepool {
	if ((notification->childType & (kMIDIObjectType_Source\|kMIDIObjectType_Destination)) != 0 &&
	[client.delegate respondsToSelector:@selector(MIDIClientEndpointRemoved:)]) {
	[client.delegate MIDIClientEndpointRemoved:client];
	}
	}
	break;
	}

	case kMIDIMsgSetupChanged:
	case kMIDIMsgPropertyChanged:
	case kMIDIMsgSerialPortOwnerChanged:
	case kMIDIMsgThruConnectionsChanged: {
	@autoreleasepool {
	if ([client.delegate respondsToSelector:@selector(MIDIClientConfigurationChanged:)]) {
	[client.delegate MIDIClientConfigurationChanged:client];
	}
	}
	break;
	}

	case kMIDIMsgIOError: {
	const MIDIIOErrorNotification notification = (const MIDIIOErrorNotification )message;

	if ([client attachedToDevice:notification->driverDevice]) {
	@autoreleasepool {
	NSError *error = [NSError errorWithDomain:NSOSStatusErrorDomain
	code:notification->errorCode
	userInfo:nil];
	if ([client.delegate respondsToSelector:@selector(MIDIClient:receivedError:)]) {
	[client.delegate MIDIClient:client receivedError:error];
	}
	}
	}
	break;
	}

	default: {
	NSLog(@"Unhandled MIDI state change: %d", (int)message->messageID);
	}
	}
	}

	static void midiRead(const MIDIPacketList packets, void portContext, void *sourceContext) {
	MIDIClient client = (__bridge MIDIClient )portContext;

	// Read the data out of each packet and forward it to the client's delegate.
	// Each MIDIPacket will contain either some MIDI commands, or the start/continuation of a SysEx
	// command. The start of a command is detected with a byte greater than or equal to 0x80 (all data
	// must be 7-bit friendly). The end of a SysEx command is marked with 0x7F.

	// TODO(pquinn): Should something be done with the timestamp data?

	UInt32 packetCount = packets->numPackets;
	const MIDIPacket *packet = &packets->packet[0];
	@autoreleasepool {
	while (packetCount--) {
	if (packet->length == 0) {
	continue;
	}

	const Byte firstByte = packet->data[0];
	const Byte lastByte = packet->data[packet->length - 1];

	if (firstByte >= 0x80 && firstByte != MIDIMessageSysEx && firstByte != MIDIMessageSysExEnd) {
	// Packet describes non-SysEx MIDI messages.
	NSMutableData *data = nil;
	for (UInt16 i = 0; i < packet->length; ++i) {
	// Packets can contain multiple MIDI messages.
	if (packet->data[i] >= 0x80) {
	if (data.length > 0) { // Tell the delegate about the last extracted command.
	[client.delegate MIDIClient:client receivedData:data];
	}
	data = [[NSMutableData alloc] init];
	}
	[data appendBytes:&packet->data[i] length:1];
	}

	if (data.length > 0) {
	[client.delegate MIDIClient:client receivedData:data];
	}
	}

	if (firstByte == MIDIMessageSysEx) {
	// The start of a SysEx message; collect data into sysExBuffer.
	client.sysExBuffer = [[NSMutableData alloc] initWithBytes:packet->data
	length:packet->length];
	} else if (firstByte < 0x80 \|\| firstByte == MIDIMessageSysExEnd) {
	// Continuation or end of a SysEx message.
	[client.sysExBuffer appendBytes:packet->data length:packet->length];
	}

	if (lastByte == MIDIMessageSysExEnd) {
	// End of a SysEx message.
	[client.delegate MIDIClient:client receivedData:client.sysExBuffer];
	client.sysExBuffer = nil;
	}

	packet = MIDIPacketNext(packet);
	}
	}
	}

	@implementation MIDIClient {
	NSString *_name;
	MIDIClientRef _client;
	MIDIPortRef _input;
	MIDIPortRef _output;
	}

	- (instancetype)initWithName:(NSString )name error:(NSError *)error {
	if ((self = [super init])) {
	_name = name; // Hold onto the name because MIDIClientCreate() doesn't retain it.
	OSStatus result = MIDIClientCreate((__bridge CFStringRef)name,
	midiStateChanged,
	(__bridge void *)self,
	&_client);
	if (result != noErr) {
	if (error) {
	*error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
	}
	self = nil;
	}
	}
	return self;
	}

	- (void)dealloc {
	MIDIClientDispose(_client); // Automatically disposes of the ports too.
	}

	- (BOOL)connectToSource:(MIDISource )source error:(NSError *)error {
	OSStatus result = noErr;
	if (!_input) { // Lazily create the input port.
	result = MIDIInputPortCreate(_client,
	(__bridge CFStringRef)_name,
	midiRead,
	(__bridge void *)self,
	&_input);
	if (result != noErr) {
	if (error) {
	*error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
	}
	return NO;
	}
	}

	// Connect the source to the port.
	result = MIDIPortConnectSource(_input, source.endpoint, (__bridge void *)self);
	if (result != noErr) {
	if (error) {
	*error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
	}
	return NO;
	}

	self.source = source;
	return YES;
	}

	- (BOOL)connectToDestination:(MIDIDestination )destination error:(NSError *)error {
	if (!_output) { // Lazily create the output port.
	OSStatus result = MIDIOutputPortCreate(_client,
	(__bridge CFStringRef)_name,
	&_output);
	if (result != noErr) {
	if (error) {
	*error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
	}
	return NO;
	}
	}

	self.destination = destination;
	return YES;
	}

	- (BOOL)sendData:(NSData )data error:(NSError *)error {
	if (data.length > sizeof(((MIDIPacket *)0)->data)) {
	// TODO(pquinn): Dynamically allocate a buffer.
	if (error) {
	*error = [NSError errorWithDomain:MIDIClientErrorDomain
	code:0
	userInfo:@{NSLocalizedDescriptionKey:
	@"Too much data for a basic MIDIPacket."}];
	}
	return NO;
	}

	MIDIPacketList packetList;
	MIDIPacket *packet = MIDIPacketListInit(&packetList);
	packet = MIDIPacketListAdd(&packetList, sizeof(packetList), packet, 0, data.length, data.bytes);
	if (!packet) {
	if (error) {
	*error = [NSError errorWithDomain:MIDIClientErrorDomain
	code:0
	userInfo:@{NSLocalizedDescriptionKey:
	@"Packet too large for buffer."}];
	}
	return NO;
	}

	OSStatus result = MIDISend(_output, self.destination.endpoint, &packetList);
	if (result != noErr) {
	if (error) {
	*error = [NSError errorWithDomain:NSOSStatusErrorDomain code:result userInfo:nil];
	}
	return NO;
	}
	return YES;
	}

	- (BOOL)attachedToDevice:(MIDIDeviceRef)device {
	MIDIDeviceRef sourceDevice = 0, destinationDevice = 0;
	MIDIEntityGetDevice(self.source.endpoint, &sourceDevice);
	MIDIEntityGetDevice(self.destination.endpoint, &destinationDevice);

	SInt32 sourceID = 0, destinationID = 0, deviceID = 0;
	MIDIObjectGetIntegerProperty(sourceDevice, kMIDIPropertyUniqueID, &sourceID);
	MIDIObjectGetIntegerProperty(destinationDevice, kMIDIPropertyUniqueID, &destinationID);
	MIDIObjectGetIntegerProperty(device, kMIDIPropertyUniqueID, &deviceID);

	return (deviceID == sourceID \|\| deviceID == destinationID);
	}
	@end