void Alsa::openPort(unsigned int portNumber_)
{
if ( _connected ) {
this->closePort();
}
unsigned int nSrc = this->getPortCount();
if (nSrc < 1) {
std::cerr << "error: CxxMidi::Output::Alsa::openPort: no MIDI output sources found" << std::endl;
}
snd_seq_port_info_t *pinfo;
snd_seq_port_info_alloca( &pinfo );
std::ostringstream ost;
if ( portInfo( _apiData->seq, pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE, (int) portNumber_ ) == 0 )
{
std::cerr << "error: CxxMidi::Output::Alsa::openPort: port " << portNumber_ << " is invalid" << std::endl;
}
snd_seq_addr_t sender, receiver;
receiver.client = snd_seq_port_info_get_client( pinfo );
receiver.port = snd_seq_port_info_get_port( pinfo );
sender.client = snd_seq_client_id( _apiData->seq );
if ( _apiData->vport < 0 ) {
_apiData->vport = snd_seq_create_simple_port( _apiData->seq, "CxxMidi (RtMidi) output",
SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ,
SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION );
if ( _apiData->vport < 0 ) {
std::cerr << "error: CxxMidi::Output::Alsa::openPort: error creating output port" << std::endl;
}
}
sender.port = _apiData->vport;
// Make subscription
snd_seq_port_subscribe_malloc( &_apiData->subscription );
snd_seq_port_subscribe_set_sender(_apiData->subscription, &sender);
snd_seq_port_subscribe_set_dest(_apiData->subscription, &receiver);
snd_seq_port_subscribe_set_time_update(_apiData->subscription, 1);
snd_seq_port_subscribe_set_time_real(_apiData->subscription, 1);
if ( snd_seq_subscribe_port(_apiData->seq, _apiData->subscription) ) {
std::cerr << "error: CxxMidi::Output::Alsa::openPort: error making port connection" << std::endl;
}
_connected = true;
}
void MidiAlsaSeq::subscribeWritablePort( MidiPort * _port,
const QString & _dest,
bool _subscribe )
{
if( !m_portIDs.contains( _port ) )
{
return;
}
const int pid = m_portIDs[_port][1] < 0 ? m_portIDs[_port][0] :
m_portIDs[_port][1];
if( pid < 0 )
{
return;
}
m_seqMutex.lock();
snd_seq_addr_t dest;
if( snd_seq_parse_address( m_seqHandle, &dest,
_dest.section( ' ', 0, 0 ).toLatin1().constData() ) )
{
fprintf( stderr, "error parsing dest-address!\n" );
m_seqMutex.unlock();
return;
}
snd_seq_port_info_t * port_info;
snd_seq_port_info_malloc( &port_info );
snd_seq_get_port_info( m_seqHandle, pid, port_info );
const snd_seq_addr_t * sender = snd_seq_port_info_get_addr( port_info );
snd_seq_port_subscribe_t * subs;
snd_seq_port_subscribe_malloc( &subs );
snd_seq_port_subscribe_set_sender( subs, sender );
snd_seq_port_subscribe_set_dest( subs, &dest );
if( _subscribe )
{
snd_seq_subscribe_port( m_seqHandle, subs );
}
else
{
snd_seq_unsubscribe_port( m_seqHandle, subs );
}
snd_seq_port_subscribe_free( subs );
snd_seq_port_info_free( port_info );
m_seqMutex.unlock();
}
/**
* Connects this Alsa midi input device with an Alsa MIDI source.
*
* @param Client - Alsa sequencer client and port ID of a MIDI source
* (e.g. "64:0")
* @throws MidiInputException if connection cannot be established
*/
void MidiInputDeviceAlsa::MidiInputPortAlsa::ConnectToAlsaMidiSource(const char* MidiSource) {
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t* subs;
int hExtClient, hExtPort;
sscanf(MidiSource, "%d:%d", &hExtClient, &hExtPort);
sender.client = (char) hExtClient;
sender.port = (char) hExtPort;
dest.client = (char) pDevice->hAlsaSeqClient;
dest.port = (char) portNumber;
snd_seq_port_subscribe_malloc(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_port_subscribe_set_queue(subs, 1);
snd_seq_port_subscribe_set_time_update(subs, 1);
snd_seq_port_subscribe_set_time_real(subs, 1);
if (snd_seq_subscribe_port(pDevice->hAlsaSeq, subs) < 0) {
snd_seq_port_subscribe_free(subs);
throw MidiInputException(String("Unable to connect to Alsa seq client \'") + MidiSource + "\' (" + snd_strerror(errno) + ")");
}
subscriptions.push_back(subs);
}
bool midi_init() {
snd_seq_addr_t sender, receiver;
snd_seq_port_info_t *pinfo;
snd_seq_client_info_t *cinfo;
bool found = false;
if (snd_seq_open(&s_midi, "default", SND_SEQ_OPEN_OUTPUT, 0) < 0) {
Error("Failed to initialize MIDI\n");
s_midi = NULL;
return false;
}
snd_seq_set_client_name(s_midi, s_midiCaption);
/* Create a port to work on */
s_midiPort = snd_seq_create_simple_port(s_midi, s_midiCaption, SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
if (s_midiPort < 0) {
Error("Failed to initialize MIDI\n");
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
/* Try to find a MIDI out */
snd_seq_port_info_alloca(&pinfo);
snd_seq_client_info_alloca(&cinfo);
snd_seq_client_info_set_client(cinfo, -1);
/* Walk all clients and ports, and see if one matches our demands */
while (snd_seq_query_next_client(s_midi, cinfo) >= 0 && !found) {
int client;
client = snd_seq_client_info_get_client(cinfo);
if (client == 0) continue;
snd_seq_port_info_set_client(pinfo, client);
snd_seq_port_info_set_port(pinfo, -1);
while (snd_seq_query_next_port(s_midi, pinfo) >= 0) {
if ((snd_seq_port_info_get_capability(pinfo) & (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) != (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) continue;
/* Most linux installations come with a Midi Through Port.
* This is 'hardware' support that mostly ends up on your serial, which
* you most likely do not have connected. So we skip it by default. */
if (strncmp("Midi Through Port", snd_seq_port_info_get_name(pinfo), 17) == 0) continue;
found = true;
break;
}
}
if (!found) {
Error("No valid MIDI output ports.\n Please install and start Timidity++ like: timidity -iA\n");
snd_seq_delete_port(s_midi, s_midiPort);
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
/* Subscribe ourself to the port */
receiver.client = snd_seq_port_info_get_client(pinfo);
receiver.port = snd_seq_port_info_get_port(pinfo);
sender.client = snd_seq_client_id(s_midi);
sender.port = s_midiPort;
snd_seq_port_subscribe_malloc(&s_midiSubscription);
snd_seq_port_subscribe_set_sender(s_midiSubscription, &sender);
snd_seq_port_subscribe_set_dest(s_midiSubscription, &receiver);
snd_seq_port_subscribe_set_time_update(s_midiSubscription, 1);
snd_seq_port_subscribe_set_time_real(s_midiSubscription, 1);
if (snd_seq_subscribe_port(s_midi, s_midiSubscription) < 0) {
Error("Failed to subscript to MIDI output\n");
snd_seq_delete_port(s_midi, s_midiPort);
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
/* Start the MIDI decoder */
if (snd_midi_event_new(4, &s_midiCoder) < 0) {
Error("Failed to initialize MIDI decoder\n");
snd_seq_delete_port(s_midi, s_midiPort);
snd_seq_close(s_midi);
s_midi = NULL;
return false;
}
snd_midi_event_init(s_midiCoder);
return true;
}
