---

RtMidi.cpp

/**********************************************************************/
/**********************************************************************/

#include "RtMidi.h"
#include <sstream>

RtMidi :: RtMidi()
  : apiData_( 0 ), connected_( false )
{
}

void RtMidi :: error( RtError::Type type )
{
  if (type == RtError::WARNING) {
    std::cerr << '\n' << errorString_ << "\n\n";
  }
  else if (type == RtError::DEBUG_WARNING) {
#if defined(__RTMIDI_DEBUG__)
    std::cerr << '\n' << errorString_ << "\n\n";
#endif
  }
  else {
    std::cerr << '\n' << errorString_ << "\n\n";
    throw RtError( errorString_, type );
  }
}

RtMidiIn :: RtMidiIn() : RtMidi()
{
}

RtMidiIn :: RtMidiIn( unsigned int portNumber, RtMidiCallback callback, void *userData ) : RtMidi()

{
  // Attempt to make the connection.
  this->openPort( portNumber, callback, userData );
}

RtMidiIn :: ~RtMidiIn()
{
  closePort();
}

RtMidiOut :: RtMidiOut() : RtMidi()
{
}

RtMidiOut :: RtMidiOut( unsigned int portNumber ) : RtMidi()
{
  // Attempt to make the connection.
  this->openPort( portNumber );
}

RtMidiOut :: ~RtMidiOut()
{
  closePort();
}


#if defined(__MACOSX_CORE__)

// The CoreMIDI API is based on the use of a callback function for
// MIDI input.  We convert the system specific time stamps to delta
// time values.

// OS-X CoreMIDI header files.
#include <CoreMIDI/CoreMIDI.h>
#include <CoreAudio/HostTime.h>

// A structure to hold variables related to the CoreMIDI API
// implementation.
struct CoreMidiData {
  MIDIClientRef client;
  MIDIPortRef port;
  MIDIEndpointRef destinationId;
};

void midiInputCallback( const MIDIPacketList *list, void *procRef, void *srcRef )
{
  RtMidiIn::RtMidiInData *data = static_cast<RtMidiIn::RtMidiInData *> (procRef);

  bool continueSysex = false;
  unsigned char status;
  unsigned short nBytes, iByte, size;
  unsigned long long time;
  RtMidiIn::MidiMessage message;
  const MIDIPacket *packet = &list->packet[0];
  for ( unsigned int i=0; i<list->numPackets; ++i ) {

    // My interpretation of the CoreMIDI documentation: all message
    // types, except sysex, are complete within a packet and there may
    // be several of them in a single packet.  Sysex messages can be
    // broken across multiple packets but are bundled alone within a
    // packet.  I'm assuming that sysex messages, if segmented, must
    // be complete within the same MIDIPacketList.

    nBytes = packet->length;
    if ( nBytes == 0 ) continue;

    // Calculate time stamp.
    message.timeStamp = 0.0;
    time = packet->timeStamp;
    time -= data->lastTime;
    data->lastTime = packet->timeStamp;
    time = AudioConvertHostTimeToNanos( time );
    message.timeStamp = time * 0.000000001;

    iByte = 0;
    if ( continueSysex ) {
      // We have a continuing, segmented sysex message.
      if ( !(data->ignoreFlags & 0x01) ) {
        // If we're not ignoring sysex messages, copy the entire packet.
        message.bytes.assign( packet->data, &packet->data[nBytes] );
      }
      if ( packet->data[nBytes] == 0xF7 ) continueSysex = false;
      if ( !continueSysex ) {
        // If not a continuing sysex message, invoke the user callback function or queue the message.
        if ( data->usingCallback && message.bytes.size() > 0 ) {
          RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
          callback( message.timeStamp, &message.bytes, data->userData );
        }
        else {
          // As long as we haven't reached our queue size limit, push the message.
          if ( data->queueLimit > data->queue.size() )
            data->queue.push( message );
          else
            std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
        }
        message.bytes.clear();
      }
    }
    else {
      while ( iByte < nBytes ) {
        size = 0;
        // We are expecting that the next byte in the packet is a status byte.
        status = packet->data[iByte];
        if ( !(status & 0x80) ) break;
        // Determine the number of bytes in the MIDI message.
        if ( status < 0xC0 ) size = 3;
        else if ( status < 0xE0 ) size = 2;
        else if ( status < 0xF0 ) size = 3;
        else if ( status == 0xF0 ) {
          // A MIDI sysex
          if ( data->ignoreFlags & 0x01 ) {
            size = 0;
            iByte = nBytes;
          }
          else size = nBytes - iByte;
          if ( packet->data[nBytes] == 0xF7 ) continueSysex = false;
        }
        else if ( status < 0xF3 ) {
          if ( status == 0xF1 && (data->ignoreFlags & 0x02) ) {
            // A MIDI time code message and we're ignoring it.
            size = 0;
            iByte += 3;
          }
          else size = 3;
        }
        else if ( status == 0xF3 ) size = 2;
        else if ( status == 0xFE && (data->ignoreFlags & 0x04) ) {
          // A MIDI active sensing message and we're ignoring it.
          size = 0;
          iByte += 1;
        }
        else size = 1;

        // Copy the MIDI data to our vector.
        if ( size ) {
          message.bytes.assign( &packet->data[iByte], &packet->data[iByte+size] );
          if ( !continueSysex ) {
            // If not a continuing sysex message, invoke the user callback function or queue the message.
            if ( data->usingCallback ) {
              RtMidiIn::RtMidiCallback callback = (RtMidiIn::RtMidiCallback) data->userCallback;
              callback( message.timeStamp, &message.bytes, data->userData );
            }
            else {
              // As long as we haven't reached our queue size limit, push the message.
              if ( data->queueLimit > data->queue.size() )
                data->queue.push( message );
              else
                std::cerr << "\nRtMidiIn: message queue limit reached!!\n\n";
            }
            message.bytes.clear();
          }
          iByte += size;
        }
      }
    }
    packet = MIDIPacketNext(packet);
  }
}

