macosx/coremidi/JackCoreMidiDriver.cpp

   1 /*
   2 Copyright (C) 2009 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackCoreMidiDriver.h"
  21 #include "JackGraphManager.h"
  22 #include "JackServer.h"
  23 #include "JackEngineControl.h"
  24 #include "JackDriverLoader.h"
  25
  26 #include <mach/mach_time.h>
  27 #include <assert.h>
  28 #include <iostream>
  29 #include <sstream>
  30 #include <string>
  31
  32 namespace Jack
  33 {
  34
  35 static MIDITimeStamp MIDIGetCurrentHostTime()
  36 {
  37         return mach_absolute_time();
  38 }
  39
  40 void JackCoreMidiDriver::ReadProcAux(const MIDIPacketList *pktlist, jack_ringbuffer_t* ringbuffer)
  41 {
  42     // Write the number of packets
  43     size_t size = jack_ringbuffer_write(ringbuffer, (char*)&pktlist->numPackets, sizeof(UInt32));
  44     if (size != sizeof(UInt32)) {
  45         jack_error("ReadProc : ring buffer is full, skip events...");
  46         return;
  47     }
  48
  49     for (unsigned int i = 0; i < pktlist->numPackets; ++i) {
  50
  51         MIDIPacket *packet = (MIDIPacket *)pktlist->packet;
  52
  53         // TODO : use timestamp
  54
  55         // Check available size first..
  56         size = jack_ringbuffer_write_space(ringbuffer);
  57         if (size < (sizeof(UInt16) + packet->length)) {
  58            jack_error("ReadProc : ring buffer is full, skip events...");
  59            return;
  60         }
  61         // Write length of each packet first
  62         jack_ringbuffer_write(ringbuffer, (char*)&packet->length, sizeof(UInt16));
  63         // Write event actual data
  64         jack_ringbuffer_write(ringbuffer, (char*)packet->data, packet->length);
  65
  66         packet = MIDIPacketNext(packet);
  67     }
  68 }
  69
  70 void JackCoreMidiDriver::ReadProc(const MIDIPacketList *pktlist, void *refCon, void *connRefCon)
  71 {
  72     jack_ringbuffer_t* ringbuffer = (jack_ringbuffer_t*)connRefCon;
  73     ReadProcAux(pktlist, ringbuffer);
  74 }
  75
  76 void JackCoreMidiDriver::ReadVirtualProc(const MIDIPacketList *pktlist, void *refCon, void *connRefCon)
  77 {
  78     jack_ringbuffer_t* ringbuffer = (jack_ringbuffer_t*)refCon;
  79     ReadProcAux(pktlist, ringbuffer);
  80 }
  81
  82 void JackCoreMidiDriver::NotifyProc(const MIDINotification *message, void *refCon)
  83 {
  84         jack_info("NotifyProc %d", message->messageID);
  85 }
  86
  87 JackCoreMidiDriver::JackCoreMidiDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table)
  88     : JackMidiDriver(name, alias, engine, table), fMidiClient(NULL), fInputPort(NULL), fOutputPort(NULL), fRealCaptureChannels(0), fRealPlaybackChannels(0)
  89 {}
  90
  91 JackCoreMidiDriver::~JackCoreMidiDriver()
  92 {}
  93
  94 int JackCoreMidiDriver::Open(bool capturing,
  95                              bool playing,
  96                              int inchannels,
  97                              int outchannels,
  98                              bool monitor,
  99                              const char* capture_driver_name,
 100                              const char* playback_driver_name,
 101                              jack_nframes_t capture_latency,
 102                              jack_nframes_t playback_latency)
 103                     {
 104     OSStatus err;
 105         CFStringRef coutputStr;
 106         std::string str;
 107
 108     // Get real input/output number
 109     fRealCaptureChannels = MIDIGetNumberOfSources();
 110     fRealPlaybackChannels = MIDIGetNumberOfDestinations();
 111
 112     // Generic JackMidiDriver Open
 113     if (JackMidiDriver::Open(capturing, playing, inchannels + fRealCaptureChannels, outchannels + fRealPlaybackChannels, monitor, capture_driver_name, playback_driver_name, capture_latency, playback_latency) != 0)
 114         return -1;
 115
 116     coutputStr = CFStringCreateWithCString(0, "JackMidi", CFStringGetSystemEncoding());
 117         err = MIDIClientCreate(coutputStr, NotifyProc, this, &fMidiClient);
 118         CFRelease(coutputStr);
 119         if (!fMidiClient) {
 120         jack_error("Cannot create CoreMidi client");
 121                 goto error;
 122         }
 123
 124         err = MIDIInputPortCreate(fMidiClient, CFSTR("Input port"), ReadProc, this, &fInputPort);
 125         if (!fInputPort) {
 126                 jack_error("Cannot open CoreMidi in port\n");
 127                 goto error;
 128         }
 129
 130         err = MIDIOutputPortCreate(fMidiClient, CFSTR("Output port"), &fOutputPort);
 131         if (!fOutputPort) {
 132                 jack_error("Cannot open CoreMidi out port\n");
 133                 goto error;
 134         }
 135
 136     fMidiDestination = new MIDIEndpointRef[inchannels + fRealCaptureChannels];
 137     assert(fMidiDestination);
 138
 139     // Virtual input
 140     for (int i = 0; i < inchannels; i++)  {
 141         std::stringstream num;
 142         num << i;
 143         str = "JackMidi" + num.str();
 144         coutputStr = CFStringCreateWithCString(0, str.c_str(), CFStringGetSystemEncoding());
 145         err = MIDIDestinationCreate(fMidiClient, coutputStr, ReadVirtualProc, fRingBuffer[i], &fMidiDestination[i]);
 146         CFRelease(coutputStr);
 147         if (!fMidiDestination[i]) {
 148             jack_error("Cannot create CoreMidi destination");
 149             goto error;
 150         }
 151     }
 152
 153     // Real input
 154     for (int i = 0; i < fRealCaptureChannels; i++)  {
 155         fMidiDestination[i + inchannels] = MIDIGetSource(i);
 156         MIDIPortConnectSource(fInputPort, fMidiDestination[i + inchannels], fRingBuffer[i + inchannels]);
 157     }
 158
 159     fMidiSource = new MIDIEndpointRef[outchannels + fRealPlaybackChannels];
 160     assert(fMidiSource);
 161
 162     // Virtual output
 163     for (int i = 0; i < outchannels; i++)  {
 164         std::stringstream num;
 165         num << i;
 166         str = "JackMidi" + num.str();
 167         coutputStr = CFStringCreateWithCString(0, str.c_str(), CFStringGetSystemEncoding());
 168         err = MIDISourceCreate(fMidiClient, coutputStr, &fMidiSource[i]);
 169         CFRelease(coutputStr);
 170         if (!fMidiSource[i]) {
 171             jack_error("Cannot create CoreMidi source");
 172             goto error;
 173         }
 174     }
 175
 176      // Real output
 177     for (int i = 0; i < fRealPlaybackChannels; i++)  {
 178         fMidiSource[i + outchannels] = MIDIGetDestination(i);
 179     }
 180
 181     return 0;
 182
 183 error:
 184     Close();
 185         return -1;
 186 }
 187
 188 int JackCoreMidiDriver::Close()
 189 {
 190     if (fInputPort)
 191                  MIDIPortDispose(fInputPort);
 192
 193     if (fOutputPort)
 194                 MIDIPortDispose(fOutputPort);
 195
 196     // Only dispose "virtual" endpoints
 197     for (int i = 0; i < fCaptureChannels - fRealCaptureChannels; i++)  {
 198         if (fMidiDestination)
 199             MIDIEndpointDispose(fMidiDestination[i]);
 200     }
 201     delete[] fMidiDestination;
 202
 203     // Only dispose "virtual" endpoints
 204     for (int i = 0; i < fPlaybackChannels - fRealPlaybackChannels; i++)  {
 205         if (fMidiSource[i])
 206             MIDIEndpointDispose(fMidiSource[i]);
 207     }
 208     delete[] fMidiSource;
 209
 210         if (fMidiClient)
 211         MIDIClientDispose(fMidiClient);
 212
 213     return 0;
 214 }
 215
 216 int JackCoreMidiDriver::Attach()
 217 {
 218     OSStatus err;
 219     JackPort* port;
 220     CFStringRef pname;
 221     jack_port_id_t port_index;
 222     char name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
 223     char endpoint_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
 224     char alias[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
 225     int i;
 226
 227     jack_log("JackCoreMidiDriver::Attach fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
 228
 229     for (i = 0; i < fCaptureChannels; i++) {
 230
 231         err = MIDIObjectGetStringProperty(fMidiDestination[i], kMIDIPropertyName, &pname);
 232         if (err == noErr) {
 233             CFStringGetCString(pname, endpoint_name, sizeof(endpoint_name), 0);
 234             CFRelease(pname);
 235             snprintf(alias, sizeof(alias) - 1, "%s:%s:out%d", fAliasName, endpoint_name, i + 1);
 236         } else {
 237             snprintf(alias, sizeof(alias) - 1, "%s:%s:out%d", fAliasName, fCaptureDriverName, i + 1);
 238         }
 239
 240         snprintf(name, sizeof(name) - 1, "%s:capture_%d", fClientControl.fName, i + 1);
 241         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE, CaptureDriverFlags, fEngineControl->fBufferSize)) == NO_PORT) {
 242             jack_error("driver: cannot register port for %s", name);
 243             return -1;
 244         }
 245         port = fGraphManager->GetPort(port_index);
 246         port->SetAlias(alias);
 247         fCapturePortList[i] = port_index;
 248         jack_log("JackCoreMidiDriver::Attach fCapturePortList[i] port_index = %ld", port_index);
 249     }
 250
 251     for (i = 0; i < fPlaybackChannels; i++) {
 252
 253         err = MIDIObjectGetStringProperty(fMidiSource[i], kMIDIPropertyName, &pname);
 254         if (err == noErr) {
 255             CFStringGetCString(pname, endpoint_name, sizeof(endpoint_name), 0);
 256             CFRelease(pname);
 257             snprintf(alias, sizeof(alias) - 1, "%s:%s:in%d", fAliasName, endpoint_name, i + 1);
 258         } else {
 259             snprintf(alias, sizeof(alias) - 1, "%s:%s:in%d", fAliasName, fPlaybackDriverName, i + 1);
 260         }
 261
 262         snprintf(name, sizeof(name) - 1, "%s:playback_%d", fClientControl.fName, i + 1);
 263         if ((port_index = fGraphManager->AllocatePort(fClientControl.fRefNum, name, JACK_DEFAULT_MIDI_TYPE, PlaybackDriverFlags, fEngineControl->fBufferSize)) == NO_PORT) {
 264             jack_error("driver: cannot register port for %s", name);
 265             return -1;
 266         }
 267         port = fGraphManager->GetPort(port_index);
 268         port->SetAlias(alias);
 269         fPlaybackPortList[i] = port_index;
 270         jack_log("JackCoreMidiDriver::Attach fPlaybackPortList[i] port_index = %ld", port_index);
 271     }
 272
 273     return 0;
 274 }
 275 int JackCoreMidiDriver::Read()
 276 {
 277     for (int chan = 0; chan < fCaptureChannels; chan++)  {
 278
 279         if (fGraphManager->GetConnectionsNum(fCapturePortList[chan]) > 0) {
 280
 281             // Get JACK port
 282             JackMidiBuffer* midi_buffer = GetInputBuffer(chan);
 283
 284             if (jack_ringbuffer_read_space(fRingBuffer[chan]) == 0) {
 285                 // Reset buffer
 286                 midi_buffer->Reset(midi_buffer->nframes);
 287             } else {
 288
 289                 while (jack_ringbuffer_read_space(fRingBuffer[chan]) > 0) {
 290
 291                     // Read event number
 292                     int ev_count = 0;
 293                     jack_ringbuffer_read(fRingBuffer[chan], (char*)&ev_count, sizeof(int));
 294
 295                     for (int j = 0; j < ev_count; j++)  {
 296                         // Read event length
 297                         UInt16 event_len;
 298                         jack_ringbuffer_read(fRingBuffer[chan], (char*)&event_len, sizeof(UInt16));
 299                         // Read event actual data
 300                         jack_midi_data_t* dest = midi_buffer->ReserveEvent(0, event_len);
 301                         jack_ringbuffer_read(fRingBuffer[chan], (char*)dest, event_len);
 302                     }
 303                 }
 304             }
 305
 306         } else {
 307             // Consume ring buffer
 308             jack_ringbuffer_read_advance(fRingBuffer[chan], jack_ringbuffer_read_space(fRingBuffer[chan]));
 309         }
 310     }
 311     return 0;
 312 }
 313
 314 int JackCoreMidiDriver::Write()
 315 {
 316     MIDIPacketList* pktlist = (MIDIPacketList*)fMIDIBuffer;
 317
 318     for (int chan = 0; chan < fPlaybackChannels; chan++)  {
 319
 320          if (fGraphManager->GetConnectionsNum(fPlaybackPortList[chan]) > 0) {
 321
 322             MIDIPacket* packet = MIDIPacketListInit(pktlist);
 323             JackMidiBuffer* midi_buffer = GetOutputBuffer(chan);
 324
 325             // TODO : use timestamp
 326
 327             for (unsigned int j = 0; j < midi_buffer->event_count; j++) {
 328                 JackMidiEvent* ev = &midi_buffer->events[j];
 329                 packet = MIDIPacketListAdd(pktlist, sizeof(fMIDIBuffer), packet, MIDIGetCurrentHostTime(), ev->size, ev->GetData(midi_buffer));
 330             }
 331
 332             if (packet) {
 333                 if (chan < fPlaybackChannels - fRealPlaybackChannels) {
 334                     OSStatus err = MIDIReceived(fMidiSource[chan], pktlist);
 335                     if (err != noErr)
 336                         jack_error("MIDIReceived error");
 337                 } else {
 338                     OSStatus err = MIDISend(fOutputPort, fMidiSource[chan], pktlist);
 339                     if (err != noErr)
 340                         jack_error("MIDISend error");
 341                 }
 342             }
 343         }
 344     }
 345
 346     return 0;
 347 }
 348
 349 } // end of namespace
 350
 351 #ifdef __cplusplus
 352 extern "C"
 353 {
 354 #endif
 355
 356     SERVER_EXPORT jack_driver_desc_t * driver_get_descriptor()
 357     {
 358         jack_driver_desc_t * desc;
 359         unsigned int i;
 360
 361         desc = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
 362         strcpy(desc->name, "coremidi");                                     // size MUST be less then JACK_DRIVER_NAME_MAX + 1
 363         strcpy(desc->desc, "Apple CoreMIDI API based MIDI backend");      // size MUST be less then JACK_DRIVER_PARAM_DESC + 1
 364
 365         desc->nparams = 2;
 366         desc->params = (jack_driver_param_desc_t*)calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
 367
 368         i = 0;
 369         strcpy(desc->params[i].name, "inchannels");
 370         desc->params[i].character = 'i';
 371         desc->params[i].type = JackDriverParamInt;
 372         desc->params[i].value.ui = 0;
 373         strcpy(desc->params[i].short_desc, "CoreMIDI virtual bus");
 374         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
 375
 376         i++;
 377         strcpy(desc->params[i].name, "outchannels");
 378         desc->params[i].character = 'o';
 379         desc->params[i].type = JackDriverParamInt;
 380         desc->params[i].value.ui = 0;
 381         strcpy(desc->params[i].short_desc, "CoreMIDI virtual bus");
 382         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
 383
 384         return desc;
 385     }
 386
 387     SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)
 388     {
 389         const JSList * node;
 390         const jack_driver_param_t * param;
 391         int virtual_in = 0;
 392         int virtual_out = 0;
 393
 394         for (node = params; node; node = jack_slist_next (node)) {
 395             param = (const jack_driver_param_t *) node->data;
 396
 397             switch (param->character) {
 398
 399                 case 'i':
 400                     virtual_in = param->value.ui;
 401                     break;
 402
 403                 case 'o':
 404                     virtual_out = param->value.ui;
 405                     break;
 406                 }
 407         }
 408
 409         Jack::JackDriverClientInterface* driver = new Jack::JackCoreMidiDriver("system_midi", "coremidi", engine, table);
 410         if (driver->Open(1, 1, virtual_in, virtual_out, false, "in", "out", 0, 0) == 0) {
 411             return driver;
 412         } else {
 413             delete driver;
 414             return NULL;
 415         }
 416     }
 417
 418 #ifdef __cplusplus
 419 }
 420 #endif
 421