int rtobject_update_alsa_seq_port_name(rtobject_t* rtobj){
snd_seq_port_info_t* port_info_ptr;
int port_id;
char *ret;
port_id = rtobject_get_address(rtobj);
if (port_id < 0){
return -1;
}
if (!port_id)
printf("modifying master path ALSA seq port !\n");
ret = rtobject_get_absolute_pathname(rtobj);
/*create an empty port descriptor structure*/
if ((snd_seq_port_info_malloc(&port_info_ptr)) < 0)
return -1;
/*set port id*/
snd_seq_port_info_set_port(port_info_ptr, port_id);
/*set port name*/
snd_seq_port_info_set_name(port_info_ptr, ret);
/*set capabilities*/
snd_seq_port_info_set_capability(port_info_ptr,\
SND_SEQ_PORT_CAP_WRITE|\
SND_SEQ_PORT_CAP_SUBS_WRITE);
/*set type*/
snd_seq_port_info_set_type(port_info_ptr, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
/*set the port info in sequencer*/
if (snd_seq_set_port_info(alsa_seq_client_handle, port_id, port_info_ptr) > 0){
printf("error: couldn't update port info of object being moved\n");
return -1;
}
/*free port descriptor structure*/
snd_seq_port_info_free(port_info_ptr);
free(ret);
/*recursively update names of member objects for signal paths*/
if (RTOBJECT_MAJOR_TYPE_SIGNAL_PATH == rtobject_get_major_type(rtobj)){
node_t *temp_node;
for (temp_node = ((signal_path_t*)rtobj->imp_struct)->object_list;\
temp_node; \
temp_node = temp_node->next){
rtobject_update_alsa_seq_port_name((rtobject_t*)temp_node->data);
}
}
return 0;
}
void MidiInputDeviceAlsa::MidiInputPortAlsa::ParameterName::OnSetValue(String s) throw (Exception) {
if (s.size() > 16) throw Exception("Name too long for ALSA MIDI input port (max. 16 characters)");
snd_seq_port_info_t* hInfo;
snd_seq_port_info_malloc(&hInfo);
snd_seq_get_port_info(((MidiInputDeviceAlsa*)pPort->GetDevice())->hAlsaSeq, pPort->GetPortNumber(), hInfo);
snd_seq_port_info_set_name(hInfo, s.c_str());
snd_seq_set_port_info(((MidiInputDeviceAlsa*)pPort->GetDevice())->hAlsaSeq, pPort->GetPortNumber(), hInfo);
snd_seq_port_info_free(hInfo);
}
void free_aseq_output(aseq_output_t *output)
{
int err = 0;
err = snd_seq_delete_port(output->handle, output->port);
if (0 != err)
output_error("problem while deleting alsa port\n%s\n", snd_strerror(err));
snd_seq_port_info_free(output->info);
free(output);
}
/*
* Class: org_tritonus_lowlevel_alsa_AlsaSeqPortInfo
* Method: free
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_org_tritonus_lowlevel_alsa_AlsaSeqPortInfo_free
(JNIEnv* env, jobject obj)
{
snd_seq_port_info_t* handle;
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaSeqPortInfo_free(): begin\n"); }
handle = getHandle(env, obj);
snd_seq_port_info_free(handle);
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaSeqPortInfo_free(): end\n"); }
}
//==============================================================================
static AlsaPort iterateMidiClient (const AlsaClient::Ptr& seq,
snd_seq_client_info_t* clientInfo,
const bool forInput,
StringArray& deviceNamesFound,
const int deviceIndexToOpen)
{
AlsaPort port;
snd_seq_t* seqHandle = seq->get();
snd_seq_port_info_t* portInfo = nullptr;
if (snd_seq_port_info_malloc (&portInfo) == 0)
{
int numPorts = snd_seq_client_info_get_num_ports (clientInfo);
const int client = snd_seq_client_info_get_client (clientInfo);
snd_seq_port_info_set_client (portInfo, client);
snd_seq_port_info_set_port (portInfo, -1);
while (--numPorts >= 0)
{
if (snd_seq_query_next_port (seqHandle, portInfo) == 0
&& (snd_seq_port_info_get_capability (portInfo) & (forInput ? SND_SEQ_PORT_CAP_READ
: SND_SEQ_PORT_CAP_WRITE)) != 0)
{
deviceNamesFound.add (snd_seq_client_info_get_name (clientInfo));
if (deviceNamesFound.size() == deviceIndexToOpen + 1)
{
const int sourcePort = snd_seq_port_info_get_port (portInfo);
const int sourceClient = snd_seq_client_info_get_client (clientInfo);
if (sourcePort != -1)
{
const String name (forInput ? JUCE_ALSA_MIDI_INPUT_NAME
: JUCE_ALSA_MIDI_OUTPUT_NAME);
seq->setName (name);
port.createPort (seq, name, forInput);
port.connectWith (sourceClient, sourcePort);
}
}
}
}
snd_seq_port_info_free (portInfo);
}
return port;
}
int rtobject_create_alsa_seq_port(rtobject_t* rtobj){
snd_seq_port_info_t* port_info_ptr;
int port_id;
char *ret;
port_id = rtobject_get_address(rtobj);
if ((RTOBJECT_MAJOR_TYPE_SIGNAL_PATH == rtobject_get_major_type(rtobj))&&\
(!(strcmp("main", rtobject_get_name(rtobj))))){
ret = strdup("main");
}else{
ret = rtobject_get_absolute_pathname(rtobj);
}
/*alsa only allows ports from 0 to 256, this is silly but we can only work around*/
if ((port_id < 0)||(port_id > 256)) return -1;
/*create an empty port descriptor structure*/
if ((snd_seq_port_info_malloc(&port_info_ptr)) < 0)
return -1;
/*set port id*/
snd_seq_port_info_set_port(port_info_ptr, port_id);
/*set port name*/
snd_seq_port_info_set_name(port_info_ptr, (const char*)ret);
/*set capabilities*/
snd_seq_port_info_set_capability(port_info_ptr,\
SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE);
/*set type*/
snd_seq_port_info_set_type(port_info_ptr,SND_SEQ_PORT_TYPE_MIDI_GENERIC);
/*create the port*/
if ((snd_seq_create_port(alsa_seq_client_handle, port_info_ptr)) < 0)
return -1;
/*free port descriptor structure*/
snd_seq_port_info_free(port_info_ptr);
free(ret);
return 0;
}
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();
}
static QString __portName( snd_seq_t * _seq, const snd_seq_addr_t * _addr )
{
snd_seq_client_info_t * cinfo;
snd_seq_port_info_t * pinfo;
snd_seq_client_info_malloc( &cinfo );
snd_seq_port_info_malloc( &pinfo );
snd_seq_get_any_port_info( _seq, _addr->client, _addr->port, pinfo );
snd_seq_get_any_client_info( _seq, _addr->client, cinfo );
const QString name = __portName( cinfo, pinfo );
snd_seq_client_info_free( cinfo );
snd_seq_port_info_free( pinfo );
return name;
}
void destroy_midi_hardware(struct MidiHardware *midi_hardware) {
if (midi_hardware) {
if (midi_hardware->thread) {
// send dummy event to make thread wake up from blocking
midi_hardware->quit_flag = true;
snd_seq_event_t ev;
snd_seq_ev_clear(&ev);
ev.source.client = midi_hardware->client_id;
ev.source.port = 0;
snd_seq_ev_set_subs(&ev);
snd_seq_ev_set_direct(&ev);
ev.type = SND_SEQ_EVENT_USR0;
int err = snd_seq_event_output(midi_hardware->seq, &ev);
if (err < 0)
panic("unable to send event: %s\n", snd_strerror(err));
err = snd_seq_drain_output(midi_hardware->seq);
if (err < 0)
panic("unable to drain output: %s\n", snd_strerror(err));
os_thread_destroy(midi_hardware->thread);
}
destroy_devices_info(midi_hardware->current_devices_info);
destroy_devices_info(midi_hardware->ready_devices_info);
genesis_midi_device_unref(midi_hardware->system_announce_device);
genesis_midi_device_unref(midi_hardware->system_timer_device);
if (midi_hardware->seq) {
if (midi_hardware->client_info)
snd_seq_client_info_free(midi_hardware->client_info);
if (midi_hardware->port_info)
snd_seq_port_info_free(midi_hardware->port_info);
snd_seq_close(midi_hardware->seq);
}
os_mutex_destroy(midi_hardware->mutex);
destroy(midi_hardware, 1);
}
}
void MidiAlsaSeq::applyPortName( MidiPort * _port )
{
m_seqMutex.lock();
for( int i = 0; i < 2; ++i )
{
if( m_portIDs[_port][i] == -1 )
{
continue;
}
snd_seq_port_info_t * port_info;
snd_seq_port_info_malloc( &port_info );
snd_seq_get_port_info( m_seqHandle, m_portIDs[_port][i],
port_info );
snd_seq_port_info_set_name( port_info,
_port->displayName().toUtf8().constData() );
snd_seq_set_port_info( m_seqHandle, m_portIDs[_port][i],
port_info );
snd_seq_port_info_free( port_info );
}
m_seqMutex.unlock();
}
void MidiAlsaSeq::updatePortList()
{
QStringList readablePorts;
QStringList writablePorts;
// get input- and output-ports
snd_seq_client_info_t * cinfo;
snd_seq_port_info_t * pinfo;
snd_seq_client_info_malloc( &cinfo );
snd_seq_port_info_malloc( &pinfo );
snd_seq_client_info_set_client( cinfo, -1 );
m_seqMutex.lock();
while( snd_seq_query_next_client( m_seqHandle, cinfo ) >= 0 )
{
int client = snd_seq_client_info_get_client( cinfo );
snd_seq_port_info_set_client( pinfo, client );
snd_seq_port_info_set_port( pinfo, -1 );
while( snd_seq_query_next_port( m_seqHandle, pinfo ) >= 0 )
{
// we need both READ and SUBS_READ
if( ( snd_seq_port_info_get_capability( pinfo )
& ( SND_SEQ_PORT_CAP_READ |
SND_SEQ_PORT_CAP_SUBS_READ ) ) ==
( SND_SEQ_PORT_CAP_READ |
SND_SEQ_PORT_CAP_SUBS_READ ) )
{
readablePorts.push_back( __portName( cinfo, pinfo ) );
}
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 ) )
{
writablePorts.push_back( __portName( cinfo, pinfo ) );
}
}
}
m_seqMutex.unlock();
snd_seq_client_info_free( cinfo );
snd_seq_port_info_free( pinfo );
if( m_readablePorts != readablePorts )
{
m_readablePorts = readablePorts;
emit readablePortsChanged();
}
if( m_writablePorts != writablePorts )
{
m_writablePorts = writablePorts;
emit writablePortsChanged();
}
}
void MidiAlsaSeq::applyPortMode( MidiPort * _port )
{
m_seqMutex.lock();
// determine port-capabilities
unsigned int caps[2] = { 0, 0 };
switch( _port->mode() )
{
case MidiPort::Duplex:
caps[1] |= SND_SEQ_PORT_CAP_READ |
SND_SEQ_PORT_CAP_SUBS_READ;
case MidiPort::Input:
caps[0] |= SND_SEQ_PORT_CAP_WRITE |
SND_SEQ_PORT_CAP_SUBS_WRITE;
break;
case MidiPort::Output:
caps[1] |= SND_SEQ_PORT_CAP_READ |
SND_SEQ_PORT_CAP_SUBS_READ;
break;
default:
break;
}
for( int i = 0; i < 2; ++i )
{
if( caps[i] != 0 )
{
// no port there yet?
if( m_portIDs[_port][i] == -1 )
{
// then create one;
m_portIDs[_port][i] =
snd_seq_create_simple_port(
m_seqHandle,
_port->displayName().toUtf8().constData(),
caps[i],
SND_SEQ_PORT_TYPE_MIDI_GENERIC |
SND_SEQ_PORT_TYPE_APPLICATION );
continue;
}
snd_seq_port_info_t * port_info;
snd_seq_port_info_malloc( &port_info );
snd_seq_get_port_info( m_seqHandle, m_portIDs[_port][i],
port_info );
snd_seq_port_info_set_capability( port_info, caps[i] );
snd_seq_set_port_info( m_seqHandle, m_portIDs[_port][i],
port_info );
snd_seq_port_info_free( port_info );
}
// still a port there although no caps? ( = dummy port)
else if( m_portIDs[_port][i] != -1 )
{
// then remove this port
snd_seq_delete_simple_port( m_seqHandle,
m_portIDs[_port][i] );
m_portIDs[_port][i] = -1;
}
}
m_seqMutex.unlock();
}
//==============================================================================
static snd_seq_t* iterateDevices (const bool forInput,
StringArray& deviceNamesFound,
const int deviceIndexToOpen)
{
snd_seq_t* returnedHandle = 0;
snd_seq_t* seqHandle;
if (snd_seq_open (&seqHandle, "default", forInput ? SND_SEQ_OPEN_INPUT
: SND_SEQ_OPEN_OUTPUT, 0) == 0)
{
snd_seq_system_info_t* systemInfo;
snd_seq_client_info_t* clientInfo;
if (snd_seq_system_info_malloc (&systemInfo) == 0)
{
if (snd_seq_system_info (seqHandle, systemInfo) == 0
&& snd_seq_client_info_malloc (&clientInfo) == 0)
{
int numClients = snd_seq_system_info_get_cur_clients (systemInfo);
while (--numClients >= 0 && returnedHandle == 0)
{
if (snd_seq_query_next_client (seqHandle, clientInfo) == 0)
{
snd_seq_port_info_t* portInfo;
if (snd_seq_port_info_malloc (&portInfo) == 0)
{
int numPorts = snd_seq_client_info_get_num_ports (clientInfo);
const int client = snd_seq_client_info_get_client (clientInfo);
snd_seq_port_info_set_client (portInfo, client);
snd_seq_port_info_set_port (portInfo, -1);
while (--numPorts >= 0)
{
if (snd_seq_query_next_port (seqHandle, portInfo) == 0
&& (snd_seq_port_info_get_capability (portInfo)
& (forInput ? SND_SEQ_PORT_CAP_READ
: SND_SEQ_PORT_CAP_WRITE)) != 0)
{
deviceNamesFound.add (snd_seq_client_info_get_name (clientInfo));
if (deviceNamesFound.size() == deviceIndexToOpen + 1)
{
const int sourcePort = snd_seq_port_info_get_port (portInfo);
const int sourceClient = snd_seq_client_info_get_client (clientInfo);
if (sourcePort != -1)
{
snd_seq_set_client_name (seqHandle,
forInput ? "Juce Midi Input"
: "Juce Midi Output");
const int portId
= snd_seq_create_simple_port (seqHandle,
forInput ? "Juce Midi In Port"
: "Juce Midi Out Port",
forInput ? (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)
: (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ),
SND_SEQ_PORT_TYPE_MIDI_GENERIC);
snd_seq_connect_from (seqHandle, portId, sourceClient, sourcePort);
returnedHandle = seqHandle;
}
}
}
}
snd_seq_port_info_free (portInfo);
}
}
}
snd_seq_client_info_free (clientInfo);
}
snd_seq_system_info_free (systemInfo);
}
if (returnedHandle == 0)
snd_seq_close (seqHandle);
}
deviceNamesFound.appendNumbersToDuplicates (true, true);
return returnedHandle;
}
