v2/rtmidi.cpp

   1 /**********************************************************************/
   2 /*! \class RtMidi
   3     \brief An abstract base class for realtime MIDI input/output.
   4
   5     This class implements some common functionality for the realtime
   6     MIDI input/output subclasses RtMidiIn and RtMidiOut.
   7
   8     RtMidi WWW site: http://music.mcgill.ca/~gary/rtmidi/
   9
  10     RtMidi: realtime MIDI i/o C++ classes
  11     Copyright (c) 2003-2005 Gary P. Scavone
  12
  13     Permission is hereby granted, free of charge, to any person
  14     obtaining a copy of this software and associated documentation files
  15     (the "Software"), to deal in the Software without restriction,
  16     including without limitation the rights to use, copy, modify, merge,
  17     publish, distribute, sublicense, and/or sell copies of the Software,
  18     and to permit persons to whom the Software is furnished to do so,
  19     subject to the following conditions:
  20
  21     The above copyright notice and this permission notice shall be
  22     included in all copies or substantial portions of the Software.
  23
  24     Any person wishing to distribute modifications to the Software is
  25     requested to send the modifications to the original developer so that
  26     they can be incorporated into the canonical version.
  27
  28     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  29     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  30     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  31     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  32     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  33     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  34     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  35 */
  36 /**********************************************************************/
  37
  38 // RtMidi: Version 1.0.4, 14 October 2005
  39
  40 // chuck
  41 #include "rtmidi.h"
  42 #include <sstream>
  43 #include <iostream>
  44
  45
  46 //*********************************************************************//
  47 //  Common RtMidi Definitions
  48 //*********************************************************************//
  49
  50 RtMidi :: RtMidi()
  51   : apiData_( 0 ), connected_( false )
  52 {
  53 }
  54
  55 // chuck
  56 void RtMidi :: error( RtError::Type type )
  57 {
  58   if (type == RtError::WARNING) {
  59     std::cerr << "[chuck](via RtMidi): " << errorString_ << "\n";
  60   }
  61   else if (type == RtError::DEBUG_WARNING) {
  62 #if defined(__RTMIDI_DEBUG__)
  63     std::cerr << "[chuck](via RtMidi): " << errorString_ << "\n";
  64 #endif
  65   }
  66   else {
  67     // std::cerr << "[chuck](via RtMidi): " << errorString_ << "\n";
  68     throw RtError( errorString_, type );
  69   }
  70 }
  71
  72
  73 //*********************************************************************//
  74 //  Common RtMidiIn Definitions
  75 //*********************************************************************//
  76
  77 RtMidiIn :: RtMidiIn() : RtMidi()
  78 {
  79   this->initialize();
  80 }
  81
  82 void RtMidiIn :: setCallback( RtMidiCallback callback, void *userData )
  83 {
  84   if ( inputData_.usingCallback ) {
  85     errorString_ = "RtMidiIn::setCallback: callback function is already set!";
  86     error( RtError::WARNING );
  87     return;
  88   }
  89
  90   if ( !callback ) {
  91     errorString_ = "RtMidiIn::setCallback: callback function value is invalid!";
  92     error( RtError::WARNING );
  93     return;
  94   }
  95
  96   inputData_.userCallback = (void *) callback;
  97   inputData_.userData = userData;
  98   inputData_.usingCallback = true;
  99 }
 100
 101 void RtMidiIn :: cancelCallback()
 102 {
 103   if ( !inputData_.usingCallback ) {
 104     errorString_ = "RtMidiIn::cancelCallback: no callback function was set!";
 105     error( RtError::WARNING );
 106     return;
 107   }
 108
 109   inputData_.userCallback = 0;
 110   inputData_.userData = 0;
 111   inputData_.usingCallback = false;
 112 }
 113
 114 void RtMidiIn :: setQueueSizeLimit( unsigned int queueSize )
 115 {
 116   inputData_.queueLimit = queueSize;
 117 }
 118
 119 void RtMidiIn :: ignoreTypes( bool midiSysex, bool midiTime, bool midiSense )
 120 {
 121   inputData_.ignoreFlags = 0;
 122   if ( midiSysex ) inputData_.ignoreFlags = 0x01;
 123   if ( midiTime ) inputData_.ignoreFlags |= 0x02;
 124   if ( midiSense ) inputData_.ignoreFlags |= 0x04;
 125 }
 126
 127 double RtMidiIn :: getMessage( std::vector<unsigned char> *message )
 128 {
 129   message->clear();
 130
 131   if ( inputData_.usingCallback ) {
 132     errorString_ = "RtMidiIn::getNextMessage: user callback is currently set for this port.";
 133     error( RtError::WARNING );
 134     return 0.0;
 135   }
 136
 137   if ( inputData_.queue.size() == 0 ) return 0.0;
 138
 139   // Copy queued message to the vector pointer argument and then "pop" it.
 140   std::vector<unsigned char> *bytes = &(inputData_.queue.front().bytes);
 141   message->assign( bytes->begin(), bytes->end() );
 142   double deltaTime = inputData_.queue.front().timeStamp;
 143   inputData_.queue.pop();
 144
 145   return deltaTime;
 146 }
 147
 148 //*********************************************************************//
 149 //  Common RtMidiOut Definitions
 150 //*********************************************************************//
 151
 152 RtMidiOut :: RtMidiOut() : RtMidi()
 153 {
 154   this->initialize();
 155 }
 156
 157
 158 //*********************************************************************//
 159 //  API: Macintosh OS-X
 160 //*********************************************************************//
 161
 162 // API information found at:
 163 //   - http://developer. apple .com/audio/pdf/coreaudio.pdf
 164
 165 #if defined(__MACOSX_CORE__)
 166
 167 // The CoreMIDI API is based on the use of a callback function for
 168 // MIDI input.  We convert the system specific time stamps to delta
 169 // time values.
 170
 171 // OS-X CoreMIDI header files.
 172 #include <CoreMIDI/CoreMIDI.h>
 173 #include <CoreAudio/HostTime.h>
 174
 175 // CoreMIDI naming helper function prototypes
 176 static void readable_name(MIDIEndpointRef end, char *buffer, int bufsize);
 177 static int get_device_name(SInt32 uniqueid, char*buffer, int bufsize);
 178
 179 // A structure to hold variables related to the CoreMIDI API
 180 // implementation.
 181 struct CoreMidiData {
 182   MIDIClientRef client;
 183   MIDIPortRef port;
 184   MIDIEndpointRef endpoint;
 185   MIDIEndpointRef destinationId;
 186   unsigned long long lastTime;
 187 };
 188
 189 // ******
 190 // API: OS-X
 191 // helper functions
 192 // *****
 193
 194 // coreMIDI port naming helper function
 195 /*
 196   This wraps up the code to take a passed-in endpoint and work out
 197   a nice human-readable name for it.
 198
 199   For the moment, this function will return firstly the device name +
 200   port name, or if we can work out what external devices are hooked
 201   in, that name. It only grabs the very first connected device name.
 202
 203   NB. won't get connected devices correctly before 10.3.
 204 */
 205 static void readable_name(MIDIEndpointRef end, char *buffer, int bufsize)
 206 {
 207     MIDIEntityRef ent = NULL;
 208     MIDIDeviceRef dev = NULL;
 209     int ii, count, length, ret;
 210     SInt32 *idarray;
 211     CFDataRef data = NULL;
 212     CFStringRef s;
 213
 214     buffer[0] = '\0';
 215
 216     if( MIDIObjectGetDataProperty(end, kMIDIPropertyConnectionUniqueID, &data) == 0)
 217     {
 218         length = CFDataGetLength(data) / sizeof(SInt32);
 219         idarray = (SInt32 *) CFDataGetBytePtr(data);
 220         count = 0;
 221         for (ii = 0; ii < length; ii++) {
 222             if (bufsize < 3)
 223                 break;
 224             if (count > 0) {
 225                 strcpy(buffer, ", ");
 226                 buffer += 2;
 227                 bufsize -= 2;
 228             }
 229
 230             if (get_device_name(idarray[ii], buffer, bufsize) == 0) {
 231                 count++;
 232                 bufsize -= strlen(buffer);
 233                 buffer += strlen(buffer);
 234             }
 235         }
 236
 237         CFRelease(data);
 238         if (count > 0)
 239             return;
 240     }
 241
 242     char * mid = buffer;
 243     // build up the name of the enclosing device, if it can be found.
 244     if (MIDIEndpointGetEntity(end, &ent) == 0) {
 245         if (MIDIEntityGetDevice(ent, &dev) == 0) {
 246             if (MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &s) == 0) {
 247                 CFStringGetCString(s, buffer, bufsize, 0);
 248                 bufsize -= strlen(buffer) + 1;
 249                 buffer += strlen(buffer);
 250
 251                 CFRelease(s);
 252             }
 253         }
 254     }
 255
 256     // ge
 257     char buffy[128];
 258     // Now add the port/endpoint name.
 259     // no need to update buffer pointer. Last item.
 260     if (MIDIObjectGetStringProperty(end, kMIDIPropertyName, &s) == 0) {
 261         CFStringGetCString(s, buffy, 128, 0);
 262         CFRelease(s);
 263
 264         // copy if different
 265         if( strcmp( mid, buffy ) && strlen(buffy) < bufsize ) {
 266             *buffer = ' ';
 267             buffer++;
 268             strcpy( buffer, buffy );
 269         }
 270     }
 271 }
 272
 273
 274 // port naming helper function (External devices)
 275 /*
 276   Uses the midiojectfindbyuniqueid function to hunt down the relevant
 277   device and copies its name into the buffer provided. We don't know
 278   what type of device we'll get back, so we first throw away any
 279   external flags (We don't care), and then cast it up to device which
 280   is the thing which has a useful name.
 281
 282   If it can't find one, return -1. 0 returned on success.
 283 */
 284 static int get_device_name(SInt32 uniqueid, char *buffer, int bufsize)
 285 {
 286     int ret;
 287     void *object;
 288     MIDIObjectType type;
 289
 290     MIDIDeviceRef dev = NULL;
 291     MIDIEntityRef ent = NULL;
 292     MIDIEndpointRef end = NULL;
 293     CFStringRef name = NULL;
 294
 295     ret = MIDIObjectFindByUniqueID(uniqueid, &object, &type);
 296     if (ret < 0)
 297         return -1;
 298
 299     // now clear any external flag.
 300     if (type > 0)
 301         type = type & (~kMIDIObjectType_ExternalMask);
 302
 303     if (type == kMIDIObjectType_Device) {
 304         dev = (MIDIDeviceRef) object;
 305     } else  if (type == kMIDIObjectType_Entity) {
 306         ent = (MIDIEntityRef) object;
 307         if (MIDIEntityGetDevice(ent, &dev)) {
 308             return -1;
 309         }
 310     } if (type == kMIDIObjectType_Source ||
 311         type == kMIDIObjectType_Destination) {
 312         end = (MIDIEndpointRef) object;
 313         if (MIDIEndpointGetEntity(end, &ent)) {
 314             return -1;
 315         }
 316         if (MIDIEntityGetDevice(ent, &dev)) {
 317             return -1;
 318         }
 319     } else {
 320         // unknown type
 321         printf("Unknown type %d returned from findobject\n", (int) type);
 322         CFRelease(object);
 323         return -1;
 324     }
 325
 326     MIDIObjectGetStringProperty(dev, kMIDIPropertyName, &name);
 327     CFStringGetCString(name, buffer, bufsize, 0);
 328     CFRelease(name);
 329
 330     return 0;
 331 }
 332
 333
 334
 335
 336
 337 //*********************************************************************//
 338 //  API: OS-X
 339 //  Class Definitions: RtMidiIn
 340 //*********************************************************************//
 341
 342 void midiInputCallback( const MIDIPacketList *list, void *procRef, void *srcRef )
 343 {
 344   RtMidiIn::RtMidiInData *data = static_cast<RtMidiIn::RtMidiInData *> (procRef);
 345   CoreMidiData *apiData = static_cast<CoreMidiData *> (data->apiData);
 346
 347   bool continueSysex = false;
 348   unsigned char status;
 349   unsigned short nBytes, iByte, size;
 350   unsigned long long time;
 351   RtMidiIn::MidiMessage message;
 352   const MIDIPacket *packet = &list->packet[0];
 353   for ( unsigned int i=0; i<list->numPackets; ++i ) {
 354
 355     // My interpretation of the CoreMIDI documentation: all message
 356     // types, except sysex, are complete within a packet and there may
 357     // be several of them in a single packet.  Sysex messages can be
 358     // broken across multiple packets but are bundled alone within a
 359     // packet.  I'm assuming that sysex messages, if segmented, must
 360     // be complete within the same MIDIPacketList.
 361
 362     nBytes = packet->length;
 363     if ( nBytes == 0 ) continue;
 364
 365     // Calculate time stamp.
 366     message.timeStamp = 0.0;
 367     if ( data->firstMessage )
 368       data->firstMessage = false;
 369     else {
 370       time = packet->timeStamp;
 371       time -= apiData->lastTime;
 372       time = AudioConvertHostTimeToNanos( time );
 373       message.timeStamp = time * 0.000000001;
 374     }
 375     apiData->lastTime = packet->timeStamp;
 376
 377     iByte = 0;
 378     if ( continueSysex ) {
 379       // We have a continuing, segmented sysex message.
 380       if ( !(data->ignoreFlags & 0x01) ) {
 381         // If we're not ignoring sysex messages, copy the entire packet.
 382         for ( unsigned int j=0; j<nBytes; j++ )
 383           message.bytes.push_back( packet->data[j] );
 384       }
 385       if ( packet->data[nBytes] == 0xF7 ) continueSysex = false;
 386       if ( !continueSysex ) {
 387         // If not a continuing sysex message, invoke the user callback function or queue the message.
 388         if ( data->usingCallback && message.bytes.size() > 0 ) {
 389           RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
 390           callback( message.timeStamp, &message.bytes, data->userData );
 391         }
 392         else {
 393           // As long as we haven't reached our queue size limit, push the message.
 394           if ( data->queueLimit > data->queue.size() )
 395             data->queue.push( message );
 396           else
 397             std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
 398         }
 399         message.bytes.clear();
 400       }
 401     }
 402     else {
 403       while ( iByte < nBytes ) {
 404         size = 0;
 405         // We are expecting that the next byte in the packet is a status byte.
 406         status = packet->data[iByte];
 407         if ( !(status & 0x80) ) break;
 408         // Determine the number of bytes in the MIDI message.
 409         if ( status < 0xC0 ) size = 3;
 410         else if ( status < 0xE0 ) size = 2;
 411         else if ( status < 0xF0 ) size = 3;
 412         else if ( status == 0xF0 ) {
 413           // A MIDI sysex
 414           if ( data->ignoreFlags & 0x01 ) {
 415             size = 0;
 416             iByte = nBytes;
 417           }
 418           else size = nBytes - iByte;
 419           if ( packet->data[nBytes] == 0xF7 ) continueSysex = false;
 420         }
 421         else if ( status < 0xF3 ) {
 422           if ( status == 0xF1 && (data->ignoreFlags & 0x02) ) {
 423             // A MIDI time code message and we're ignoring it.
 424             size = 0;
 425             iByte += 3;
 426           }
 427           else size = 3;
 428         }
 429         else if ( status == 0xF3 ) size = 2;
 430         else if ( status == 0xF8 ) {
 431           size = 1;
 432           if ( data->ignoreFlags & 0x02 ) {
 433             // A MIDI timing tick message and we're ignoring it.
 434             size = 0;
 435             iByte += 3;
 436           }
 437         }
 438         else if ( status == 0xFE && (data->ignoreFlags & 0x04) ) {
 439           // A MIDI active sensing message and we're ignoring it.
 440           size = 0;
 441           iByte += 1;
 442         }
 443         else size = 1;
 444
 445         // Copy the MIDI data to our vector.
 446         if ( size ) {
 447           message.bytes.assign( &packet->data[iByte], &packet->data[iByte+size] );
 448           if ( !continueSysex ) {
 449             // If not a continuing sysex message, invoke the user callback function or queue the message.
 450             if ( data->usingCallback ) {
 451               RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
 452               callback( message.timeStamp, &message.bytes, data->userData );
 453             }
 454             else {
 455               // As long as we haven't reached our queue size limit, push the message.
 456               if ( data->queueLimit > data->queue.size() )
 457                 data->queue.push( message );
 458               else
 459                 std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
 460             }
 461             message.bytes.clear();
 462           }
 463           iByte += size;
 464         }
 465       }
 466     }
 467     packet = MIDIPacketNext(packet);
 468   }
 469 }
 470
 471 void RtMidiIn :: initialize( void )
 472 {
 473   // Set up our client.
 474   MIDIClientRef client;
 475   OSStatus result = MIDIClientCreate( CFSTR("RtMidi Input Client"), NULL, NULL, &client );
 476   if ( result != noErr ) {
 477     errorString_ = "RtMidiIn::initialize: error creating OS-X MIDI client object.";
 478     error( RtError::DRIVER_ERROR );
 479   }
 480
 481   // Save our api-specific connection information.
 482   CoreMidiData *data = (CoreMidiData *) new CoreMidiData;
 483   data->client = client;
 484   data->endpoint = 0;
 485   apiData_ = (void *) data;
 486   inputData_.apiData = (void *) data;
 487 }
 488
 489 void RtMidiIn :: openPort( unsigned int portNumber )
 490 {
 491   if ( connected_ ) {
 492     errorString_ = "RtMidiIn::openPort: a valid connection already exists!";
 493     error( RtError::WARNING );
 494     return;
 495   }
 496
 497   unsigned int nSrc = MIDIGetNumberOfSources();
 498   if (nSrc < 1) {
 499     errorString_ = "RtMidiIn::openPort: no MIDI input sources found!";
 500     error( RtError::NO_DEVICES_FOUND );
 501   }
 502
 503   std::ostringstream ost;
 504   if ( portNumber >= nSrc ) {
 505     ost << "RtMidiIn::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
 506     errorString_ = ost.str();
 507     error( RtError::INVALID_PARAMETER );
 508   }
 509
 510   MIDIPortRef port;
 511   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 512   OSStatus result = MIDIInputPortCreate( data->client, CFSTR("RtMidi MIDI Input Port"), midiInputCallback, (void *)&inputData_, &port );
 513   if ( result != noErr ) {
 514     MIDIClientDispose( data->client );
 515     errorString_ = "RtMidiIn::openPort: error creating OS-X MIDI input port.";
 516     error( RtError::DRIVER_ERROR );
 517   }
 518
 519   // Get the desired input source identifier.
 520   MIDIEndpointRef endpoint = MIDIGetSource( portNumber );
 521   if ( endpoint == NULL ) {
 522     MIDIPortDispose( port );
 523     MIDIClientDispose( data->client );
 524     errorString_ = "RtMidiIn::openPort: error getting MIDI input source reference.";
 525     error( RtError::DRIVER_ERROR );
 526   }
 527
 528   // Make the connection.
 529   result = MIDIPortConnectSource( port, endpoint, NULL );
 530   if ( result != noErr ) {
 531     MIDIPortDispose( port );
 532     MIDIClientDispose( data->client );
 533     errorString_ = "RtMidiIn::openPort: error connecting OS-X MIDI input port.";
 534     error( RtError::DRIVER_ERROR );
 535   }
 536
 537   // Save our api-specific port information.
 538   data->port = port;
 539
 540   connected_ = true;
 541 }
 542
 543 void RtMidiIn :: openVirtualPort()
 544 {
 545   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 546
 547   // Create a virtual MIDI input destination.
 548   MIDIEndpointRef endpoint;
 549   OSStatus result = MIDIDestinationCreate( data->client, CFSTR("RtMidi Input"), midiInputCallback, (void *)&inputData_, &endpoint );
 550   if ( result != noErr ) {
 551     errorString_ = "RtMidiIn::openVirtualPort: error creating virtual OS-X MIDI destination.";
 552     error( RtError::DRIVER_ERROR );
 553   }
 554
 555   // Save our api-specific connection information.
 556   data->endpoint = endpoint;
 557 }
 558
 559 void RtMidiIn :: closePort( void )
 560 {
 561   if ( connected_ ) {
 562     CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 563     MIDIPortDispose( data->port );
 564     connected_ = false;
 565   }
 566 }
 567
 568 RtMidiIn :: ~RtMidiIn()
 569 {
 570   // Close a connection if it exists.
 571   closePort();
 572
 573   // Cleanup.
 574   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 575   MIDIClientDispose( data->client );
 576   if ( data->endpoint ) MIDIEndpointDispose( data->endpoint );
 577   delete data;
 578 }
 579
 580 unsigned int RtMidiIn :: getPortCount()
 581 {
 582   return MIDIGetNumberOfSources();
 583 }
 584
 585 std::string RtMidiIn :: getPortName( unsigned int portNumber )
 586 {
 587   CFStringRef nameRef;
 588   MIDIEndpointRef portRef;
 589   std::ostringstream ost;
 590   char name[128];
 591
 592   if ( portNumber >= MIDIGetNumberOfSources() ) {
 593     ost << "RtMidiIn::getPortName: 'portNumber' argument (" << portNumber << ") is invalid.";
 594     errorString_ = ost.str();
 595     error( RtError::INVALID_PARAMETER );
 596   }
 597   portRef = MIDIGetSource( portNumber );
 598 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
 599   readable_name(portRef, name, sizeof(name));
 600 #else
 601   MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &nameRef );
 602   CFStringGetCString( nameRef, name, sizeof(name), 0);
 603   CFRelease( nameRef );
 604 #endif
 605   std::string stringName = name;
 606   return stringName;
 607 }
 608
 609 //*********************************************************************//
 610 //  API: OS-X
 611 //  Class Definitions: RtMidiOut
 612 //*********************************************************************//
 613
 614 unsigned int RtMidiOut :: getPortCount()
 615 {
 616   return MIDIGetNumberOfDestinations();
 617 }
 618
 619 std::string RtMidiOut :: getPortName( unsigned int portNumber )
 620 {
 621   CFStringRef nameRef;
 622   MIDIEndpointRef portRef;
 623   std::ostringstream ost;
 624   char name[128];
 625
 626   if ( portNumber >= MIDIGetNumberOfDestinations() ) {
 627     ost << "RtMidiOut::getPortName: 'portNumber' argument (" << portNumber << ") is invalid.";
 628     errorString_ = ost.str();
 629     error( RtError::INVALID_PARAMETER );
 630   }
 631   portRef = MIDIGetDestination( portNumber );
 632 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
 633   readable_name(portRef, name, sizeof(name));
 634 #else
 635   MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &nameRef );
 636   CFStringGetCString( nameRef, name, sizeof(name), 0);
 637   CFRelease( nameRef );
 638 #endif
 639   std::string stringName = name;
 640   return stringName;
 641 }
 642
 643 void RtMidiOut :: initialize( void )
 644 {
 645   // Set up our client.
 646   MIDIClientRef client;
 647   OSStatus result = MIDIClientCreate( CFSTR("RtMidi Output Client"), NULL, NULL, &client );
 648   if ( result != noErr ) {
 649     errorString_ = "RtMidiOut::initialize: error creating OS-X MIDI client object.";
 650     error( RtError::DRIVER_ERROR );
 651   }
 652
 653   // Save our api-specific connection information.
 654   CoreMidiData *data = (CoreMidiData *) new CoreMidiData;
 655   data->client = client;
 656   data->endpoint = 0;
 657   apiData_ = (void *) data;
 658 }
 659
 660 void RtMidiOut :: openPort( unsigned int portNumber )
 661 {
 662   if ( connected_ ) {
 663     errorString_ = "RtMidiOut::openPort: a valid connection already exists!";
 664     error( RtError::WARNING );
 665     return;
 666   }
 667
 668   unsigned int nDest = MIDIGetNumberOfDestinations();
 669   if (nDest < 1) {
 670     errorString_ = "RtMidiOut::openPort: no MIDI output destinations found!";
 671     error( RtError::NO_DEVICES_FOUND );
 672   }
 673
 674   std::ostringstream ost;
 675   if ( portNumber >= nDest ) {
 676     ost << "RtMidiOut::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
 677     errorString_ = ost.str();
 678     error( RtError::INVALID_PARAMETER );
 679   }
 680
 681   MIDIPortRef port;
 682   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 683   OSStatus result = MIDIOutputPortCreate( data->client, CFSTR("RtMidi Virtual MIDI Output Port"), &port );
 684   if ( result != noErr ) {
 685     MIDIClientDispose( data->client );
 686     errorString_ = "RtMidiOut::openPort: error creating OS-X MIDI output port.";
 687     error( RtError::DRIVER_ERROR );
 688   }
 689
 690   // Get the desired output port identifier.
 691   MIDIEndpointRef destination = MIDIGetDestination( portNumber );
 692   if ( destination == NULL ) {
 693     MIDIPortDispose( port );
 694     MIDIClientDispose( data->client );
 695     errorString_ = "RtMidiOut::openPort: error getting MIDI output destination reference.";
 696     error( RtError::DRIVER_ERROR );
 697   }
 698
 699   // Save our api-specific connection information.
 700   data->port = port;
 701   data->destinationId = destination;
 702   connected_ = true;
 703 }
 704
 705 void RtMidiOut :: closePort( void )
 706 {
 707   if ( connected_ ) {
 708     CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 709     MIDIPortDispose( data->port );
 710     connected_ = false;
 711   }
 712 }
 713
 714 void RtMidiOut :: openVirtualPort()
 715 {
 716   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 717
 718   if ( data->endpoint ) {
 719     errorString_ = "RtMidiOut::openVirtualPort: a virtual output port already exists!";
 720     error( RtError::WARNING );
 721     return;
 722   }
 723
 724   // Create a virtual MIDI output source.
 725   MIDIEndpointRef endpoint;
 726   OSStatus result = MIDISourceCreate( data->client, CFSTR("RtMidi Output"), &endpoint );
 727   if ( result != noErr ) {
 728     errorString_ = "RtMidiOut::initialize: error creating OS-X virtual MIDI source.";
 729     error( RtError::DRIVER_ERROR );
 730   }
 731
 732   // Save our api-specific connection information.
 733   data->endpoint = endpoint;
 734 }
 735
 736 RtMidiOut :: ~RtMidiOut()
 737 {
 738   // Close a connection if it exists.
 739   closePort();
 740
 741   // Cleanup.
 742   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 743   MIDIClientDispose( data->client );
 744   if ( data->endpoint ) MIDIEndpointDispose( data->endpoint );
 745   delete data;
 746 }
 747
 748 void RtMidiOut :: sendMessage( std::vector<unsigned char> *message )
 749 {
 750   unsigned int nBytes = message->size();
 751   // Pad the buffer for extra (unknown) structure data.
 752   Byte buffer[nBytes+32];
 753   MIDIPacketList *pktlist = (MIDIPacketList *) buffer;
 754   MIDIPacket *curPacket = MIDIPacketListInit( pktlist );
 755
 756   MIDITimeStamp timeStamp = 0;
 757   curPacket = MIDIPacketListAdd( pktlist, sizeof(buffer), curPacket, timeStamp, nBytes, &message->at(0) );
 758
 759   CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
 760
 761   // Send to any destinations that may have connected to us.
 762   OSStatus result;
 763   if ( data->endpoint ) {
 764     result = MIDIReceived( data->endpoint, pktlist );
 765     if ( result != noErr ) {
 766       errorString_ = "RtMidiOut::sendMessage: error sending MIDI to virtual destinations.";
 767       error( RtError::WARNING );
 768     }
 769   }
 770
 771   // And send to an explicit destination port if we're connected.
 772   if ( connected_ ) {
 773     result = MIDISend( data->port, data->destinationId, pktlist );
 774     if ( result != noErr ) {
 775       errorString_ = "RtMidiOut::sendMessage: error sending MIDI message to port.";
 776       error( RtError::WARNING );
 777     }
 778   }
 779 }
 780
 781 #endif  // __MACOSX_CORE__
 782
 783
 784 //*********************************************************************//
 785 //  API: LINUX ALSA SEQUENCER
 786 //*********************************************************************//
 787
 788 // API information found at:
 789 //   - http://www.alsa-project.org/documentation.php#Library
 790
 791 // chuck
 792 #if defined(__LINUX_ALSASEQ__) || defined(__LINUX_ALSA__) || defined(__LINUX_JACK__)
 793
 794 // The ALSA Sequencer API is based on the use of a callback function for
 795 // MIDI input.
 796 //
 797 // Thanks to Pedro Lopez-Cabanillas for help with the ALSA sequencer
 798 // time stamps and other assorted fixes!!!
 799
 800 #include <pthread.h>
 801 #include <sys/time.h>
 802
 803 // ALSA header file.
 804 #include <alsa/asoundlib.h>
 805
 806 // A structure to hold variables related to the ALSA API
 807 // implementation.
 808 struct AlsaMidiData {
 809   snd_seq_t *seq;
 810   int vport;
 811   snd_seq_port_subscribe_t *subscription;
 812   snd_midi_event_t *coder;
 813   unsigned int bufferSize;
 814   unsigned char *buffer;
 815   pthread_t thread;
 816   unsigned long long lastTime;
 817   int queue_id; // an input queue is needed to get timestamped events
 818 };
 819
 820 #define PORT_TYPE( pinfo, bits ) ((snd_seq_port_info_get_capability(pinfo) & (bits)) == (bits))
 821
 822 //*********************************************************************//
 823 //  API: LINUX ALSA
 824 //  Class Definitions: RtMidiIn
 825 //*********************************************************************//
 826
 827 extern "C" void *alsaMidiHandler( void *ptr )
 828 {
 829   RtMidiIn::RtMidiInData *data = static_cast<RtMidiIn::RtMidiInData *> (ptr);
 830   AlsaMidiData *apiData = static_cast<AlsaMidiData *> (data->apiData);
 831
 832   long nBytes;
 833   unsigned long long time, lastTime;
 834   bool continueSysex = false;
 835   RtMidiIn::MidiMessage message;
 836
 837   snd_seq_event_t *ev;
 838   int result;
 839   apiData->bufferSize = 32;
 840   result = snd_midi_event_new( 0, &apiData->coder );
 841   if ( result < 0 ) {
 842     data->doInput = false;
 843     std::cerr << "\nRtMidiIn::alsaMidiHandler: error initializing MIDI event parser!\n\n";
 844     return 0;
 845   }
 846   unsigned char *buffer = (unsigned char *) malloc( apiData->bufferSize );
 847   if ( buffer == NULL ) {
 848     data->doInput = false;
 849     std::cerr << "\nRtMidiIn::alsaMidiHandler: error initializing buffer memory!\n\n";
 850     return 0;
 851   }
 852   snd_midi_event_init( apiData->coder );
 853   snd_midi_event_no_status( apiData->coder, 1 ); // suppress running status messages
 854
 855   while ( data->doInput ) {
 856
 857     if ( snd_seq_event_input_pending( apiData->seq, 1 ) == 0 ) {
 858       // No data pending ... sleep a bit.
 859       usleep( 1000 );
 860       continue;
 861     }
 862
 863     // If here, there should be data.
 864     result = snd_seq_event_input( apiData->seq, &ev );
 865     if ( result == -ENOSPC ) {
 866       std::cerr << "\nRtMidiIn::alsaMidiHandler: MIDI input buffer overrun!\n\n";
 867       continue;
 868     }
 869     else if ( result <= 0 ) {
 870       std::cerr << "RtMidiIn::alsaMidiHandler: unknown MIDI input error!\n";
 871       continue;
 872     }
 873
 874     // This is a bit weird, but we now have to decode an ALSA MIDI
 875     // event (back) into MIDI bytes.  We'll ignore non-MIDI types.
 876     message.bytes.clear();
 877     switch ( ev->type ) {
 878
 879         case SND_SEQ_EVENT_PORT_SUBSCRIBED:
 880 #if defined(__RTMIDI_DEBUG__)
 881       std::cout << "RtMidiIn::alsaMidiHandler: port connection made!\n";
 882 #endif
 883       break;
 884
 885         case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
 886       std::cerr << "RtMidiIn::alsaMidiHandler: port connection has closed!\n";
 887       data->doInput = false;
 888       break;
 889
 890     case SND_SEQ_EVENT_QFRAME: // MIDI time code
 891       if ( data->ignoreFlags & 0x02 ) break;
 892
 893     case SND_SEQ_EVENT_TICK: // MIDI timing tick
 894       if ( data->ignoreFlags & 0x02 ) break;
 895
 896     case SND_SEQ_EVENT_SENSING: // Active sensing
 897       if ( data->ignoreFlags & 0x04 ) break;
 898
 899         case SND_SEQ_EVENT_SYSEX:
 900       if ( (data->ignoreFlags & 0x01) ) break;
 901       if ( ev->data.ext.len > apiData->bufferSize ) {
 902         apiData->bufferSize = ev->data.ext.len;
 903         free( buffer );
 904         buffer = (unsigned char *) malloc( apiData->bufferSize );
 905         if ( buffer == NULL ) {
 906           data->doInput = false;
 907           std::cerr << "\nRtMidiIn::alsaMidiHandler: error resizing buffer memory!\n\n";
 908           break;
 909         }
 910       }
 911
 912     default:
 913       nBytes = snd_midi_event_decode( apiData->coder, buffer, apiData->bufferSize, ev );
 914       if ( nBytes <= 0 ) {
 915 #if defined(__RTMIDI_DEBUG__)
 916         std::cerr << "\nRtMidiIn::alsaMidiHandler: event parsing error or not a MIDI event!\n\n";
 917 #endif
 918         break;
 919       }
 920
 921       // The ALSA sequencer has a maximum buffer size for MIDI sysex
 922       // events of 256 bytes.  If a device sends sysex messages larger
 923       // than this, they are segmented into 256 byte chunks.  So,
 924       // we'll watch for this and concatenate sysex chunks into a
 925       // single sysex message if necessary.
 926       if ( !continueSysex )
 927         message.bytes.assign( buffer, &buffer[nBytes] );
 928       else
 929         message.bytes.insert( message.bytes.end(), buffer, &buffer[nBytes] );
 930
 931       if ( ev->type == SND_SEQ_EVENT_SYSEX && message.bytes.back() == 0xF7 )
 932         continueSysex = false;
 933       else {
 934         continueSysex = true;
 935         break;
 936       }
 937
 938       // Calculate the time stamp:
 939       message.timeStamp = 0.0;
 940
 941       // Method 1: Use the system time.
 942       //(void)gettimeofday(&tv, (struct timezone *)NULL);
 943       //time = (tv.tv_sec * 1000000) + tv.tv_usec;
 944
 945       // Method 2: Use the ALSA sequencer event time data.
 946       // (thanks to Pedro Lopez-Cabanillas!).
 947       time = ( ev->time.time.tv_sec * 1000000 ) + ( ev->time.time.tv_nsec/1000 );
 948       lastTime = time;
 949       time -= apiData->lastTime;
 950       apiData->lastTime = lastTime;
 951       if ( data->firstMessage == true )
 952         data->firstMessage = false;
 953       else
 954         message.timeStamp = time * 0.000001;
 955     }
 956
 957     snd_seq_free_event(ev);
 958     if ( message.bytes.size() == 0 ) continue;
 959
 960     if ( data->usingCallback ) {
 961       RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
 962       callback( message.timeStamp, &message.bytes, data->userData );
 963     }
 964     else {
 965       // As long as we haven't reached our queue size limit, push the message.
 966       if ( data->queueLimit > data->queue.size() )
 967         data->queue.push( message );
 968       else
 969         std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
 970     }
 971   }
 972
 973   if ( buffer ) free( buffer );
 974   snd_midi_event_free( apiData->coder );
 975   apiData->coder = 0;
 976   return 0;
 977 }
 978
 979 void RtMidiIn :: initialize( void )
 980 {
 981   // Set up the ALSA sequencer client.
 982     snd_seq_t *seq;
 983   int result = snd_seq_open(&seq, "default", SND_SEQ_OPEN_DUPLEX, SND_SEQ_NONBLOCK);
 984   if ( result < 0 ) {
 985     errorString_ = "RtMidiIn::initialize: error creating ALSA sequencer input client object.";
 986     error( RtError::DRIVER_ERROR );
 987     }
 988
 989   // Set client name.
 990   snd_seq_set_client_name(seq, "RtMidi Input Client");
 991
 992   // Save our api-specific connection information.
 993   AlsaMidiData *data = (AlsaMidiData *) new AlsaMidiData;
 994   data->seq = seq;
 995   data->vport = -1;
 996   apiData_ = (void *) data;
 997   inputData_.apiData = (void *) data;
 998
 999   // Create the input queue
1000   data->queue_id = snd_seq_alloc_named_queue(seq, "RtMidi Queue");
1001   // Set arbitrary tempo (mm=100) and resolution (240)
1002   snd_seq_queue_tempo_t *qtempo;
1003   snd_seq_queue_tempo_alloca(&qtempo);
1004   snd_seq_queue_tempo_set_tempo(qtempo, 600000);
1005   snd_seq_queue_tempo_set_ppq(qtempo, 240);
1006   snd_seq_set_queue_tempo(data->seq, data->queue_id, qtempo);
1007   snd_seq_drain_output(data->seq);
1008 }
1009
1010 // This function is used to count or get the pinfo structure for a given port number.
1011 unsigned int portInfo( snd_seq_t *seq, snd_seq_port_info_t *pinfo, unsigned int type, int portNumber )
1012 {
1013     snd_seq_client_info_t *cinfo;
1014   int client;
1015   int count = 0;
1016     snd_seq_client_info_alloca( &cinfo );
1017
1018     snd_seq_client_info_set_client( cinfo, -1 );
1019     while ( snd_seq_query_next_client( seq, cinfo ) >= 0 ) {
1020     client = snd_seq_client_info_get_client( cinfo );
1021     if ( client == 0 ) continue;
1022         // Reset query info
1023         snd_seq_port_info_set_client( pinfo, client );
1024         snd_seq_port_info_set_port( pinfo, -1 );
1025         while ( snd_seq_query_next_port( seq, pinfo ) >= 0 ) {
1026       if ( !PORT_TYPE( pinfo, type ) )  continue;
1027       if ( count == portNumber ) return 1;
1028       count++;
1029         }
1030     }
1031
1032   // If a negative portNumber was used, return the port count.
1033   if ( portNumber < 0 ) return count;
1034   return 0;
1035 }
1036
1037 void RtMidiIn :: openPort( unsigned int portNumber )
1038 {
1039   if ( connected_ ) {
1040     errorString_ = "RtMidiIn::openPort: a valid connection already exists!";
1041     error( RtError::WARNING );
1042     return;
1043   }
1044
1045   unsigned int nSrc = this->getPortCount();
1046   if (nSrc < 1) {
1047     errorString_ = "RtMidiIn::openPort: no MIDI input sources found!";
1048     error( RtError::NO_DEVICES_FOUND );
1049   }
1050
1051     snd_seq_port_info_t *pinfo;
1052     snd_seq_port_info_alloca( &pinfo );
1053   std::ostringstream ost;
1054   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1055   if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, (int) portNumber ) == 0 ) {
1056     ost << "RtMidiIn::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
1057     errorString_ = ost.str();
1058     error( RtError::INVALID_PARAMETER );
1059   }
1060
1061
1062   snd_seq_addr_t sender, receiver;
1063   sender.client = snd_seq_port_info_get_client( pinfo );
1064   sender.port = snd_seq_port_info_get_port( pinfo );
1065   receiver.client = snd_seq_client_id( data->seq );
1066   if ( data->vport < 0 ) {
1067     snd_seq_port_info_set_client( pinfo, 0 );
1068     snd_seq_port_info_set_port( pinfo, 0 );
1069     snd_seq_port_info_set_capability( pinfo,
1070                                       SND_SEQ_PORT_CAP_WRITE |
1071                                       SND_SEQ_PORT_CAP_SUBS_WRITE );
1072     snd_seq_port_info_set_type( pinfo,
1073                                 SND_SEQ_PORT_TYPE_MIDI_GENERIC |
1074                                 SND_SEQ_PORT_TYPE_APPLICATION );
1075     snd_seq_port_info_set_midi_channels(pinfo, 16);
1076     snd_seq_port_info_set_timestamping(pinfo, 1);
1077     snd_seq_port_info_set_timestamp_real(pinfo, 1);
1078     snd_seq_port_info_set_timestamp_queue(pinfo, data->queue_id);
1079     snd_seq_port_info_set_name(pinfo, "RtMidi Input");
1080     data->vport = snd_seq_create_port(data->seq, pinfo);
1081
1082     if ( data->vport < 0 ) {
1083       errorString_ = "RtMidiIn::openPort: ALSA error creating input port.";
1084       error( RtError::DRIVER_ERROR );
1085     }
1086   }
1087
1088   receiver.port = data->vport;
1089
1090   // Make subscription
1091   snd_seq_port_subscribe_malloc( &data->subscription );
1092   snd_seq_port_subscribe_set_sender(data->subscription, &sender);
1093   snd_seq_port_subscribe_set_dest(data->subscription, &receiver);
1094   if ( snd_seq_subscribe_port(data->seq, data->subscription) ) {
1095     errorString_ = "RtMidiIn::openPort: ALSA error making port connection.";
1096     error( RtError::DRIVER_ERROR );
1097   }
1098
1099   if ( inputData_.doInput == false ) {
1100     // Start the input queue
1101     snd_seq_start_queue( data->seq, data->queue_id, NULL );
1102     snd_seq_drain_output( data->seq );
1103     // Start our MIDI input thread.
1104     pthread_attr_t attr;
1105     pthread_attr_init(&attr);
1106     // chuck
1107     //pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1108     //pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
1109
1110     inputData_.doInput = true;
1111     int err = pthread_create(&data->thread, &attr, alsaMidiHandler, &inputData_);
1112     pthread_attr_destroy(&attr);
1113     if (err) {
1114       snd_seq_unsubscribe_port( data->seq, data->subscription );
1115       snd_seq_port_subscribe_free( data->subscription );
1116       inputData_.doInput = false;
1117       errorString_ = "RtMidiIn::openPort: error starting MIDI input thread!";
1118       error( RtError::THREAD_ERROR );
1119     }
1120   }
1121
1122   connected_ = true;
1123 }
1124
1125 void RtMidiIn :: openVirtualPort()
1126 {
1127   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1128   if ( data->vport < 0 ) {
1129     snd_seq_port_info_t *pinfo;
1130     snd_seq_port_info_alloca( &pinfo );
1131     snd_seq_port_info_set_capability( pinfo,
1132                       SND_SEQ_PORT_CAP_WRITE |
1133                       SND_SEQ_PORT_CAP_SUBS_WRITE );
1134     snd_seq_port_info_set_type( pinfo,
1135                 SND_SEQ_PORT_TYPE_MIDI_GENERIC |
1136                 SND_SEQ_PORT_TYPE_APPLICATION );
1137     snd_seq_port_info_set_midi_channels(pinfo, 16);
1138     snd_seq_port_info_set_timestamping(pinfo, 1);
1139     snd_seq_port_info_set_timestamp_real(pinfo, 1);
1140     snd_seq_port_info_set_timestamp_queue(pinfo, data->queue_id);
1141     snd_seq_port_info_set_name(pinfo, "RtMidi Input");
1142     data->vport = snd_seq_create_port(data->seq, pinfo);
1143
1144     if ( data->vport < 0 ) {
1145       errorString_ = "RtMidiIn::openVirtualPort: ALSA error creating virtual port.";
1146       error( RtError::DRIVER_ERROR );
1147     }
1148   }
1149
1150   if ( inputData_.doInput == false ) {
1151     // Start the input queue
1152     snd_seq_start_queue( data->seq, data->queue_id, NULL );
1153     snd_seq_drain_output( data->seq );
1154     // Start our MIDI input thread.
1155     pthread_attr_t attr;
1156     pthread_attr_init(&attr);
1157     // chuck
1158     //pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1159     //pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
1160
1161     inputData_.doInput = true;
1162     int err = pthread_create(&data->thread, &attr, alsaMidiHandler, &inputData_);
1163     pthread_attr_destroy(&attr);
1164     if (err) {
1165       snd_seq_unsubscribe_port( data->seq, data->subscription );
1166       snd_seq_port_subscribe_free( data->subscription );
1167       inputData_.doInput = false;
1168       errorString_ = "RtMidiIn::openPort: error starting MIDI input thread!";
1169       error( RtError::THREAD_ERROR );
1170     }
1171   }
1172 }
1173
1174 void RtMidiIn :: closePort( void )
1175 {
1176   if ( connected_ ) {
1177     AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1178     snd_seq_unsubscribe_port( data->seq, data->subscription );
1179     snd_seq_port_subscribe_free( data->subscription );
1180     // Stop the input queue
1181     snd_seq_stop_queue( data->seq, data->queue_id, NULL );
1182     snd_seq_drain_output( data->seq );
1183     connected_ = false;
1184   }
1185 }
1186
1187 RtMidiIn :: ~RtMidiIn()
1188 {
1189   // Close a connection if it exists.
1190   closePort();
1191
1192   // Shutdown the input thread.
1193   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1194   if ( inputData_.doInput ) {
1195     inputData_.doInput = false;
1196     pthread_join( data->thread, NULL );
1197   }
1198
1199   // Cleanup.
1200   if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
1201   snd_seq_free_queue( data->seq, data->queue_id );
1202   snd_seq_close( data->seq );
1203   delete data;
1204 }
1205
1206 unsigned int RtMidiIn :: getPortCount()
1207 {
1208     snd_seq_port_info_t *pinfo;
1209     snd_seq_port_info_alloca( &pinfo );
1210
1211   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1212   return portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, -1 );
1213 }
1214
1215 std::string RtMidiIn :: getPortName( unsigned int portNumber )
1216 {
1217     snd_seq_port_info_t *pinfo;
1218     snd_seq_port_info_alloca( &pinfo );
1219
1220   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1221   if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, (int) portNumber ) ) {
1222     std::string stringName = std::string( snd_seq_port_info_get_name( pinfo ) );
1223     return stringName;
1224   }
1225
1226   // If we get here, we didn't find a match.
1227   errorString_ = "RtMidiIn::getPortName: error looking for port name!";
1228   error( RtError::INVALID_PARAMETER );
1229   return 0;
1230 }
1231
1232 //*********************************************************************//
1233 //  API: LINUX ALSA
1234 //  Class Definitions: RtMidiOut
1235 //*********************************************************************//
1236
1237 unsigned int RtMidiOut :: getPortCount()
1238 {
1239     snd_seq_port_info_t *pinfo;
1240     snd_seq_port_info_alloca( &pinfo );
1241
1242   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1243   return portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, -1 );
1244 }
1245
1246 std::string RtMidiOut :: getPortName( unsigned int portNumber )
1247 {
1248     snd_seq_port_info_t *pinfo;
1249     snd_seq_port_info_alloca( &pinfo );
1250
1251   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1252   if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, (int) portNumber ) ) {
1253     std::string stringName = std::string( snd_seq_port_info_get_name( pinfo ) );
1254     return stringName;
1255   }
1256
1257   // If we get here, we didn't find a match.
1258   errorString_ = "RtMidiOut::getPortName: error looking for port name!";
1259   error( RtError::INVALID_PARAMETER );
1260   return 0;
1261 }
1262
1263 void RtMidiOut :: initialize( void )
1264 {
1265   // Set up the ALSA sequencer client.
1266     snd_seq_t *seq;
1267   int result = snd_seq_open(&seq, "default", SND_SEQ_OPEN_OUTPUT, 0);
1268   if ( result < 0 ) {
1269     errorString_ = "RtMidiOut::initialize: error creating ALSA sequencer client object.";
1270     error( RtError::DRIVER_ERROR );
1271     }
1272
1273   // Set client name.
1274   snd_seq_set_client_name(seq, "RtMidi Output Client");
1275
1276   // Save our api-specific connection information.
1277   AlsaMidiData *data = (AlsaMidiData *) new AlsaMidiData;
1278   data->seq = seq;
1279   data->vport = -1;
1280   data->bufferSize = 32;
1281   data->coder = 0;
1282   data->buffer = 0;
1283   result = snd_midi_event_new( data->bufferSize, &data->coder );
1284   if ( result < 0 ) {
1285     delete data;
1286     errorString_ = "RtMidiOut::initialize: error initializing MIDI event parser!\n\n";
1287     error( RtError::DRIVER_ERROR );
1288   }
1289   data->buffer = (unsigned char *) malloc( data->bufferSize );
1290   if ( data->buffer == NULL ) {
1291     delete data;
1292     errorString_ = "RtMidiOut::initialize: error allocating buffer memory!\n\n";
1293     error( RtError::MEMORY_ERROR );
1294   }
1295   snd_midi_event_init( data->coder );
1296   apiData_ = (void *) data;
1297 }
1298
1299 void RtMidiOut :: openPort( unsigned int portNumber )
1300 {
1301   if ( connected_ ) {
1302     errorString_ = "RtMidiOut::openPort: a valid connection already exists!";
1303     error( RtError::WARNING );
1304     return;
1305   }
1306
1307   unsigned int nSrc = this->getPortCount();
1308   if (nSrc < 1) {
1309     errorString_ = "RtMidiOut::openPort: no MIDI output sources found!";
1310     error( RtError::NO_DEVICES_FOUND );
1311   }
1312
1313     snd_seq_port_info_t *pinfo;
1314     snd_seq_port_info_alloca( &pinfo );
1315   std::ostringstream ost;
1316   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1317   if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, (int) portNumber ) == 0 ) {
1318     ost << "RtMidiOut::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
1319     errorString_ = ost.str();
1320     error( RtError::INVALID_PARAMETER );
1321   }
1322
1323   snd_seq_addr_t sender, receiver;
1324   receiver.client = snd_seq_port_info_get_client( pinfo );
1325   receiver.port = snd_seq_port_info_get_port( pinfo );
1326   sender.client = snd_seq_client_id( data->seq );
1327
1328   if ( data->vport < 0 ) {
1329     data->vport = snd_seq_create_simple_port( data->seq, "RtMidi Output",
1330                                               SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ,
1331                                               SND_SEQ_PORT_TYPE_MIDI_GENERIC );
1332     if ( data->vport < 0 ) {
1333       errorString_ = "RtMidiOut::openPort: ALSA error creating output port.";
1334       error( RtError::DRIVER_ERROR );
1335     }
1336   }
1337
1338   sender.port = data->vport;
1339
1340   // Make subscription
1341   snd_seq_port_subscribe_malloc( &data->subscription );
1342   snd_seq_port_subscribe_set_sender(data->subscription, &sender);
1343   snd_seq_port_subscribe_set_dest(data->subscription, &receiver);
1344   snd_seq_port_subscribe_set_time_update(data->subscription, 1);
1345   snd_seq_port_subscribe_set_time_real(data->subscription, 1);
1346   if ( snd_seq_subscribe_port(data->seq, data->subscription) ) {
1347     errorString_ = "RtMidiOut::openPort: ALSA error making port connection.";
1348     error( RtError::DRIVER_ERROR );
1349   }
1350
1351   connected_ = true;
1352 }
1353
1354 void RtMidiOut :: closePort( void )
1355 {
1356   if ( connected_ ) {
1357     AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1358     snd_seq_unsubscribe_port( data->seq, data->subscription );
1359     snd_seq_port_subscribe_free( data->subscription );
1360     connected_ = false;
1361   }
1362 }
1363
1364 void RtMidiOut :: openVirtualPort()
1365 {
1366   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1367   if ( data->vport < 0 ) {
1368     data->vport = snd_seq_create_simple_port( data->seq, "RtMidi Output",
1369                                               SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ,
1370                                               SND_SEQ_PORT_TYPE_MIDI_GENERIC );
1371
1372     if ( data->vport < 0 ) {
1373       errorString_ = "RtMidiOut::openVirtualPort: ALSA error creating virtual port.";
1374       error( RtError::DRIVER_ERROR );
1375     }
1376   }
1377 }
1378
1379 RtMidiOut :: ~RtMidiOut()
1380 {
1381   // Close a connection if it exists.
1382   closePort();
1383
1384   // Cleanup.
1385   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1386   if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
1387   if ( data->coder ) snd_midi_event_free( data->coder );
1388   if ( data->buffer ) free( data->buffer );
1389   snd_seq_close( data->seq );
1390   delete data;
1391 }
1392
1393 void RtMidiOut :: sendMessage( std::vector<unsigned char> *message )
1394 {
1395   int result;
1396   AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
1397   unsigned int nBytes = message->size();
1398   if ( nBytes > data->bufferSize ) {
1399     data->bufferSize = nBytes;
1400     result = snd_midi_event_resize_buffer ( data->coder, nBytes);
1401     if ( result != 0 ) {
1402       errorString_ = "RtMidiOut::sendMessage: ALSA error resizing MIDI event buffer.";
1403       error( RtError::DRIVER_ERROR );
1404     }
1405     free (data->buffer);
1406     data->buffer = (unsigned char *) malloc( data->bufferSize );
1407     if ( data->buffer == NULL ) {
1408     errorString_ = "RtMidiOut::initialize: error allocating buffer memory!\n\n";
1409     error( RtError::MEMORY_ERROR );
1410     }
1411   }
1412
1413   snd_seq_event_t ev;
1414   snd_seq_ev_clear(&ev);
1415   snd_seq_ev_set_source(&ev, data->vport);
1416   snd_seq_ev_set_subs(&ev);
1417   snd_seq_ev_set_direct(&ev);
1418   for ( unsigned int i=0; i<nBytes; i++ ) data->buffer[i] = message->at(i);
1419   result = snd_midi_event_encode( data->coder, data->buffer, (long)nBytes, &ev );
1420   if ( result < (int)nBytes ) {
1421     errorString_ = "RtMidiOut::sendMessage: event parsing error!";
1422     error( RtError::WARNING );
1423     return;
1424   }
1425
1426   // Send the event.
1427   result = snd_seq_event_output(data->seq, &ev);
1428   if ( result < 0 ) {
1429     errorString_ = "RtMidiOut::sendMessage: error sending MIDI message to port.";
1430     error( RtError::WARNING );
1431   }
1432   snd_seq_drain_output(data->seq);
1433 }
1434
1435 #endif // __LINUX_ALSA__
1436
1437
1438 //*********************************************************************//
1439 //  API: IRIX MD
1440 //*********************************************************************//
1441
1442 // API information gleamed from:
1443 //   http://techpubs.sgi.com/library/tpl/cgi-bin/getdoc.cgi?cmd=getdoc&coll=0650&db=man&fname=3%20mdIntro
1444
1445 // If the Makefile doesn't work, try the following:
1446 // CC -o midiinfo -LANG:std -D__IRIX_MD__ -I../ ../RtMidi.cpp midiinfo.cpp -lpthread -lmd
1447 // CC -o midiout -LANG:std -D__IRIX_MD__ -I../ ../RtMidi.cpp midiout.cpp -lpthread -lmd
1448 // CC -o qmidiin -LANG:std -D__IRIX_MD__ -I../ ../RtMidi.cpp qmidiin.cpp -lpthread -lmd
1449 // CC -o cmidiin -LANG:std -D__IRIX_MD__ -I../ ../RtMidi.cpp cmidiin.cpp -lpthread -lmd
1450
1451 #if defined(__IRIX_MD__)
1452
1453 #include <pthread.h>
1454 #include <sys/time.h>
1455 #include <unistd.h>
1456
1457 // Irix MIDI header file.
1458 #include <dmedia/midi.h>
1459
1460 // A structure to hold variables related to the IRIX API
1461 // implementation.
1462 struct IrixMidiData {
1463   MDport port;
1464   pthread_t thread;
1465 };
1466
1467 //*********************************************************************//
1468 //  API: IRIX
1469 //  Class Definitions: RtMidiIn
1470 //*********************************************************************//
1471
1472 extern "C" void *irixMidiHandler( void *ptr )
1473 {
1474   RtMidiIn::RtMidiInData *data = static_cast<RtMidiIn::RtMidiInData *> (ptr);
1475   IrixMidiData *apiData = static_cast<IrixMidiData *> (data->apiData);
1476
1477   bool continueSysex = false;
1478   unsigned char status;
1479   unsigned short size;
1480   MDevent event;
1481   int fd = mdGetFd( apiData->port );
1482   if ( fd < 0 ) {
1483     data->doInput = false;
1484     std::cerr << "\nRtMidiIn::irixMidiHandler: error getting port descriptor!\n\n";
1485     return 0;
1486   }
1487
1488   fd_set mask, rmask;
1489   FD_ZERO( &mask );
1490   FD_SET( fd, &mask );
1491   struct timeval timeout = {0, 0};
1492   RtMidiIn::MidiMessage message;
1493   int result;
1494
1495   while ( data->doInput ) {
1496
1497     rmask = mask;
1498     timeout.tv_sec = 0;
1499     timeout.tv_usec = 0;
1500     if ( select( fd+1, &rmask, NULL, NULL, &timeout ) <= 0 ) {
1501       // No data pending ... sleep a bit.
1502       usleep( 1000 );
1503       continue;
1504     }
1505
1506     // If here, there should be data.
1507     result = mdReceive( apiData->port, &event, 1);
1508     if ( result <= 0 ) {
1509       std::cerr << "\nRtMidiIn::irixMidiHandler: MIDI input read error!\n\n";
1510       continue;
1511     }
1512
1513     message.timeStamp = event.stamp * 0.000000001;
1514
1515     size = 0;
1516     status = event.msg[0];
1517     if ( !(status & 0x80) ) continue;
1518     if ( status == 0xF0 ) {
1519       // Sysex message ... can be segmented across multiple messages.
1520       if ( !(data->ignoreFlags & 0x01) ) {
1521         if ( continueSysex ) {
1522           // We have a continuing, segmented sysex message.  Append
1523           // the new bytes to our existing message.
1524           for ( int i=0; i<event.msglen; i++ )
1525             message.bytes.push_back( event.sysexmsg[i] );
1526           if ( event.sysexmsg[event.msglen-1] == 0xF7 ) continueSysex = false;
1527           if ( !continueSysex ) {
1528             // If not a continuing sysex message, invoke the user callback function or queue the message.
1529             if ( data->usingCallback && message.bytes.size() > 0 ) {
1530               RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
1531               callback( message.timeStamp, &message.bytes, data->userData );
1532             }
1533             else {
1534               // As long as we haven't reached our queue size limit, push the message.
1535               if ( data->queueLimit > data->queue.size() )
1536                 data->queue.push( message );
1537               else
1538                 std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
1539             }
1540             message.bytes.clear();
1541           }
1542         }
1543       }
1544       mdFree( NULL );
1545       continue;
1546     }
1547     else if ( status < 0xC0 ) size = 3;
1548     else if ( status < 0xE0 ) size = 2;
1549     else if ( status < 0xF0 ) size = 3;
1550     else if ( status < 0xF3 ) {
1551       if ( status == 0xF1 && !(data->ignoreFlags & 0x02) ) {
1552         // A MIDI time code message and we're not ignoring it.
1553         size = 3;
1554       }
1555     }
1556     else if ( status == 0xF3 ) size = 2;
1557     else if ( status == 0xF8 ) {
1558       if ( !(data->ignoreFlags & 0x02) ) {
1559         // A MIDI timing tick message and we're not ignoring it.
1560         size = 1;
1561       }
1562     }
1563     else if ( status == 0xFE ) { // MIDI active sensing
1564       if ( !(data->ignoreFlags & 0x04) )
1565         size = 1;
1566     }
1567     else size = 1;
1568
1569     // Copy the MIDI data to our vector.
1570     if ( size ) {
1571       message.bytes.assign( &event.msg[0], &event.msg[size] );
1572       // Invoke the user callback function or queue the message.
1573       if ( data->usingCallback ) {
1574         RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
1575         callback( message.timeStamp, &message.bytes, data->userData );
1576       }
1577       else {
1578         // As long as we haven't reached our queue size limit, push the message.
1579         if ( data->queueLimit > data->queue.size() )
1580           data->queue.push( message );
1581         else
1582           std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
1583       }
1584       message.bytes.clear();
1585     }
1586   }
1587
1588   return 0;
1589 }
1590
1591 void RtMidiIn :: initialize( void )
1592 {
1593   // Initialize the Irix MIDI system.  At the moment, we will not
1594   // worry about a return value of zero (ports) because there is a
1595   // chance the user could plug something in after instantiation.
1596   int nPorts = mdInit();
1597
1598   // Create our api-specific connection information.
1599   IrixMidiData *data = (IrixMidiData *) new IrixMidiData;
1600   apiData_ = (void *) data;
1601   inputData_.apiData = (void *) data;
1602 }
1603
1604 void RtMidiIn :: openPort( unsigned int portNumber )
1605 {
1606   if ( connected_ ) {
1607     errorString_ = "RtMidiIn::openPort: a valid connection already exists!";
1608     error( RtError::WARNING );
1609     return;
1610   }
1611
1612   int nPorts = mdInit();
1613   if (nPorts < 1) {
1614     errorString_ = "RtMidiIn::openPort: no Irix MIDI input sources found!";
1615     error( RtError::NO_DEVICES_FOUND );
1616   }
1617
1618   std::ostringstream ost;
1619   if ( portNumber >= nPorts ) {
1620     ost << "RtMidiIn::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
1621     errorString_ = ost.str();
1622     error( RtError::INVALID_PARAMETER );
1623   }
1624
1625   IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1626   data->port = mdOpenInPort( mdGetName(portNumber) );
1627   if ( data->port == NULL ) {
1628     ost << "RtMidiIn::openPort: Irix error opening the port (" << portNumber << ").";
1629     errorString_ = ost.str();
1630     error( RtError::DRIVER_ERROR );
1631   }
1632   mdSetStampMode(data->port, MD_DELTASTAMP);
1633
1634   // Start our MIDI input thread.
1635   pthread_attr_t attr;
1636   pthread_attr_init(&attr);
1637   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
1638   pthread_attr_setschedpolicy(&attr, SCHED_RR);
1639
1640   inputData_.doInput = true;
1641   int err = pthread_create(&data->thread, &attr, irixMidiHandler, &inputData_);
1642   pthread_attr_destroy(&attr);
1643   if (err) {
1644     mdClosePort( data->port );
1645     inputData_.doInput = false;
1646     errorString_ = "RtMidiIn::openPort: error starting MIDI input thread!";
1647     error( RtError::THREAD_ERROR );
1648   }
1649
1650   connected_ = true;
1651 }
1652
1653 void RtMidiIn :: openVirtualPort()
1654 {
1655   // This function cannot be implemented for the Irix MIDI API.
1656   errorString_ = "RtMidiIn::openVirtualPort: cannot be implemented in Irix MIDI API!";
1657   error( RtError::WARNING );
1658 }
1659
1660 void RtMidiIn :: closePort( void )
1661 {
1662   if ( connected_ ) {
1663     IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1664     mdClosePort( data->port );
1665     connected_ = false;
1666
1667     // Shutdown the input thread.
1668     inputData_.doInput = false;
1669     pthread_join( data->thread, NULL );
1670   }
1671 }
1672
1673 RtMidiIn :: ~RtMidiIn()
1674 {
1675   // Close a connection if it exists.
1676   closePort();
1677
1678   // Cleanup.
1679   IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1680   delete data;
1681 }
1682
1683 unsigned int RtMidiIn :: getPortCount()
1684 {
1685   int nPorts = mdInit();
1686   if ( nPorts >= 0 ) return nPorts;
1687   else return 0;
1688 }
1689
1690 std::string RtMidiIn :: getPortName( unsigned int portNumber )
1691 {
1692   int nPorts = mdInit();
1693
1694   std::ostringstream ost;
1695   if ( portNumber >= nPorts ) {
1696     ost << "RtMidiIn::getPortName: 'portNumber' argument (" << portNumber << ") is invalid.";
1697     errorString_ = ost.str();
1698     error( RtError::INVALID_PARAMETER );
1699   }
1700
1701   std::string stringName = std::string( mdGetName( portNumber ) );
1702   return stringName;
1703 }
1704
1705 //*********************************************************************//
1706 //  API: IRIX MD
1707 //  Class Definitions: RtMidiOut
1708 //*********************************************************************//
1709
1710 unsigned int RtMidiOut :: getPortCount()
1711 {
1712   int nPorts = mdInit();
1713   if ( nPorts >= 0 ) return nPorts;
1714   else return 0;
1715 }
1716
1717 std::string RtMidiOut :: getPortName( unsigned int portNumber )
1718 {
1719   int nPorts = mdInit();
1720
1721   std::ostringstream ost;
1722   if ( portNumber >= nPorts ) {
1723     ost << "RtMidiIn::getPortName: 'portNumber' argument (" << portNumber << ") is invalid.";
1724     errorString_ = ost.str();
1725     error( RtError::INVALID_PARAMETER );
1726   }
1727
1728   std::string stringName = std::string( mdGetName( portNumber ) );
1729   return stringName;
1730 }
1731
1732 void RtMidiOut :: initialize( void )
1733 {
1734   // Initialize the Irix MIDI system.  At the moment, we will not
1735   // worry about a return value of zero (ports) because there is a
1736   // chance the user could plug something in after instantiation.
1737   int nPorts = mdInit();
1738
1739   // Create our api-specific connection information.
1740   IrixMidiData *data = (IrixMidiData *) new IrixMidiData;
1741   apiData_ = (void *) data;
1742 }
1743
1744 void RtMidiOut :: openPort( unsigned int portNumber )
1745 {
1746   if ( connected_ ) {
1747     errorString_ = "RtMidiOut::openPort: a valid connection already exists!";
1748     error( RtError::WARNING );
1749     return;
1750   }
1751
1752   int nPorts = mdInit();
1753   if (nPorts < 1) {
1754     errorString_ = "RtMidiOut::openPort: no Irix MIDI output sources found!";
1755     error( RtError::NO_DEVICES_FOUND );
1756   }
1757
1758   std::ostringstream ost;
1759   if ( portNumber >= nPorts ) {
1760     ost << "RtMidiOut::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
1761     errorString_ = ost.str();
1762     error( RtError::INVALID_PARAMETER );
1763   }
1764
1765   IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1766   data->port = mdOpenOutPort( mdGetName(portNumber) );
1767   if ( data->port == NULL ) {
1768     ost << "RtMidiOut::openPort: Irix error opening the port (" << portNumber << ").";
1769     errorString_ = ost.str();
1770     error( RtError::DRIVER_ERROR );
1771   }
1772   mdSetStampMode(data->port, MD_NOSTAMP);
1773
1774   connected_ = true;
1775 }
1776
1777 void RtMidiOut :: closePort( void )
1778 {
1779   if ( connected_ ) {
1780     IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1781     mdClosePort( data->port );
1782     connected_ = false;
1783   }
1784 }
1785
1786 void RtMidiOut :: openVirtualPort()
1787 {
1788   // This function cannot be implemented for the Irix MIDI API.
1789   errorString_ = "RtMidiOut::openVirtualPort: cannot be implemented in Irix MIDI API!";
1790   error( RtError::WARNING );
1791 }
1792
1793 RtMidiOut :: ~RtMidiOut()
1794 {
1795   // Close a connection if it exists.
1796   closePort();
1797
1798   // Cleanup.
1799   IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1800   delete data;
1801 }
1802
1803 void RtMidiOut :: sendMessage( std::vector<unsigned char> *message )
1804 {
1805   int result;
1806   MDevent event;
1807   IrixMidiData *data = static_cast<IrixMidiData *> (apiData_);
1808   char *buffer = 0;
1809
1810   unsigned int nBytes = message->size();
1811   if ( nBytes == 0 ) return;
1812   event.stamp = 0;
1813   if ( message->at(0) == 0xF0 ) {
1814     if ( nBytes < 3 ) return; // check for bogus sysex
1815     event.msg[0] = 0xF0;
1816     event.msglen = nBytes;
1817     buffer = (char *) malloc( nBytes );
1818     for ( int i=0; i<nBytes; i++ ) buffer[i] = message->at(i);
1819     event.sysexmsg = buffer;
1820   }
1821   else {
1822     for ( int i=0; i<nBytes; i++ )
1823       event.msg[i] = message->at(i);
1824   }
1825
1826   // Send the event.
1827   result = mdSend( data->port, &event, 1 );
1828   if ( buffer ) free( buffer );
1829   if ( result < 1 ) {
1830     errorString_ = "RtMidiOut::sendMessage: IRIX error sending MIDI message!";
1831     error( RtError::WARNING );
1832     return;
1833   }
1834 }
1835
1836 #endif // __IRIX_MD__
1837
1838 //*********************************************************************//
1839 //  API: Windows Multimedia Library (MM)
1840 //*********************************************************************//
1841
1842 // API information deciphered from:
1843 //  - http://msdn.microsoft.com/library/default.asp?url=/library/en-us/multimed/htm/_win32_midi_reference.asp
1844
1845 // chuck
1846 #if defined(__WINDOWS_DS__)
1847 //#if defined(__WINDOWS_MM__)
1848
1849 // The Windows MM API is based on the use of a callback function for
1850 // MIDI input.  We convert the system specific time stamps to delta
1851 // time values.
1852
1853 // Windows MM MIDI header files.
1854 #include <windows.h>
1855 #include <mmsystem.h>
1856
1857 // A structure to hold variables related to the CoreMIDI API
1858 // implementation.
1859 struct WinMidiData {
1860   HMIDIIN inHandle;    // Handle to Midi Input Device
1861   HMIDIOUT outHandle;  // Handle to Midi Output Device
1862   DWORD lastTime;
1863   RtMidiIn::MidiMessage message;
1864 };
1865
1866 //*********************************************************************//
1867 //  API: Windows MM
1868 //  Class Definitions: RtMidiIn
1869 //*********************************************************************//
1870
1871 static void CALLBACK midiInputCallback( HMIDIOUT hmin,
1872                                         UINT inputStatus,
1873                                         DWORD instancePtr,
1874                                         DWORD midiMessage,
1875                                         DWORD timestamp )
1876 {
1877   if ( inputStatus != MIM_DATA && inputStatus != MIM_LONGDATA ) return;
1878
1879   //RtMidiIn::RtMidiInData *data = static_cast<RtMidiIn::RtMidiInData *> (instancePtr);
1880   RtMidiIn::RtMidiInData *data = (RtMidiIn::RtMidiInData *)instancePtr;
1881   WinMidiData *apiData = static_cast<WinMidiData *> (data->apiData);
1882
1883   // Calculate time stamp.
1884   apiData->message.timeStamp = 0.0;
1885   if ( data->firstMessage == true ) data->firstMessage = false;
1886   else apiData->message.timeStamp = (double) ( timestamp - apiData->lastTime ) * 0.001;
1887   apiData->lastTime = timestamp;
1888
1889   if ( inputStatus == MIM_DATA ) { // Channel or system message
1890
1891     // Make sure the first byte is a status byte.
1892     unsigned char status = (unsigned char) (midiMessage & 0x000000FF);
1893     if ( !(status & 0x80) ) return;
1894
1895     // Determine the number of bytes in the MIDI message.
1896     unsigned short nBytes = 1;
1897     if ( status < 0xC0 ) nBytes = 3;
1898     else if ( status < 0xE0 ) nBytes = 2;
1899     else if ( status < 0xF0 ) nBytes = 3;
1900     else if ( status < 0xF3 ) {
1901       // A MIDI time code message and we're ignoring it.
1902       if ( status == 0xF1 && (data->ignoreFlags & 0x02) ) return;
1903       nBytes = 3;
1904     }
1905     else if ( status == 0xF3 ) nBytes = 2;
1906     else if ( status == 0xF8 && (data->ignoreFlags & 0x02) ) {
1907       // A MIDI timing tick message and we're ignoring it.
1908       return;
1909     }
1910     else if ( status == 0xFE && (data->ignoreFlags & 0x04) ) {
1911       // A MIDI active sensing message and we're ignoring it.
1912       return;
1913     }
1914
1915     // Copy bytes to our MIDI message.
1916     unsigned char *ptr = (unsigned char *) &midiMessage;
1917     for ( int i=0; i<nBytes; i++ ) apiData->message.bytes.push_back( *ptr++ );
1918   }
1919   else { // Sysex message
1920     MIDIHDR *sysex = ( MIDIHDR *) midiMessage;
1921     for ( int i=0; i<(int)sysex->dwBytesRecorded; i++ )
1922       apiData->message.bytes.push_back( sysex->lpData[i] );
1923     if ( apiData->message.bytes.back() != 0xF7 ) return;
1924   }
1925
1926   if ( data->usingCallback ) {
1927     RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
1928     callback( apiData->message.timeStamp, &apiData->message.bytes, data->userData );
1929   }
1930   else {
1931     // As long as we haven't reached our queue size limit, push the message.
1932     if ( data->queueLimit > data->queue.size() )
1933       data->queue.push( apiData->message );
1934     else
1935       std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
1936   }
1937
1938   // Clear the vector for the next input message.  Note that doing
1939   // this here allows our code to work for sysex messages which are
1940   // segmented across multiple buffers.
1941   apiData->message.bytes.clear();
1942 }
1943
1944 void RtMidiIn :: initialize( void )
1945 {
1946   // We'll issue a warning here if no devices are available but not
1947   // throw an error since the user can plugin something later.
1948   unsigned int nDevices = midiInGetNumDevs();
1949   if ( nDevices == 0 ) {
1950     errorString_ = "RtMidiIn::initialize: no MIDI input devices currently available.";
1951     error( RtError::WARNING );
1952   }
1953
1954   // Save our api-specific connection information.
1955   WinMidiData *data = (WinMidiData *) new WinMidiData;
1956   apiData_ = (void *) data;
1957   inputData_.apiData = (void *) data;
1958   data->message.bytes.clear();  // needs to be empty for first input message
1959 }
1960
1961 void RtMidiIn :: openPort( unsigned int portNumber )
1962 {
1963   if ( connected_ ) {
1964     errorString_ = "RtMidiIn::openPort: a valid connection already exists!";
1965     error( RtError::WARNING );
1966     return;
1967   }
1968
1969   unsigned int nDevices = midiInGetNumDevs();
1970   if (nDevices == 0) {
1971     errorString_ = "RtMidiIn::openPort: no MIDI input sources found!";
1972     error( RtError::NO_DEVICES_FOUND );
1973   }
1974
1975   std::ostringstream ost;
1976   if ( portNumber >= nDevices ) {
1977     ost << "RtMidiIn::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
1978     errorString_ = ost.str();
1979     error( RtError::INVALID_PARAMETER );
1980   }
1981
1982   WinMidiData *data = static_cast<WinMidiData *> (apiData_);
1983   MMRESULT result = midiInOpen( &data->inHandle,
1984                                 portNumber,
1985                                 (DWORD)&midiInputCallback,
1986                                 (DWORD)&inputData_,
1987                                 CALLBACK_FUNCTION );
1988   if ( result != MMSYSERR_NOERROR ) {
1989     errorString_ = "RtMidiIn::openPort: error creating Windows MM MIDI input port.";
1990     error( RtError::DRIVER_ERROR );
1991   }
1992
1993   result = midiInStart( data->inHandle );
1994   if ( result != MMSYSERR_NOERROR ) {
1995     midiInClose( data->inHandle );
1996     errorString_ = "RtMidiIn::openPort: error starting Windows MM MIDI input port.";
1997     error( RtError::DRIVER_ERROR );
1998   }
1999
2000   connected_ = true;
2001 }
2002
2003 void RtMidiIn :: openVirtualPort()
2004 {
2005   // This function cannot be implemented for the Windows MM MIDI API.
2006   errorString_ = "RtMidiIn::openVirtualPort: cannot be implemented in Windows MM MIDI API!";
2007   error( RtError::WARNING );
2008 }
2009
2010 void RtMidiIn :: closePort( void )
2011 {
2012   if ( connected_ ) {
2013     WinMidiData *data = static_cast<WinMidiData *> (apiData_);
2014     midiInReset( data->inHandle );
2015     midiInStop( data->inHandle );
2016     midiInClose( data->inHandle );
2017     connected_ = false;
2018   }
2019 }
2020
2021 RtMidiIn :: ~RtMidiIn()
2022 {
2023   // Close a connection if it exists.
2024   closePort();
2025
2026   // Cleanup.
2027   WinMidiData *data = static_cast<WinMidiData *> (apiData_);
2028   delete data;
2029 }
2030
2031 unsigned int RtMidiIn :: getPortCount()
2032 {
2033   return midiInGetNumDevs();
2034 }
2035
2036 std::string RtMidiIn :: getPortName( unsigned int portNumber )
2037 {
2038   unsigned int nDevices = midiInGetNumDevs();
2039   if ( portNumber >= nDevices ) {
2040     std::ostringstream ost;
2041     ost << "RtMidiIn::getPortName: 'portNumber' argument (" << portNumber << ") is invalid.";
2042     errorString_ = ost.str();
2043     error( RtError::INVALID_PARAMETER );
2044   }
2045
2046   MIDIINCAPS deviceCaps;
2047   MMRESULT result = midiInGetDevCaps( portNumber, &deviceCaps, sizeof(MIDIINCAPS));
2048
2049   std::string stringName = std::string( deviceCaps.szPname );
2050   return stringName;
2051 }
2052
2053 //*********************************************************************//
2054 //  API: Windows MM
2055 //  Class Definitions: RtMidiOut
2056 //*********************************************************************//
2057
2058 unsigned int RtMidiOut :: getPortCount()
2059 {
2060   return midiOutGetNumDevs();
2061 }
2062
2063 std::string RtMidiOut :: getPortName( unsigned int portNumber )
2064 {
2065   unsigned int nDevices = midiOutGetNumDevs();
2066   if ( portNumber >= nDevices ) {
2067     std::ostringstream ost;
2068     ost << "RtMidiOut::getPortName: 'portNumber' argument (" << portNumber << ") is invalid.";
2069     errorString_ = ost.str();
2070     error( RtError::INVALID_PARAMETER );
2071   }
2072
2073   MIDIOUTCAPS deviceCaps;
2074   MMRESULT result = midiOutGetDevCaps( portNumber, &deviceCaps, sizeof(MIDIOUTCAPS));
2075
2076   std::string stringName = std::string( deviceCaps.szPname );
2077   return stringName;
2078 }
2079
2080 void RtMidiOut :: initialize( void )
2081 {
2082   // We'll issue a warning here if no devices are available but not
2083   // throw an error since the user can plug something in later.
2084   unsigned int nDevices = midiOutGetNumDevs();
2085   if ( nDevices == 0 ) {
2086     errorString_ = "RtMidiOut::initialize: no MIDI output devices currently available.";
2087     error( RtError::WARNING );
2088   }
2089
2090   // Save our api-specific connection information.
2091   WinMidiData *data = (WinMidiData *) new WinMidiData;
2092   apiData_ = (void *) data;
2093 }
2094
2095 void RtMidiOut :: openPort( unsigned int portNumber )
2096 {
2097   if ( connected_ ) {
2098     errorString_ = "RtMidiOut::openPort: a valid connection already exists!";
2099     error( RtError::WARNING );
2100     return;
2101   }
2102
2103   unsigned int nDevices = midiOutGetNumDevs();
2104   if (nDevices < 1) {
2105     errorString_ = "RtMidiOut::openPort: no MIDI output destinations found!";
2106     error( RtError::NO_DEVICES_FOUND );
2107   }
2108
2109   std::ostringstream ost;
2110   if ( portNumber >= nDevices ) {
2111     ost << "RtMidiOut::openPort: 'portNumber' argument (" << portNumber << ") is invalid.";
2112     errorString_ = ost.str();
2113     error( RtError::INVALID_PARAMETER );
2114   }
2115
2116   WinMidiData *data = static_cast<WinMidiData *> (apiData_);
2117   MMRESULT result = midiOutOpen( &data->outHandle,
2118                                  portNumber,
2119                                  (DWORD)NULL,
2120                                  (DWORD)NULL,
2121                                  CALLBACK_NULL );
2122   if ( result != MMSYSERR_NOERROR ) {
2123     errorString_ = "RtMidiOut::openPort: error creating Windows MM MIDI output port.";
2124     error( RtError::DRIVER_ERROR );
2125   }
2126
2127   connected_ = true;
2128 }
2129
2130 void RtMidiOut :: closePort( void )
2131 {
2132   if ( connected_ ) {
2133     WinMidiData *data = static_cast<WinMidiData *> (apiData_);
2134     midiOutReset( data->outHandle );
2135     midiOutClose( data->outHandle );
2136     connected_ = false;
2137   }
2138 }
2139
2140 void RtMidiOut :: openVirtualPort()
2141 {
2142   // This function cannot be implemented for the Windows MM MIDI API.
2143   errorString_ = "RtMidiOut::openVirtualPort: cannot be implemented in Windows MM MIDI API!";
2144   error( RtError::WARNING );
2145 }
2146
2147 RtMidiOut :: ~RtMidiOut()
2148 {
2149   // Close a connection if it exists.
2150   closePort();
2151
2152   // Cleanup.
2153   WinMidiData *data = static_cast<WinMidiData *> (apiData_);
2154   delete data;
2155 }
2156
2157 void RtMidiOut :: sendMessage( std::vector<unsigned char> *message )
2158 {
2159   unsigned int nBytes = message->size();
2160   if ( nBytes == 0 ) {
2161     errorString_ = "RtMidiOut::sendMessage: message argument is empty!";
2162     error( RtError::WARNING );
2163     return;
2164   }
2165
2166   MMRESULT result;
2167   WinMidiData *data = static_cast<WinMidiData *> (apiData_);
2168   if ( message->at(0) == 0xF0 ) { // Sysex message
2169
2170     // Allocate buffer for sysex data.
2171     char *buffer = (char *) malloc( nBytes );
2172     if ( buffer == NULL ) {
2173       errorString_ = "RtMidiOut::sendMessage: error allocating sysex message memory!";
2174       error( RtError::MEMORY_ERROR );
2175     }
2176
2177     // Copy data to buffer.
2178     for ( unsigned int i=0; i<nBytes; i++ ) buffer[i] = message->at(i);
2179
2180     // Create and prepare MIDIHDR structure.
2181     MIDIHDR sysex;
2182     sysex.lpData = (LPSTR) buffer;
2183     sysex.dwBufferLength = nBytes;
2184     sysex.dwFlags = 0;
2185     result = midiOutPrepareHeader( data->outHandle,  &sysex, sizeof(MIDIHDR) );
2186     if ( result != MMSYSERR_NOERROR ) {
2187       free( buffer );
2188       errorString_ = "RtMidiOut::sendMessage: error preparing sysex header.";
2189       error( RtError::DRIVER_ERROR );
2190     }
2191
2192     // Send the message.
2193     result = midiOutLongMsg( data->outHandle, &sysex, sizeof(MIDIHDR) );
2194     if ( result != MMSYSERR_NOERROR ) {
2195       free( buffer );
2196       errorString_ = "RtMidiOut::sendMessage: error sending sysex message.";
2197       error( RtError::DRIVER_ERROR );
2198     }
2199
2200     // Unprepare the buffer and MIDIHDR.
2201     while ( MIDIERR_STILLPLAYING == midiOutUnprepareHeader( data->outHandle, &sysex, sizeof (MIDIHDR) ) ) Sleep( 1 );
2202     free( buffer );
2203
2204   }
2205   else { // Channel or system message.
2206
2207     // Make sure the message size isn't too big.
2208     if ( nBytes > 3 ) {
2209       errorString_ = "RtMidiOut::sendMessage: message size is greater than 3 bytes (and not sysex)!";
2210       error( RtError::WARNING );
2211       return;
2212     }
2213
2214     // Pack MIDI bytes into double word.
2215     DWORD packet;
2216     unsigned char *ptr = (unsigned char *) &packet;
2217     for ( unsigned int i=0; i<nBytes; i++ ) {
2218       *ptr = message->at(i);
2219       ptr++;
2220     }
2221
2222     // Send the message immediately.
2223     result = midiOutShortMsg( data->outHandle, packet );
2224     if ( result != MMSYSERR_NOERROR ) {
2225       errorString_ = "RtMidiOut::sendMessage: error sending MIDI message.";
2226       error( RtError::DRIVER_ERROR );
2227     }
2228   }
2229 }
2230
2231 #endif  // __WINDOWS_MM__
2232
2233
2234 #if defined(__LINUX_OSS__)  // dummy
2235
2236 /*void midiInputCallback( const MIDIPacketList *list, void *procRef, void *srcRef )
2237 {
2238     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2239 }
2240 */
2241 void RtMidiIn :: initialize( void )
2242 {
2243     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2244 }
2245
2246 void RtMidiIn :: openPort( unsigned int portNumber )
2247 {
2248     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2249 }
2250
2251 void RtMidiIn :: openVirtualPort()
2252 {
2253     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2254 }
2255
2256 void RtMidiIn :: closePort( void )
2257 {
2258     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2259 }
2260
2261 RtMidiIn :: ~RtMidiIn()
2262 {
2263     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2264 }
2265
2266 unsigned int RtMidiIn :: getPortCount()
2267 {
2268     return 0;
2269 }
2270
2271 std::string RtMidiIn :: getPortName( unsigned int portNumber )
2272 {
2273     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2274     return "";
2275 }
2276
2277 //*********************************************************************//
2278 //  API: OS-X
2279 //  Class Definitions: RtMidiOut
2280 //*********************************************************************//
2281
2282 unsigned int RtMidiOut :: getPortCount()
2283 {
2284     return 0;
2285 }
2286
2287 std::string RtMidiOut :: getPortName( unsigned int portNumber )
2288 {
2289     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2290     return "";
2291 }
2292
2293 void RtMidiOut :: initialize( void )
2294 {
2295     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2296 }
2297
2298 void RtMidiOut :: openPort( unsigned int portNumber )
2299 {
2300     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2301 }
2302
2303 void RtMidiOut :: closePort( void )
2304 {
2305     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2306 }
2307
2308 void RtMidiOut :: openVirtualPort()
2309 {
2310     fprintf( stderr, "[chuck](via rtmidi): midi not supported for this platform\n" );
2311 }
2312
2313 RtMidiOut :: ~RtMidiOut()
2314 {
2315 }
2316
2317 void RtMidiOut :: sendMessage( std::vector<unsigned char> *message )
2318 {
2319 }
2320
2321 #endif  // dummy