ios/WALT/MIDIClient.m

/*
 * 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