/RtMidi.cpp
http://ewitool.googlecode.com/ · C++ · 3747 lines · 2794 code · 575 blank · 378 comment · 588 complexity · b595065c57d234c35379646fa077e891 MD5 · raw file
Large files are truncated click here to view the full file
- /**********************************************************************/
- /*! \class RtMidi
- \brief An abstract base class for realtime MIDI input/output.
- This class implements some common functionality for the realtime
- MIDI input/output subclasses RtMidiIn and RtMidiOut.
- RtMidi WWW site: http://music.mcgill.ca/~gary/rtmidi/
- RtMidi: realtime MIDI i/o C++ classes
- Copyright (c) 2003-2012 Gary P. Scavone
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation files
- (the "Software"), to deal in the Software without restriction,
- including without limitation the rights to use, copy, modify, merge,
- publish, distribute, sublicense, and/or sell copies of the Software,
- and to permit persons to whom the Software is furnished to do so,
- subject to the following conditions:
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
- Any person wishing to distribute modifications to the Software is
- asked to send the modifications to the original developer so that
- they can be incorporated into the canonical version. This is,
- however, not a binding provision of this license.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
- ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
- /**********************************************************************/
- // RtMidi: Version 2.0.1
- #include "RtMidi.h"
- #include <sstream>
- //*********************************************************************//
- // RtMidi Definitions
- //*********************************************************************//
- void RtMidi :: getCompiledApi( std::vector<RtMidi::Api> &apis ) throw()
- {
- apis.clear();
- // The order here will control the order of RtMidi's API search in
- // the constructor.
- #if defined(__MACOSX_CORE__)
- apis.push_back( MACOSX_CORE );
- #endif
- #if defined(__LINUX_ALSA__)
- apis.push_back( LINUX_ALSA );
- #endif
- #if defined(__UNIX_JACK__)
- apis.push_back( UNIX_JACK );
- #endif
- #if defined(__WINDOWS_MM__)
- apis.push_back( WINDOWS_MM );
- #endif
- #if defined(__WINDOWS_KS__)
- apis.push_back( WINDOWS_KS );
- #endif
- #if defined(__RTMIDI_DUMMY__)
- apis.push_back( RTMIDI_DUMMY );
- #endif
- }
- void RtMidi :: error( RtError::Type type, std::string errorString )
- {
- 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 Definitions
- //*********************************************************************//
- void RtMidiIn :: openMidiApi( RtMidi::Api api, const std::string clientName, unsigned int queueSizeLimit )
- {
- if ( rtapi_ )
- delete rtapi_;
- rtapi_ = 0;
- #if defined(__UNIX_JACK__)
- if ( api == UNIX_JACK )
- rtapi_ = new MidiInJack( clientName, queueSizeLimit );
- #endif
- #if defined(__LINUX_ALSA__)
- if ( api == LINUX_ALSA )
- rtapi_ = new MidiInAlsa( clientName, queueSizeLimit );
- #endif
- #if defined(__WINDOWS_MM__)
- if ( api == WINDOWS_MM )
- rtapi_ = new MidiInWinMM( clientName, queueSizeLimit );
- #endif
- #if defined(__WINDOWS_KS__)
- if ( api == WINDOWS_KS )
- rtapi_ = new MidiInWinKS( clientName, queueSizeLimit );
- #endif
- #if defined(__MACOSX_CORE__)
- if ( api == MACOSX_CORE )
- rtapi_ = new MidiInCore( clientName, queueSizeLimit );
- #endif
- #if defined(__RTMIDI_DUMMY__)
- if ( api == RTMIDI_DUMMY )
- rtapi_ = new MidiInDummy( clientName, queueSizeLimit );
- #endif
- }
- RtMidiIn :: RtMidiIn( RtMidi::Api api, const std::string clientName, unsigned int queueSizeLimit )
- {
- rtapi_ = 0;
- if ( api != UNSPECIFIED ) {
- // Attempt to open the specified API.
- openMidiApi( api, clientName, queueSizeLimit );
- if ( rtapi_ ) return;
- // No compiled support for specified API value. Issue a debug
- // warning and continue as if no API was specified.
- RtMidi::error( RtError::WARNING, "RtMidiIn: no compiled support for specified API argument!" );
- }
- // Iterate through the compiled APIs and return as soon as we find
- // one with at least one port or we reach the end of the list.
- std::vector< RtMidi::Api > apis;
- getCompiledApi( apis );
- for ( unsigned int i=0; i<apis.size(); i++ ) {
- openMidiApi( apis[i], clientName, queueSizeLimit );
- if ( rtapi_->getPortCount() ) break;
- }
- if ( rtapi_ ) return;
- // It should not be possible to get here because the preprocessor
- // definition __RTMIDI_DUMMY__ is automatically defined if no
- // API-specific definitions are passed to the compiler. But just in
- // case something weird happens, we'll print out an error message.
- RtMidi::error( RtError::WARNING, "RtMidiIn: no compiled API support found ... critical error!!" );
- }
- RtMidiIn :: ~RtMidiIn() throw()
- {
- delete rtapi_;
- }
- //*********************************************************************//
- // RtMidiOut Definitions
- //*********************************************************************//
- void RtMidiOut :: openMidiApi( RtMidi::Api api, const std::string clientName )
- {
- if ( rtapi_ )
- delete rtapi_;
- rtapi_ = 0;
- #if defined(__UNIX_JACK__)
- if ( api == UNIX_JACK )
- rtapi_ = new MidiOutJack( clientName );
- #endif
- #if defined(__LINUX_ALSA__)
- if ( api == LINUX_ALSA )
- rtapi_ = new MidiOutAlsa( clientName );
- #endif
- #if defined(__WINDOWS_MM__)
- if ( api == WINDOWS_MM )
- rtapi_ = new MidiOutWinMM( clientName );
- #endif
- #if defined(__WINDOWS_KS__)
- if ( api == WINDOWS_KS )
- rtapi_ = new MidiOutWinKS( clientName );
- #endif
- #if defined(__MACOSX_CORE__)
- if ( api == MACOSX_CORE )
- rtapi_ = new MidiOutCore( clientName );
- #endif
- #if defined(__RTMIDI_DUMMY__)
- if ( api == RTMIDI_DUMMY )
- rtapi_ = new MidiOutDummy( clientName );
- #endif
- }
- RtMidiOut :: RtMidiOut( RtMidi::Api api, const std::string clientName )
- {
- rtapi_ = 0;
- if ( api != UNSPECIFIED ) {
- // Attempt to open the specified API.
- openMidiApi( api, clientName );
- if ( rtapi_ ) return;
- // No compiled support for specified API value. Issue a debug
- // warning and continue as if no API was specified.
- RtMidi::error( RtError::WARNING, "RtMidiOut: no compiled support for specified API argument!" );
- }
- // Iterate through the compiled APIs and return as soon as we find
- // one with at least one port or we reach the end of the list.
- std::vector< RtMidi::Api > apis;
- getCompiledApi( apis );
- for ( unsigned int i=0; i<apis.size(); i++ ) {
- openMidiApi( apis[i], clientName );
- if ( rtapi_->getPortCount() ) break;
- }
- if ( rtapi_ ) return;
- // It should not be possible to get here because the preprocessor
- // definition __RTMIDI_DUMMY__ is automatically defined if no
- // API-specific definitions are passed to the compiler. But just in
- // case something weird happens, we'll print out an error message.
- RtMidi::error( RtError::WARNING, "RtMidiOut: no compiled API support found ... critical error!!" );
- }
- RtMidiOut :: ~RtMidiOut() throw()
- {
- delete rtapi_;
- }
- //*********************************************************************//
- // Common MidiInApi Definitions
- //*********************************************************************//
- MidiInApi :: MidiInApi( unsigned int queueSizeLimit )
- : apiData_( 0 ), connected_( false )
- {
- // Allocate the MIDI queue.
- inputData_.queue.ringSize = queueSizeLimit;
- if ( inputData_.queue.ringSize > 0 )
- inputData_.queue.ring = new MidiMessage[ inputData_.queue.ringSize ];
- }
- MidiInApi :: ~MidiInApi( void )
- {
- // Delete the MIDI queue.
- if ( inputData_.queue.ringSize > 0 ) delete [] inputData_.queue.ring;
- }
- void MidiInApi :: setCallback( RtMidiIn::RtMidiCallback callback, void *userData )
- {
- if ( inputData_.usingCallback ) {
- errorString_ = "MidiInApi::setCallback: a callback function is already set!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- if ( !callback ) {
- errorString_ = "RtMidiIn::setCallback: callback function value is invalid!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- inputData_.userCallback = (void *) callback;
- inputData_.userData = userData;
- inputData_.usingCallback = true;
- }
- void MidiInApi :: cancelCallback()
- {
- if ( !inputData_.usingCallback ) {
- errorString_ = "RtMidiIn::cancelCallback: no callback function was set!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- inputData_.userCallback = 0;
- inputData_.userData = 0;
- inputData_.usingCallback = false;
- }
- void MidiInApi :: 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 MidiInApi :: getMessage( std::vector<unsigned char> *message )
- {
- message->clear();
- if ( inputData_.usingCallback ) {
- errorString_ = "RtMidiIn::getNextMessage: a user callback is currently set for this port.";
- RtMidi::error( RtError::WARNING, errorString_ );
- 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.ring[inputData_.queue.front].bytes);
- message->assign( bytes->begin(), bytes->end() );
- double deltaTime = inputData_.queue.ring[inputData_.queue.front].timeStamp;
- inputData_.queue.size--;
- inputData_.queue.front++;
- if ( inputData_.queue.front == inputData_.queue.ringSize )
- inputData_.queue.front = 0;
- return deltaTime;
- }
- //*********************************************************************//
- // Common MidiOutApi Definitions
- //*********************************************************************//
- MidiOutApi :: MidiOutApi( void )
- : apiData_( 0 ), connected_( false )
- {
- }
- MidiOutApi :: ~MidiOutApi( void )
- {
- }
- // *************************************************** //
- //
- // OS/API-specific methods.
- //
- // *************************************************** //
- #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>
- #include <CoreServices/CoreServices.h>
- // A structure to hold variables related to the CoreMIDI API
- // implementation.
- struct CoreMidiData {
- MIDIClientRef client;
- MIDIPortRef port;
- MIDIEndpointRef endpoint;
- MIDIEndpointRef destinationId;
- unsigned long long lastTime;
- MIDISysexSendRequest sysexreq;
- };
- //*********************************************************************//
- // API: OS-X
- // Class Definitions: MidiInCore
- //*********************************************************************//
- void midiInputCallback( const MIDIPacketList *list, void *procRef, void *srcRef )
- {
- MidiInApi::RtMidiInData *data = static_cast<MidiInApi::RtMidiInData *> (procRef);
- CoreMidiData *apiData = static_cast<CoreMidiData *> (data->apiData);
- unsigned char status;
- unsigned short nBytes, iByte, size;
- unsigned long long time;
- bool& continueSysex = data->continueSysex;
- MidiInApi::MidiMessage& message = data->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 and PacketLists but are bundled
- // alone within each packet (these packets do not contain other
- // message types). If sysex messages are split across multiple
- // MIDIPacketLists, they must be handled by multiple calls to this
- // function.
- nBytes = packet->length;
- if ( nBytes == 0 ) continue;
- // Calculate time stamp.
- if ( data->firstMessage ) {
- message.timeStamp = 0.0;
- data->firstMessage = false;
- }
- else {
- time = packet->timeStamp;
- if ( time == 0 ) { // this happens when receiving asynchronous sysex messages
- time = AudioGetCurrentHostTime();
- }
- time -= apiData->lastTime;
- time = AudioConvertHostTimeToNanos( time );
- if ( !continueSysex )
- message.timeStamp = time * 0.000000001;
- }
- apiData->lastTime = packet->timeStamp;
- if ( apiData->lastTime == 0 ) { // this happens when receiving asynchronous sysex messages
- apiData->lastTime = AudioGetCurrentHostTime();
- }
- //std::cout << "TimeStamp = " << packet->timeStamp << std::endl;
- 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.
- for ( unsigned int j=0; j<nBytes; ++j )
- message.bytes.push_back( packet->data[j] );
- }
- continueSysex = packet->data[nBytes-1] != 0xF7;
- 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->queue.size < data->queue.ringSize ) {
- data->queue.ring[data->queue.back++] = message;
- if ( data->queue.back == data->queue.ringSize )
- data->queue.back = 0;
- data->queue.size++;
- }
- else
- std::cerr << "\nMidiInCore: 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;
- continueSysex = packet->data[nBytes-1] != 0xF7;
- }
- else if ( status == 0xF1 ) {
- // A MIDI time code message
- if ( data->ignoreFlags & 0x02 ) {
- size = 0;
- iByte += 2;
- }
- else size = 2;
- }
- else if ( status == 0xF2 ) size = 3;
- else if ( status == 0xF3 ) size = 2;
- else if ( status == 0xF8 && ( data->ignoreFlags & 0x02 ) ) {
- // A MIDI timing tick message and we're ignoring it.
- size = 0;
- iByte += 1;
- }
- 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->queue.size < data->queue.ringSize ) {
- data->queue.ring[data->queue.back++] = message;
- if ( data->queue.back == data->queue.ringSize )
- data->queue.back = 0;
- data->queue.size++;
- }
- else
- std::cerr << "\nMidiInCore: message queue limit reached!!\n\n";
- }
- message.bytes.clear();
- }
- iByte += size;
- }
- }
- }
- packet = MIDIPacketNext(packet);
- }
- }
- MidiInCore :: MidiInCore( const std::string clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit )
- {
- initialize( clientName );
- }
- MidiInCore :: ~MidiInCore( void )
- {
- // Close a connection if it exists.
- closePort();
- // Cleanup.
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- MIDIClientDispose( data->client );
- if ( data->endpoint ) MIDIEndpointDispose( data->endpoint );
- delete data;
- }
- void MidiInCore :: initialize( const std::string& clientName )
- {
- // Set up our client.
- MIDIClientRef client;
- OSStatus result = MIDIClientCreate( CFStringCreateWithCString( NULL, clientName.c_str(), kCFStringEncodingASCII ), NULL, NULL, &client );
- if ( result != noErr ) {
- errorString_ = "MidiInCore::initialize: error creating OS-X MIDI client object.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific connection information.
- CoreMidiData *data = (CoreMidiData *) new CoreMidiData;
- data->client = client;
- data->endpoint = 0;
- apiData_ = (void *) data;
- inputData_.apiData = (void *) data;
- }
- void MidiInCore :: openPort( unsigned int portNumber, const std::string portName )
- {
- if ( connected_ ) {
- errorString_ = "MidiInCore::openPort: a valid connection already exists!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- unsigned int nSrc = MIDIGetNumberOfSources();
- if (nSrc < 1) {
- errorString_ = "MidiInCore::openPort: no MIDI input sources found!";
- RtMidi::error( RtError::NO_DEVICES_FOUND, errorString_ );
- }
- std::ostringstream ost;
- if ( portNumber >= nSrc ) {
- ost << "MidiInCore::openPort: the 'portNumber' argument (" << portNumber << ") is invalid.";
- errorString_ = ost.str();
- RtMidi::error( RtError::INVALID_PARAMETER, errorString_ );
- }
- MIDIPortRef port;
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- OSStatus result = MIDIInputPortCreate( data->client,
- CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ),
- midiInputCallback, (void *)&inputData_, &port );
- if ( result != noErr ) {
- MIDIClientDispose( data->client );
- errorString_ = "MidiInCore::openPort: error creating OS-X MIDI input port.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Get the desired input source identifier.
- MIDIEndpointRef endpoint = MIDIGetSource( portNumber );
- if ( endpoint == 0 ) {
- MIDIPortDispose( port );
- MIDIClientDispose( data->client );
- errorString_ = "MidiInCore::openPort: error getting MIDI input source reference.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Make the connection.
- result = MIDIPortConnectSource( port, endpoint, NULL );
- if ( result != noErr ) {
- MIDIPortDispose( port );
- MIDIClientDispose( data->client );
- errorString_ = "MidiInCore::openPort: error connecting OS-X MIDI input port.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific port information.
- data->port = port;
- connected_ = true;
- }
- void MidiInCore :: openVirtualPort( const std::string portName )
- {
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- // Create a virtual MIDI input destination.
- MIDIEndpointRef endpoint;
- OSStatus result = MIDIDestinationCreate( data->client,
- CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ),
- midiInputCallback, (void *)&inputData_, &endpoint );
- if ( result != noErr ) {
- errorString_ = "MidiInCore::openVirtualPort: error creating virtual OS-X MIDI destination.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific connection information.
- data->endpoint = endpoint;
- }
- void MidiInCore :: closePort( void )
- {
- if ( connected_ ) {
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- MIDIPortDispose( data->port );
- connected_ = false;
- }
- }
- unsigned int MidiInCore :: getPortCount()
- {
- return MIDIGetNumberOfSources();
- }
- // This function was submitted by Douglas Casey Tucker and apparently
- // derived largely from PortMidi.
- CFStringRef EndpointName( MIDIEndpointRef endpoint, bool isExternal )
- {
- CFMutableStringRef result = CFStringCreateMutable( NULL, 0 );
- CFStringRef str;
- // Begin with the endpoint's name.
- str = NULL;
- MIDIObjectGetStringProperty( endpoint, kMIDIPropertyName, &str );
- if ( str != NULL ) {
- CFStringAppend( result, str );
- CFRelease( str );
- }
- MIDIEntityRef entity = NULL;
- MIDIEndpointGetEntity( endpoint, &entity );
- if ( entity == 0 )
- // probably virtual
- return result;
- if ( CFStringGetLength( result ) == 0 ) {
- // endpoint name has zero length -- try the entity
- str = NULL;
- MIDIObjectGetStringProperty( entity, kMIDIPropertyName, &str );
- if ( str != NULL ) {
- CFStringAppend( result, str );
- CFRelease( str );
- }
- }
- // now consider the device's name
- MIDIDeviceRef device = 0;
- MIDIEntityGetDevice( entity, &device );
- if ( device == 0 )
- return result;
- str = NULL;
- MIDIObjectGetStringProperty( device, kMIDIPropertyName, &str );
- if ( CFStringGetLength( result ) == 0 ) {
- CFRelease( result );
- return str;
- }
- if ( str != NULL ) {
- // if an external device has only one entity, throw away
- // the endpoint name and just use the device name
- if ( isExternal && MIDIDeviceGetNumberOfEntities( device ) < 2 ) {
- CFRelease( result );
- return str;
- } else {
- if ( CFStringGetLength( str ) == 0 ) {
- CFRelease( str );
- return result;
- }
- // does the entity name already start with the device name?
- // (some drivers do this though they shouldn't)
- // if so, do not prepend
- if ( CFStringCompareWithOptions( result, /* endpoint name */
- str /* device name */,
- CFRangeMake(0, CFStringGetLength( str ) ), 0 ) != kCFCompareEqualTo ) {
- // prepend the device name to the entity name
- if ( CFStringGetLength( result ) > 0 )
- CFStringInsert( result, 0, CFSTR(" ") );
- CFStringInsert( result, 0, str );
- }
- CFRelease( str );
- }
- }
- return result;
- }
- // This function was submitted by Douglas Casey Tucker and apparently
- // derived largely from PortMidi.
- static CFStringRef ConnectedEndpointName( MIDIEndpointRef endpoint )
- {
- CFMutableStringRef result = CFStringCreateMutable( NULL, 0 );
- CFStringRef str;
- OSStatus err;
- int i;
- // Does the endpoint have connections?
- CFDataRef connections = NULL;
- int nConnected = 0;
- bool anyStrings = false;
- err = MIDIObjectGetDataProperty( endpoint, kMIDIPropertyConnectionUniqueID, &connections );
- if ( connections != NULL ) {
- // It has connections, follow them
- // Concatenate the names of all connected devices
- nConnected = CFDataGetLength( connections ) / sizeof(MIDIUniqueID);
- if ( nConnected ) {
- const SInt32 *pid = (const SInt32 *)(CFDataGetBytePtr(connections));
- for ( i=0; i<nConnected; ++i, ++pid ) {
- MIDIUniqueID id = EndianS32_BtoN( *pid );
- MIDIObjectRef connObject;
- MIDIObjectType connObjectType;
- err = MIDIObjectFindByUniqueID( id, &connObject, &connObjectType );
- if ( err == noErr ) {
- if ( connObjectType == kMIDIObjectType_ExternalSource ||
- connObjectType == kMIDIObjectType_ExternalDestination ) {
- // Connected to an external device's endpoint (10.3 and later).
- str = EndpointName( (MIDIEndpointRef)(connObject), true );
- } else {
- // Connected to an external device (10.2) (or something else, catch-
- str = NULL;
- MIDIObjectGetStringProperty( connObject, kMIDIPropertyName, &str );
- }
- if ( str != NULL ) {
- if ( anyStrings )
- CFStringAppend( result, CFSTR(", ") );
- else anyStrings = true;
- CFStringAppend( result, str );
- CFRelease( str );
- }
- }
- }
- }
- CFRelease( connections );
- }
- if ( anyStrings )
- return result;
- // Here, either the endpoint had no connections, or we failed to obtain names
- return EndpointName( endpoint, false );
- }
- std::string MidiInCore :: getPortName( unsigned int portNumber )
- {
- CFStringRef nameRef;
- MIDIEndpointRef portRef;
- std::ostringstream ost;
- char name[128];
- std::string stringName;
- if ( portNumber >= MIDIGetNumberOfSources() ) {
- ost << "MidiInCore::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid.";
- errorString_ = ost.str();
- RtMidi::error( RtError::WARNING, errorString_ );
- //RtMidi::error( RtError::INVALID_PARAMETER, errorString_ );
- return stringName;
- }
- portRef = MIDIGetSource( portNumber );
- nameRef = ConnectedEndpointName(portRef);
- CFStringGetCString( nameRef, name, sizeof(name), 0);
- CFRelease( nameRef );
- return stringName = name;
- }
- //*********************************************************************//
- // API: OS-X
- // Class Definitions: MidiOutCore
- //*********************************************************************//
- MidiOutCore :: MidiOutCore( const std::string clientName ) : MidiOutApi()
- {
- initialize( clientName );
- }
- MidiOutCore :: ~MidiOutCore( void )
- {
- // Close a connection if it exists.
- closePort();
- // Cleanup.
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- MIDIClientDispose( data->client );
- if ( data->endpoint ) MIDIEndpointDispose( data->endpoint );
- delete data;
- }
- void MidiOutCore :: initialize( const std::string& clientName )
- {
- // Set up our client.
- MIDIClientRef client;
- OSStatus result = MIDIClientCreate( CFStringCreateWithCString( NULL, clientName.c_str(), kCFStringEncodingASCII ), NULL, NULL, &client );
- if ( result != noErr ) {
- errorString_ = "MidiOutCore::initialize: error creating OS-X MIDI client object.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific connection information.
- CoreMidiData *data = (CoreMidiData *) new CoreMidiData;
- data->client = client;
- data->endpoint = 0;
- apiData_ = (void *) data;
- }
- unsigned int MidiOutCore :: getPortCount()
- {
- return MIDIGetNumberOfDestinations();
- }
- std::string MidiOutCore :: getPortName( unsigned int portNumber )
- {
- CFStringRef nameRef;
- MIDIEndpointRef portRef;
- std::ostringstream ost;
- char name[128];
- std::string stringName;
- if ( portNumber >= MIDIGetNumberOfDestinations() ) {
- ost << "MidiOutCore::getPortName: the 'portNumber' argument (" << portNumber << ") is invalid.";
- errorString_ = ost.str();
- RtMidi::error( RtError::WARNING, errorString_ );
- return stringName;
- //RtMidi::error( RtError::INVALID_PARAMETER, errorString_ );
- }
- portRef = MIDIGetDestination( portNumber );
- nameRef = ConnectedEndpointName(portRef);
- CFStringGetCString( nameRef, name, sizeof(name), 0);
- CFRelease( nameRef );
-
- return stringName = name;
- }
- void MidiOutCore :: openPort( unsigned int portNumber, const std::string portName )
- {
- if ( connected_ ) {
- errorString_ = "MidiOutCore::openPort: a valid connection already exists!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- unsigned int nDest = MIDIGetNumberOfDestinations();
- if (nDest < 1) {
- errorString_ = "MidiOutCore::openPort: no MIDI output destinations found!";
- RtMidi::error( RtError::NO_DEVICES_FOUND, errorString_ );
- }
- std::ostringstream ost;
- if ( portNumber >= nDest ) {
- ost << "MidiOutCore::openPort: the 'portNumber' argument (" << portNumber << ") is invalid.";
- errorString_ = ost.str();
- RtMidi::error( RtError::INVALID_PARAMETER, errorString_ );
- }
- MIDIPortRef port;
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- OSStatus result = MIDIOutputPortCreate( data->client,
- CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ),
- &port );
- if ( result != noErr ) {
- MIDIClientDispose( data->client );
- errorString_ = "MidiOutCore::openPort: error creating OS-X MIDI output port.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Get the desired output port identifier.
- MIDIEndpointRef destination = MIDIGetDestination( portNumber );
- if ( destination == 0 ) {
- MIDIPortDispose( port );
- MIDIClientDispose( data->client );
- errorString_ = "MidiOutCore::openPort: error getting MIDI output destination reference.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific connection information.
- data->port = port;
- data->destinationId = destination;
- connected_ = true;
- }
- void MidiOutCore :: closePort( void )
- {
- if ( connected_ ) {
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- MIDIPortDispose( data->port );
- connected_ = false;
- }
- }
- void MidiOutCore :: openVirtualPort( std::string portName )
- {
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- if ( data->endpoint ) {
- errorString_ = "MidiOutCore::openVirtualPort: a virtual output port already exists!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- // Create a virtual MIDI output source.
- MIDIEndpointRef endpoint;
- OSStatus result = MIDISourceCreate( data->client,
- CFStringCreateWithCString( NULL, portName.c_str(), kCFStringEncodingASCII ),
- &endpoint );
- if ( result != noErr ) {
- errorString_ = "MidiOutCore::initialize: error creating OS-X virtual MIDI source.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific connection information.
- data->endpoint = endpoint;
- }
- char *sysexBuffer = 0;
- void sysexCompletionProc( MIDISysexSendRequest * sreq )
- {
- //std::cout << "Completed SysEx send\n";
- delete sysexBuffer;
- sysexBuffer = 0;
- }
- void MidiOutCore :: sendMessage( std::vector<unsigned char> *message )
- {
- // We use the MIDISendSysex() function to asynchronously send sysex
- // messages. Otherwise, we use a single CoreMidi MIDIPacket.
- unsigned int nBytes = message->size();
- if ( nBytes == 0 ) {
- errorString_ = "MidiOutCore::sendMessage: no data in message argument!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- // unsigned int packetBytes, bytesLeft = nBytes;
- // unsigned int messageIndex = 0;
- MIDITimeStamp timeStamp = AudioGetCurrentHostTime();
- CoreMidiData *data = static_cast<CoreMidiData *> (apiData_);
- OSStatus result;
- if ( message->at(0) == 0xF0 ) {
- while ( sysexBuffer != 0 ) usleep( 1000 ); // sleep 1 ms
- sysexBuffer = new char[nBytes];
- if ( sysexBuffer == NULL ) {
- errorString_ = "MidiOutCore::sendMessage: error allocating sysex message memory!";
- RtMidi::error( RtError::MEMORY_ERROR, errorString_ );
- }
- // Copy data to buffer.
- for ( unsigned int i=0; i<nBytes; ++i ) sysexBuffer[i] = message->at(i);
- data->sysexreq.destination = data->destinationId;
- data->sysexreq.data = (Byte *)sysexBuffer;
- data->sysexreq.bytesToSend = nBytes;
- data->sysexreq.complete = 0;
- data->sysexreq.completionProc = sysexCompletionProc;
- data->sysexreq.completionRefCon = &(data->sysexreq);
- result = MIDISendSysex( &(data->sysexreq) );
- if ( result != noErr ) {
- errorString_ = "MidiOutCore::sendMessage: error sending MIDI to virtual destinations.";
- RtMidi::error( RtError::WARNING, errorString_ );
- }
- return;
- }
- else if ( nBytes > 3 ) {
- errorString_ = "MidiOutCore::sendMessage: message format problem ... not sysex but > 3 bytes?";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- MIDIPacketList packetList;
- MIDIPacket *packet = MIDIPacketListInit( &packetList );
- packet = MIDIPacketListAdd( &packetList, sizeof(packetList), packet, timeStamp, nBytes, (const Byte *) &message->at( 0 ) );
- if ( !packet ) {
- errorString_ = "MidiOutCore::sendMessage: could not allocate packet list";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Send to any destinations that may have connected to us.
- if ( data->endpoint ) {
- result = MIDIReceived( data->endpoint, &packetList );
- if ( result != noErr ) {
- errorString_ = "MidiOutCore::sendMessage: error sending MIDI to virtual destinations.";
- RtMidi::error( RtError::WARNING, errorString_ );
- }
- }
- // And send to an explicit destination port if we're connected.
- if ( connected_ ) {
- result = MIDISend( data->port, data->destinationId, &packetList );
- if ( result != noErr ) {
- errorString_ = "MidiOutCore::sendMessage: error sending MIDI message to port.";
- RtMidi::error( RtError::WARNING, errorString_ );
- }
- }
- }
- #endif // __MACOSX_CORE__
- //*********************************************************************//
- // API: LINUX ALSA SEQUENCER
- //*********************************************************************//
- // API information found at:
- // - http://www.alsa-project.org/documentation.php#Library
- #if defined(__LINUX_ALSA__)
- // The ALSA Sequencer API is based on the use of a callback function for
- // MIDI input.
- //
- // Thanks to Pedro Lopez-Cabanillas for help with the ALSA sequencer
- // time stamps and other assorted fixes!!!
- // If you don't need timestamping for incoming MIDI events, define the
- // preprocessor definition AVOID_TIMESTAMPING to save resources
- // associated with the ALSA sequencer queues.
- #include <pthread.h>
- #include <sys/time.h>
- // ALSA header file.
- #include <alsa/asoundlib.h>
- // Global sequencer instance created when first In/Out object is
- // created, then destroyed when last In/Out is deleted.
- static snd_seq_t *s_seq = NULL;
- // Variable to keep track of how many ports are open.
- static unsigned int s_numPorts = 0;
- // The client name to use when creating the sequencer, which is
- // currently set on the first call to createSequencer.
- static std::string s_clientName = "RtMidi Client";
- // A structure to hold variables related to the ALSA API
- // implementation.
- struct AlsaMidiData {
- snd_seq_t *seq;
- unsigned int portNum;
- int vport;
- snd_seq_port_subscribe_t *subscription;
- snd_midi_event_t *coder;
- unsigned int bufferSize;
- unsigned char *buffer;
- pthread_t thread;
- pthread_t dummy_thread_id;
- unsigned long long lastTime;
- int queue_id; // an input queue is needed to get timestamped events
- int trigger_fds[2];
- };
- #define PORT_TYPE( pinfo, bits ) ((snd_seq_port_info_get_capability(pinfo) & (bits)) == (bits))
- snd_seq_t* createSequencer( const std::string& clientName )
- {
- // Set up the ALSA sequencer client.
- if ( s_seq == NULL ) {
- int result = snd_seq_open(&s_seq, "default", SND_SEQ_OPEN_DUPLEX, SND_SEQ_NONBLOCK);
- if ( result < 0 ) {
- s_seq = NULL;
- }
- else {
- // Set client name, use current name if given string is empty.
- if ( clientName != "" ) {
- s_clientName = clientName;
- }
- snd_seq_set_client_name( s_seq, s_clientName.c_str() );
- }
- }
- // Increment port count.
- s_numPorts++;
- return s_seq;
- }
- void freeSequencer ( void )
- {
- s_numPorts--;
- if ( s_numPorts == 0 && s_seq != NULL ) {
- snd_seq_close( s_seq );
- s_seq = NULL;
- }
- }
- //*********************************************************************//
- // API: LINUX ALSA
- // Class Definitions: MidiInAlsa
- //*********************************************************************//
- extern "C" void *alsaMidiHandler( void *ptr )
- {
- MidiInApi::RtMidiInData *data = static_cast<MidiInApi::RtMidiInData *> (ptr);
- AlsaMidiData *apiData = static_cast<AlsaMidiData *> (data->apiData);
- long nBytes;
- unsigned long long time, lastTime;
- bool continueSysex = false;
- bool doDecode = false;
- MidiInApi::MidiMessage message;
- int poll_fd_count;
- struct pollfd *poll_fds;
- snd_seq_event_t *ev;
- int result;
- apiData->bufferSize = 32;
- result = snd_midi_event_new( 0, &apiData->coder );
- if ( result < 0 ) {
- data->doInput = false;
- std::cerr << "\nMidiInAlsa::alsaMidiHandler: error initializing MIDI event parser!\n\n";
- return 0;
- }
- unsigned char *buffer = (unsigned char *) malloc( apiData->bufferSize );
- if ( buffer == NULL ) {
- data->doInput = false;
- snd_midi_event_free( apiData->coder );
- apiData->coder = 0;
- std::cerr << "\nMidiInAlsa::alsaMidiHandler: error initializing buffer memory!\n\n";
- return 0;
- }
- snd_midi_event_init( apiData->coder );
- snd_midi_event_no_status( apiData->coder, 1 ); // suppress running status messages
- poll_fd_count = snd_seq_poll_descriptors_count( apiData->seq, POLLIN ) + 1;
- poll_fds = (struct pollfd*)alloca( poll_fd_count * sizeof( struct pollfd ));
- snd_seq_poll_descriptors( apiData->seq, poll_fds + 1, poll_fd_count - 1, POLLIN );
- poll_fds[0].fd = apiData->trigger_fds[0];
- poll_fds[0].events = POLLIN;
- while ( data->doInput ) {
- if ( snd_seq_event_input_pending( apiData->seq, 1 ) == 0 ) {
- // No data pending
- if ( poll( poll_fds, poll_fd_count, -1) >= 0 ) {
- if ( poll_fds[0].revents & POLLIN ) {
- bool dummy;
- int res = read( poll_fds[0].fd, &dummy, sizeof(dummy) );
- (void) res;
- }
- }
- continue;
- }
- // If here, there should be data.
- result = snd_seq_event_input( apiData->seq, &ev );
- if ( result == -ENOSPC ) {
- std::cerr << "\nMidiInAlsa::alsaMidiHandler: MIDI input buffer overrun!\n\n";
- continue;
- }
- else if ( result <= 0 ) {
- std::cerr << "MidiInAlsa::alsaMidiHandler: unknown MIDI input error!\n";
- continue;
- }
- // This is a bit weird, but we now have to decode an ALSA MIDI
- // event (back) into MIDI bytes. We'll ignore non-MIDI types.
- if ( !continueSysex ) message.bytes.clear();
- doDecode = false;
- switch ( ev->type ) {
- case SND_SEQ_EVENT_PORT_SUBSCRIBED:
- #if defined(__RTMIDI_DEBUG__)
- std::cout << "MidiInAlsa::alsaMidiHandler: port connection made!\n";
- #endif
- break;
- case SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
- #if defined(__RTMIDI_DEBUG__)
- std::cerr << "MidiInAlsa::alsaMidiHandler: port connection has closed!\n";
- std::cout << "sender = " << (int) ev->data.connect.sender.client << ":"
- << (int) ev->data.connect.sender.port
- << ", dest = " << (int) ev->data.connect.dest.client << ":"
- << (int) ev->data.connect.dest.port
- << std::endl;
- #endif
- break;
- case SND_SEQ_EVENT_QFRAME: // MIDI time code
- if ( !( data->ignoreFlags & 0x02 ) ) doDecode = true;
- break;
- case SND_SEQ_EVENT_TICK: // MIDI timing tick
- if ( !( data->ignoreFlags & 0x02 ) ) doDecode = true;
- break;
- case SND_SEQ_EVENT_SENSING: // Active sensing
- if ( !( data->ignoreFlags & 0x04 ) ) doDecode = true;
- break;
- case SND_SEQ_EVENT_SYSEX:
- if ( (data->ignoreFlags & 0x01) ) break;
- if ( ev->data.ext.len > apiData->bufferSize ) {
- apiData->bufferSize = ev->data.ext.len;
- free( buffer );
- buffer = (unsigned char *) malloc( apiData->bufferSize );
- if ( buffer == NULL ) {
- data->doInput = false;
- std::cerr << "\nMidiInAlsa::alsaMidiHandler: error resizing buffer memory!\n\n";
- break;
- }
- }
- default:
- doDecode = true;
- }
- if ( doDecode ) {
- nBytes = snd_midi_event_decode( apiData->coder, buffer, apiData->bufferSize, ev );
- if ( nBytes > 0 ) {
- // The ALSA sequencer has a maximum buffer size for MIDI sysex
- // events of 256 bytes. If a device sends sysex messages larger
- // than this, they are segmented into 256 byte chunks. So,
- // we'll watch for this and concatenate sysex chunks into a
- // single sysex message if necessary.
- if ( !continueSysex )
- message.bytes.assign( buffer, &buffer[nBytes] );
- else
- message.bytes.insert( message.bytes.end(), buffer, &buffer[nBytes] );
- continueSysex = ( ( ev->type == SND_SEQ_EVENT_SYSEX ) && ( message.bytes.back() != 0xF7 ) );
- if ( !continueSysex ) {
- // Calculate the time stamp:
- message.timeStamp = 0.0;
- // Method 1: Use the system time.
- //(void)gettimeofday(&tv, (struct timezone *)NULL);
- //time = (tv.tv_sec * 1000000) + tv.tv_usec;
- // Method 2: Use the ALSA sequencer event time data.
- // (thanks to Pedro Lopez-Cabanillas!).
- time = ( ev->time.time.tv_sec * 1000000 ) + ( ev->time.time.tv_nsec/1000 );
- lastTime = time;
- time -= apiData->lastTime;
- apiData->lastTime = lastTime;
- if ( data->firstMessage == true )
- data->firstMessage = false;
- else
- message.timeStamp = time * 0.000001;
- }
- else {
- #if defined(__RTMIDI_DEBUG__)
- std::cerr << "\nMidiInAlsa::alsaMidiHandler: event parsing error or not a MIDI event!\n\n";
- #endif
- }
- }
- }
- snd_seq_free_event( ev );
- if ( message.bytes.size() == 0 || continueSysex ) continue;
- 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->queue.size < data->queue.ringSize ) {
- data->queue.ring[data->queue.back++] = message;
- if ( data->queue.back == data->queue.ringSize )
- data->queue.back = 0;
- data->queue.size++;
- }
- else
- std::cerr << "\nMidiInAlsa: message queue limit reached!!\n\n";
- }
- }
- if ( buffer ) free( buffer );
- snd_midi_event_free( apiData->coder );
- apiData->coder = 0;
- apiData->thread = apiData->dummy_thread_id;
- return 0;
- }
- MidiInAlsa :: MidiInAlsa( const std::string clientName, unsigned int queueSizeLimit ) : MidiInApi( queueSizeLimit )
- {
- initialize( clientName );
- }
- MidiInAlsa :: ~MidiInAlsa()
- {
- // Close a connection if it exists.
- closePort();
- // Shutdown the input thread.
- AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
- if ( inputData_.doInput ) {
- inputData_.doInput = false;
- int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof(inputData_.doInput) );
- (void) res;
- if ( !pthread_equal(data->thread, data->dummy_thread_id) )
- pthread_join( data->thread, NULL );
- }
- // Cleanup.
- close ( data->trigger_fds[0] );
- close ( data->trigger_fds[1] );
- if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
- #ifndef AVOID_TIMESTAMPING
- snd_seq_free_queue( data->seq, data->queue_id );
- #endif
- freeSequencer();
- delete data;
- }
- void MidiInAlsa :: initialize( const std::string& clientName )
- {
- snd_seq_t* seq = createSequencer( clientName );
- if ( seq == NULL ) {
- s_seq = NULL;
- errorString_ = "MidiInAlsa::initialize: error creating ALSA sequencer client object.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Save our api-specific connection information.
- AlsaMidiData *data = (AlsaMidiData *) new AlsaMidiData;
- data->seq = seq;
- data->portNum = -1;
- data->vport = -1;
- data->subscription = 0;
- data->dummy_thread_id = pthread_self();
- data->thread = data->dummy_thread_id;
- data->trigger_fds[0] = -1;
- data->trigger_fds[1] = -1;
- apiData_ = (void *) data;
- inputData_.apiData = (void *) data;
- if ( pipe(data->trigger_fds) == -1 ) {
- errorString_ = "MidiInAlsa::initialize: error creating pipe objects.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- // Create the input queue
- #ifndef AVOID_TIMESTAMPING
- data->queue_id = snd_seq_alloc_named_queue(s_seq, "RtMidi Queue");
- // Set arbitrary tempo (mm=100) and resolution (240)
- snd_seq_queue_tempo_t *qtempo;
- snd_seq_queue_tempo_alloca(&qtempo);
- snd_seq_queue_tempo_set_tempo(qtempo, 600000);
- snd_seq_queue_tempo_set_ppq(qtempo, 240);
- snd_seq_set_queue_tempo(data->seq, data->queue_id, qtempo);
- snd_seq_drain_output(data->seq);
- #endif
- }
- // This function is used to count or get the pinfo structure for a given port number.
- unsigned int portInfo( snd_seq_t *seq, snd_seq_port_info_t *pinfo, unsigned int type, int portNumber )
- {
- snd_seq_client_info_t *cinfo;
- int client;
- int count = 0;
- snd_seq_client_info_alloca( &cinfo );
- snd_seq_client_info_set_client( cinfo, -1 );
- while ( snd_seq_query_next_client( seq, cinfo ) >= 0 ) {
- client = snd_seq_client_info_get_client( cinfo );
- if ( client == 0 ) continue;
- // Reset query info
- snd_seq_port_info_set_client( pinfo, client );
- snd_seq_port_info_set_port( pinfo, -1 );
- while ( snd_seq_query_next_port( seq, pinfo ) >= 0 ) {
- unsigned int atyp = snd_seq_port_info_get_type( pinfo );
- if ( ( atyp & SND_SEQ_PORT_TYPE_MIDI_GENERIC ) == 0 ) continue;
- unsigned int caps = snd_seq_port_info_get_capability( pinfo );
- if ( ( caps & type ) != type ) continue;
- if ( count == portNumber ) return 1;
- ++count;
- }
- }
- // If a negative portNumber was used, return the port count.
- if ( portNumber < 0 ) return count;
- return 0;
- }
- unsigned int MidiInAlsa :: getPortCount()
- {
- snd_seq_port_info_t *pinfo;
- snd_seq_port_info_alloca( &pinfo );
- AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
- return portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, -1 );
- }
- std::string MidiInAlsa :: getPortName( unsigned int portNumber )
- {
- snd_seq_client_info_t *cinfo;
- snd_seq_port_info_t *pinfo;
- snd_seq_client_info_alloca( &cinfo );
- snd_seq_port_info_alloca( &pinfo );
- std::string stringName;
- AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
- if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, (int) portNumber ) ) {
- int cnum = snd_seq_port_info_get_client( pinfo );
- snd_seq_get_any_client_info( data->seq, cnum, cinfo );
- std::ostringstream os;
- os << snd_seq_client_info_get_name( cinfo );
- os << " "; // GO: These lines added to make sure devices are listed
- os << snd_seq_port_info_get_client( pinfo ); // GO: with full portnames added to ensure individual device names
- os << ":";
- os << snd_seq_port_info_get_port( pinfo );
- stringName = os.str();
- return stringName;
- }
- // If we get here, we didn't find a match.
- errorString_ = "MidiInAlsa::getPortName: error looking for port name!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return stringName;
- //RtMidi::error( RtError::INVALID_PARAMETER, errorString_ );
- }
- void MidiInAlsa :: openPort( unsigned int portNumber, const std::string portName )
- {
- if ( connected_ ) {
- errorString_ = "MidiInAlsa::openPort: a valid connection already exists!";
- RtMidi::error( RtError::WARNING, errorString_ );
- return;
- }
- unsigned int nSrc = this->getPortCount();
- if (nSrc < 1) {
- errorString_ = "MidiInAlsa::openPort: no MIDI input sources found!";
- RtMidi::error( RtError::NO_DEVICES_FOUND, errorString_ );
- }
- snd_seq_port_info_t *pinfo;
- snd_seq_port_info_alloca( &pinfo );
- std::ostringstream ost;
- AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
- if ( portInfo( data->seq, pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ, (int) portNumber ) == 0 ) {
- ost << "MidiInAlsa::openPort: the 'portNumber' argument (" << portNumber << ") is invalid.";
- errorString_ = ost.str();
- RtMidi::error( RtError::INVALID_PARAMETER, errorString_ );
- }
- snd_seq_addr_t sender, receiver;
- sender.client = snd_seq_port_info_get_client( pinfo );
- sender.port = snd_seq_port_info_get_port( pinfo );
- receiver.client = snd_seq_client_id( data->seq );
- if ( data->vport < 0 ) {
- snd_seq_port_info_set_client( pinfo, 0 );
- snd_seq_port_info_set_port( pinfo, 0 );
- snd_seq_port_info_set_capability( pinfo,
- SND_SEQ_PORT_CAP_WRITE |
- SND_SEQ_PORT_CAP_SUBS_WRITE );
- snd_seq_port_info_set_type( pinfo,
- SND_SEQ_PORT_TYPE_MIDI_GENERIC |
- SND_SEQ_PORT_TYPE_APPLICATION );
- snd_seq_port_info_set_midi_channels(pinfo, 16);
- #ifndef AVOID_TIMESTAMPING
- snd_seq_port_info_set_timestamping(pinfo, 1);
- snd_seq_port_info_set_timestamp_real(pinfo, 1);
- snd_seq_port_info_set_timestamp_queue(pinfo, data->queue_id);
- #endif
- snd_seq_port_info_set_name(pinfo, portName.c_str() );
- data->vport = snd_seq_create_port(data->seq, pinfo);
-
- if ( data->vport < 0 ) {
- errorString_ = "MidiInAlsa::openPort: ALSA error creating input port.";
- RtMidi::error( RtError::DRIVER_ERROR, errorString_ );
- }
- }
- receiver.port = data->vport;…