void RtMidiIn :: openPort( unsigned int portNumber, RtMidiCallback callback, void *userData )
{
  if ( connected_ ) {
    errorString_ = "RtMidiIn::openPort: a valid connection already exists!";
    error( RtError::WARNING );
    return;
  }

  unsigned int nSrc = MIDIGetNumberOfSources();
  if (nSrc < 1) {
    errorString_ = "RtMidiIn::openPort: no MIDI input sources found!";
    error( RtError::NO_DEVICES_FOUND );
  }

  std::ostringstream ost;
  if ( portNumber >= nSrc ) {
    ost << "RtMidiIn::openPort: the 'portNumber' argument (" << portNumber << ") is invalid.";
    errorString_ = ost.str();
    error( RtError::INVALID_PARAMETER );
  }

  MIDIClientRef client;
  OSStatus result = MIDIClientCreate( CFSTR("RtMidi Input Client"), NULL, NULL, &client );
  if ( result != noErr ) {
    errorString_ = "RtMidiIn::openPort: error creating OS-X MIDI client object.";
    error( RtError::DRIVER_ERROR );
  }

  MIDIPortRef port;
  result = MIDIInputPortCreate( client, CFSTR("RtMidi Virtual MIDI Input Port"), midiInputCallback, (void *)&inputData_, &port );
  if ( result != noErr ) {
    MIDIClientDispose( client );
    errorString_ = "RtMidiIn::openPort: error creating OS-X MIDI input port.";
    error( RtError::DRIVER_ERROR );
  }

  // Get the desired input source identifier.
  MIDIEndpointRef src = MIDIGetSource( portNumber );
  if ( src == NULL ) {
    MIDIPortDispose( port );
    MIDIClientDispose( client );
    errorString_ = "RtMidiIn::openPort: error getting MIDI input source reference.";
    error( RtError::DRIVER_ERROR );
  }

  // Make the connection.
  result = MIDIPortConnectSource(port, src, NULL );
  if ( result != noErr ) {
    MIDIPortDispose( port );
    MIDIClientDispose( client );
    errorString_ = "RtMidiIn::openPort: error connecting OS-X MIDI input port.";
    error( RtError::DRIVER_ERROR );
  }

  // Save our api-specific connection information.
  CoreMidiData *data = (CoreMidiData *) new CoreMidiData;
  data->client = client;
  data->port = port;
  apiData_ = (void *) data;

  if ( callback ) {
    inputData_.userCallback = (void *) callback;
    inputData_.userData = userData;
    inputData_.usingCallback = true;
  }

  inputData_.lastTime = AudioGetCurrentHostTime();

  connected_ = true;
}

void RtMidiIn :: closePort( void )
{
  if ( connected_ ) {
    CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
    MIDIClientDispose( data->client );
    MIDIPortDispose( data->port );
    delete data;
    apiData_ = 0;
  }

  connected_ = false;
}

unsigned int RtMidiIn :: getPortCount()
{
  return MIDIGetNumberOfSources();
}

std::string RtMidiIn :: getPortName( unsigned int portNumber )
{
  CFStringRef nameRef;
  MIDIEndpointRef portRef;
  std::ostringstream ost;
  char name[128];

  if ( portNumber >= MIDIGetNumberOfSources() ) {
    ost << "RtMidiIn::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid.";
    errorString_ = ost.str();
    error( RtError::INVALID_PARAMETER );
  }
  portRef = MIDIGetSource( portNumber );

  MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &nameRef );
  CFStringGetCString( nameRef, name, sizeof(name), 0);
  CFRelease( nameRef );
  std::string stringName = name;
  return stringName;
}

void RtMidiIn :: setQueueSizeLimit( unsigned int queueSize )
{
  inputData_.queueLimit = queueSize;
}

void RtMidiIn :: ignoreTypes( bool midiSysex, bool midiTime, bool midiSense )
{
  inputData_.ignoreFlags = 0;
  if ( midiSysex ) inputData_.ignoreFlags = 0x01;
  if ( midiTime ) inputData_.ignoreFlags |= 0x02;
  if ( midiSense ) inputData_.ignoreFlags |= 0x04;
}

double RtMidiIn :: getMessage( std::vector<unsigned char> *message )
{
  message->clear();
  if ( !connected_ ) {
    errorString_ = "RtMidiIn::getNextMessage: a port is not open!";
    error( RtError::WARNING );
    return 0.0;
  }

  if ( inputData_.usingCallback ) {
    errorString_ = "RtMidiIn::getNextMessage: a user callback is currently set for this port.";
    error( RtError::WARNING );
    return 0.0;
  }

  if ( inputData_.queue.size() == 0 ) return 0.0;

  // Copy queued message to the vector pointer argument and then "pop" it.
  std::vector<unsigned char> *bytes = &(inputData_.queue.front().bytes);
  message->assign( bytes->begin(), bytes->end() );
  double deltaTime = inputData_.queue.front().timeStamp;
  inputData_.queue.pop();

  return deltaTime;
}

unsigned int RtMidiOut :: getPortCount()
{
  return MIDIGetNumberOfDestinations();
}

std::string RtMidiOut :: getPortName( unsigned int portNumber )
{
  CFStringRef nameRef;
  MIDIEndpointRef portRef;
  std::ostringstream ost;
  char name[128];

  if ( portNumber >= MIDIGetNumberOfDestinations() ) {
    ost << "RtMidiOut::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid.";
    errorString_ = ost.str();
    error( RtError::INVALID_PARAMETER );
  }
  portRef = MIDIGetDestination( portNumber );

  MIDIObjectGetStringProperty( portRef, kMIDIPropertyName, &nameRef );
  CFStringGetCString( nameRef, name, sizeof(name), 0);
  CFRelease( nameRef );
  std::string stringName = name;
  return stringName;
}

void RtMidiOut :: openPort( unsigned int portNumber )
{
  if ( connected_ ) {
    errorString_ = "RtMidiOut::openPort: a valid connection already exists!";
    error( RtError::WARNING );
    return;
  }

  unsigned int nDest = MIDIGetNumberOfDestinations();
  if (nDest < 1) {
    errorString_ = "RtMidiOut::openPort: no MIDI output destinations found!";
    error( RtError::NO_DEVICES_FOUND );
  }

  std::ostringstream ost;
  if ( portNumber >= nDest ) {
    ost << "RtMidiOut::openPort: the 'portNumber' argument (" << portNumber << ") is invalid.";
    errorString_ = ost.str();
    error( RtError::INVALID_PARAMETER );
  }

  MIDIClientRef client;
  OSStatus result = MIDIClientCreate( CFSTR("RtMidi Output Client"), NULL, NULL, &client );
  if ( result != noErr ) {
    errorString_ = "RtMidiOut::openPort: error creating OS-X MIDI client object.";
    error( RtError::DRIVER_ERROR );
  }

  MIDIPortRef port;
  result = MIDIOutputPortCreate( client, CFSTR("RtMidi Virtual MIDI Output Port"), &port );
  if ( result != noErr ) {
    MIDIClientDispose( client );
    errorString_ = "RtMidiOut::openPort: error creating OS-X MIDI output port.";
    error( RtError::DRIVER_ERROR );
  }

  // Get the desired output port identifier.
  MIDIEndpointRef destinationId = MIDIGetDestination( portNumber );
  if ( destinationId == NULL ) {
    MIDIPortDispose( port );
    MIDIClientDispose( client );
    errorString_ = "RtMidiOut::openPort: error getting MIDI output destination reference.";
    error( RtError::DRIVER_ERROR );
  }

  // Save our api-specific connection information.
  CoreMidiData *data = (CoreMidiData *) new CoreMidiData;
  data->client = client;
  data->port = port;
  data->destinationId = destinationId;
  apiData_ = (void *) data;

  connected_ = true;
}

void RtMidiOut :: closePort( void )
{
  if ( connected_ ) {
    CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
    MIDIClientDispose( data->client );
    MIDIPortDispose( data->port );
    delete data;
    apiData_ = 0;
  }

  connected_ = false;
}

void RtMidiOut :: sendMessage( std::vector<unsigned char> *message )
{
  if ( !connected_ ) {
    errorString_ = "RtMidiOut::sendMessage: a port is not open!";
    error( RtError::WARNING );
    return;
  }

  unsigned int nBytes = message->size();
  // Pad the buffer for extra (unknown) structure data.
  Byte buffer[nBytes+32];
  MIDIPacketList *pktlist = (MIDIPacketList *) buffer;
  MIDIPacket *curPacket = MIDIPacketListInit( pktlist );

  MIDITimeStamp timeStamp = 0;
  curPacket = MIDIPacketListAdd( pktlist, sizeof(buffer), curPacket, timeStamp, nBytes, &message->at(0) );

  CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
  OSStatus result = MIDISend( data->port, data->destinationId, pktlist );
  if ( result != noErr ) {
    errorString_ = "RtMidiOut::sendMessage: error sending MIDI message.";
    error( RtError::WARNING );
  }
}

#endif

---

The Synthesis ToolKit in C++ (STK)

©1995-2002 Perry R. Cook and Gary P. Scavone. All Rights Reserved.