void
a2j_port_fill_name (struct a2j_port * port_ptr, int dir, snd_seq_client_info_t * client_info_ptr,
const snd_seq_port_info_t * port_info_ptr, bool make_unique)
{
char *c;
if (make_unique) {
snprintf (port_ptr->name,
sizeof(port_ptr->name),
"%s [%d] %s %s",
snd_seq_client_info_get_name(client_info_ptr),
snd_seq_client_info_get_client(client_info_ptr),
snd_seq_port_info_get_name(port_info_ptr),
(dir == A2J_PORT_CAPTURE ? "in" : "out"));
} else {
snprintf (port_ptr->name,
sizeof(port_ptr->name),
"%s %s %s",
snd_seq_client_info_get_name(client_info_ptr),
snd_seq_port_info_get_name(port_info_ptr),
(dir == A2J_PORT_CAPTURE ? "in" : "out"));
}
// replace all offending characters with ' '
for (c = port_ptr->name; *c; ++c) {
if (!JACK_IS_VALID_PORT_NAME_CHAR(*c)) {
*c = ' ';
}
}
}
/* call-seq:
name -> string
Returns the name of the port
*/
static VALUE
wrap_snd_seq_port_info_get_name(VALUE v_port_info)
{
snd_seq_port_info_t *port_info;
Data_Get_Struct(v_port_info, snd_seq_port_info_t, port_info);
return rb_str_new2(snd_seq_port_info_get_name(port_info));
}
static void list_ports(void)
{
snd_seq_client_info_t *cinfo;
snd_seq_port_info_t *pinfo;
snd_seq_client_info_alloca(&cinfo);
snd_seq_port_info_alloca(&pinfo);
puts(" Port Client name Port name");
snd_seq_client_info_set_client(cinfo, -1);
while (snd_seq_query_next_client(seq, 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(seq, 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))
continue;
printf("%3d:%-3d %-32.32s %s\n",
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo));
}
}
}
static void print_port(snd_seq_t *seq, snd_seq_client_info_t *cinfo,
snd_seq_port_info_t *pinfo, int count)
{
if (! count) {
int card = -1, pid = -1;
printf(_("client %d: '%s' [type=%s"),
snd_seq_client_info_get_client(cinfo),
snd_seq_client_info_get_name(cinfo),
(snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ?
_("user") : _("kernel")));
#ifdef HAVE_SEQ_CLIENT_INFO_GET_CARD
card = snd_seq_client_info_get_card(cinfo);
#endif
if (card != -1)
printf(",card=%d", card);
#ifdef HAVE_SEQ_CLIENT_INFO_GET_PID
pid = snd_seq_client_info_get_pid(cinfo);
#endif
if (pid != -1)
printf(",pid=%d", pid);
printf("]\n");
}
printf(" %3d '%-16s'\n",
snd_seq_port_info_get_port(pinfo),
snd_seq_port_info_get_name(pinfo));
}
// static helper functions
static QString __portName( snd_seq_client_info_t * _cinfo,
snd_seq_port_info_t * _pinfo )
{
return QString( "%1:%2 %3:%4" ).
arg( snd_seq_port_info_get_client( _pinfo ) ).
arg( snd_seq_port_info_get_port( _pinfo ) ).
arg( snd_seq_client_info_get_name( _cinfo ) ).
arg( snd_seq_port_info_get_name( _pinfo ) );
}
static void print_port(snd_seq_t *seq, snd_seq_client_info_t *cinfo,
snd_seq_port_info_t *pinfo, int count)
{
if (! count) {
printf(_("client %d: '%s' [type=%s]\n"),
snd_seq_client_info_get_client(cinfo),
snd_seq_client_info_get_name(cinfo),
(snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ?
_("user") : _("kernel")));
}
printf(" %3d '%-16s'\n",
snd_seq_port_info_get_port(pinfo),
snd_seq_port_info_get_name(pinfo));
}
/*
* Class: org_tritonus_lowlevel_alsa_AlsaSeqPortInfo
* Method: getName
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_org_tritonus_lowlevel_alsa_AlsaSeqPortInfo_getName
(JNIEnv* env, jobject obj)
{
snd_seq_port_info_t* handle;
const char* name;
jstring nameObj;
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaSeqPortInfo_getName(): begin\n"); }
handle = getHandle(env, obj);
name = snd_seq_port_info_get_name(handle);
nameObj = (*env)->NewStringUTF(env, name);
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaSeqPortInfo_getName(): end\n"); }
return nameObj;
}
void MIDIDevice::extractName()
{
MIDIInput* plugin = static_cast<MIDIInput*> (parent());
if (plugin == NULL || plugin->alsa() == NULL || m_address == NULL)
return;
snd_seq_port_info_t* portInfo = NULL;
snd_seq_port_info_alloca(&portInfo);
int r = snd_seq_get_any_port_info(plugin->alsa(), m_address->client,
m_address->port, portInfo);
if (r == 0)
m_name = QString(snd_seq_port_info_get_name(portInfo));
else
m_name = QString("ERROR");
}
QStringList qxgeditMidiDevice::deviceList ( bool bReadable ) const
{
QStringList list;
if (m_pAlsaSeq == NULL)
return list;
unsigned int uiPortFlags;
if (bReadable)
uiPortFlags = SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
else
uiPortFlags = SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
snd_seq_client_info_t *pClientInfo;
snd_seq_port_info_t *pPortInfo;
snd_seq_client_info_alloca(&pClientInfo);
snd_seq_port_info_alloca(&pPortInfo);
snd_seq_client_info_set_client(pClientInfo, -1);
while (snd_seq_query_next_client(m_pAlsaSeq, pClientInfo) >= 0) {
int iAlsaClient = snd_seq_client_info_get_client(pClientInfo);
if (iAlsaClient > 0 && iAlsaClient != m_iAlsaClient) {
snd_seq_port_info_set_client(pPortInfo, iAlsaClient);
snd_seq_port_info_set_port(pPortInfo, -1);
while (snd_seq_query_next_port(m_pAlsaSeq, pPortInfo) >= 0) {
unsigned int uiPortCapability
= snd_seq_port_info_get_capability(pPortInfo);
if (((uiPortCapability & uiPortFlags) == uiPortFlags) &&
((uiPortCapability & SND_SEQ_PORT_CAP_NO_EXPORT) == 0)) {
int iAlsaPort = snd_seq_port_info_get_port(pPortInfo);
QString sItem = QString::number(iAlsaClient) + ':';
sItem += snd_seq_client_info_get_name(pClientInfo);
sItem += c_pszItemSep;
sItem += QString::number(iAlsaPort) + ':';
sItem += snd_seq_port_info_get_name(pPortInfo);
list.append(sItem);
}
}
}
}
return list;
}
void MIDIDevice::extractName()
{
snd_seq_port_info_t* portInfo = NULL;
MIDIOut* plugin;
int r;
plugin = static_cast<MIDIOut*> (parent());
Q_ASSERT(plugin != NULL);
Q_ASSERT(plugin->alsa() != NULL);
Q_ASSERT(m_address != NULL);
snd_seq_port_info_alloca(&portInfo);
r = snd_seq_get_any_port_info(plugin->alsa(), m_address->client,
m_address->port, portInfo);
if (r == 0)
m_name = QString(snd_seq_port_info_get_name(portInfo));
else
m_name = tr("Unknown");
}
/*
discover the sequencer devices currently available
*/
static int alsa_sequencer_list(ClientData clientData, Tcl_Interp *interp) {
snd_seq_client_info_t *cinfo;
snd_seq_port_info_t *pinfo;
Tcl_Obj *result = Tcl_NewListObj(0, NULL);
if (init_seq(clientData, interp) != TCL_OK) {
return TCL_ERROR;
}
snd_seq_client_info_alloca(&cinfo);
snd_seq_port_info_alloca(&pinfo);
snd_seq_client_info_set_client(cinfo, -1);
while (snd_seq_query_next_client(seq, 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(seq, pinfo) >= 0) {
/* we need both READ and SUBS_READ */
int capability = snd_seq_port_info_get_capability(pinfo);
char *readable = ((capability &
(SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ)) ==
(SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ)) ? "r" : "";
char *writable = ((capability &
(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) ==
(SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE)) ? "w" : "";
Tcl_Obj *element = Tcl_ObjPrintf("%3d:%-3d %-32.32s %s %s%s",
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
readable, writable);
Tcl_ListObjAppendElement(interp, result, element);
}
}
Tcl_SetObjResult(interp, result);
return TCL_OK;
}
/**************************************************************************
* ALSA_AddMidiPort [internal]
*
* Helper for ALSA_MidiInit
*/
static void ALSA_AddMidiPort(snd_seq_client_info_t* cinfo, snd_seq_port_info_t* pinfo, int cap, int type)
{
if (cap & SND_SEQ_PORT_CAP_WRITE) {
TRACE("OUT (%d:%s:%s:%d:%s:%x)\n",snd_seq_client_info_get_client(cinfo),
snd_seq_client_info_get_name(cinfo),
snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ? "user" : "kernel",
snd_seq_port_info_get_port(pinfo),
snd_seq_port_info_get_name(pinfo),
type);
if (MODM_NumDevs >= MAX_MIDIOUTDRV)
return;
if (!type)
return;
memcpy(&MidiOutDev[MODM_NumDevs].addr, snd_seq_port_info_get_addr(pinfo), sizeof(snd_seq_addr_t));
/* Manufac ID. We do not have access to this with soundcard.h
* Does not seem to be a problem, because in mmsystem.h only
* Microsoft's ID is listed.
*/
MidiOutDev[MODM_NumDevs].caps.wMid = 0x00FF;
MidiOutDev[MODM_NumDevs].caps.wPid = 0x0001; /* FIXME Product ID */
/* Product Version. We simply say "1" */
MidiOutDev[MODM_NumDevs].caps.vDriverVersion = 0x001;
MidiOutDev[MODM_NumDevs].caps.wChannelMask = 0xFFFF;
/* FIXME Do we have this information?
* Assuming the soundcards can handle
* MIDICAPS_VOLUME and MIDICAPS_LRVOLUME but
* not MIDICAPS_CACHE.
*/
MidiOutDev[MODM_NumDevs].caps.dwSupport = MIDICAPS_VOLUME|MIDICAPS_LRVOLUME;
MultiByteToWideChar(CP_ACP, 0, snd_seq_client_info_get_name(cinfo), -1,
MidiOutDev[MODM_NumDevs].caps.szPname,
sizeof(MidiOutDev[MODM_NumDevs].caps.szPname) / sizeof(WCHAR));
MidiOutDev[MODM_NumDevs].caps.wTechnology = MIDI_AlsaToWindowsDeviceType(type);
MidiOutDev[MODM_NumDevs].caps.wVoices = 16;
/* FIXME Is it possible to know the maximum
* number of simultaneous notes of a soundcard ?
* I believe we don't have this information, but
* it's probably equal or more than wVoices
*/
MidiOutDev[MODM_NumDevs].caps.wNotes = 16;
MidiOutDev[MODM_NumDevs].bEnabled = TRUE;
TRACE("MidiOut[%d]\tname='%s' techn=%d voices=%d notes=%d chnMsk=%04x support=%ld\n"
"\tALSA info: midi dev-type=%lx, capa=%lx\n",
MODM_NumDevs, wine_dbgstr_w(MidiOutDev[MODM_NumDevs].caps.szPname),
MidiOutDev[MODM_NumDevs].caps.wTechnology,
MidiOutDev[MODM_NumDevs].caps.wVoices, MidiOutDev[MODM_NumDevs].caps.wNotes,
MidiOutDev[MODM_NumDevs].caps.wChannelMask, MidiOutDev[MODM_NumDevs].caps.dwSupport,
(long)type, (long)0);
MODM_NumDevs++;
}
if (cap & SND_SEQ_PORT_CAP_READ) {
TRACE("IN (%d:%s:%s:%d:%s:%x)\n",snd_seq_client_info_get_client(cinfo),
snd_seq_client_info_get_name(cinfo),
snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ? "user" : "kernel",
snd_seq_port_info_get_port(pinfo),
snd_seq_port_info_get_name(pinfo),
type);
if (MIDM_NumDevs >= MAX_MIDIINDRV)
return;
if (!type)
return;
memcpy(&MidiInDev[MIDM_NumDevs].addr, snd_seq_port_info_get_addr(pinfo), sizeof(snd_seq_addr_t));
/* Manufac ID. We do not have access to this with soundcard.h
* Does not seem to be a problem, because in mmsystem.h only
* Microsoft's ID is listed.
*/
MidiInDev[MIDM_NumDevs].caps.wMid = 0x00FF;
MidiInDev[MIDM_NumDevs].caps.wPid = 0x0001; /* FIXME Product ID */
/* Product Version. We simply say "1" */
MidiInDev[MIDM_NumDevs].caps.vDriverVersion = 0x001;
/* FIXME Do we have this information?
* Assuming the soundcards can handle
* MIDICAPS_VOLUME and MIDICAPS_LRVOLUME but
* not MIDICAPS_CACHE.
*/
MidiInDev[MIDM_NumDevs].caps.dwSupport = MIDICAPS_VOLUME|MIDICAPS_LRVOLUME;
MultiByteToWideChar(CP_ACP, 0, snd_seq_client_info_get_name(cinfo), -1,
MidiInDev[MIDM_NumDevs].caps.szPname,
sizeof(MidiInDev[MIDM_NumDevs].caps.szPname) / sizeof(WCHAR));
MidiInDev[MIDM_NumDevs].state = 0;
TRACE("MidiIn [%d]\tname='%s' support=%ld\n"
"\tALSA info: midi dev-type=%lx, capa=%lx\n",
MIDM_NumDevs, wine_dbgstr_w(MidiInDev[MIDM_NumDevs].caps.szPname),
MidiInDev[MIDM_NumDevs].caps.dwSupport,
(long)type, (long)0);
MIDM_NumDevs++;
}
}
void
mastermidibus::port_start (int a_client, int a_port)
{
#ifdef HAVE_LIBASOUND
automutex locker(m_mutex);
snd_seq_client_info_t * cinfo; /* client info */
snd_seq_client_info_alloca(&cinfo);
snd_seq_get_any_client_info(m_alsa_seq, a_client, cinfo);
snd_seq_port_info_t * pinfo; /* port info */
snd_seq_port_info_alloca(&pinfo);
snd_seq_get_any_port_info(m_alsa_seq, a_client, a_port, pinfo);
int cap = snd_seq_port_info_get_capability(pinfo); /* get its capability */
if (snd_seq_client_id(m_alsa_seq) != snd_seq_port_info_get_client(pinfo))
{
if /* the outputs */
(
(cap & (SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_WRITE)) ==
(SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_WRITE) &&
snd_seq_client_id(m_alsa_seq) != snd_seq_port_info_get_client(pinfo)
)
{
bool replacement = false;
int bus_slot = m_num_out_buses;
for (int i = 0; i < m_num_out_buses; i++)
{
if
(
m_buses_out[i]->get_client() == a_client &&
m_buses_out[i]->get_port() == a_port &&
m_buses_out_active[i] == false
)
{
replacement = true;
bus_slot = i;
}
}
m_buses_out[bus_slot] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_out_buses,
m_queue
);
m_buses_out[bus_slot]->init_out();
m_buses_out_active[bus_slot] = true;
m_buses_out_init[bus_slot] = true;
if (! replacement)
m_num_out_buses++;
}
if /* the inputs */
(
(cap & (SND_SEQ_PORT_CAP_SUBS_READ | SND_SEQ_PORT_CAP_READ)) ==
(SND_SEQ_PORT_CAP_SUBS_READ | SND_SEQ_PORT_CAP_READ) &&
snd_seq_client_id(m_alsa_seq) != snd_seq_port_info_get_client(pinfo)
)
{
bool replacement = false;
int bus_slot = m_num_in_buses;
for (int i = 0; i < m_num_in_buses; i++)
{
if
(
m_buses_in[i]->get_client() == a_client &&
m_buses_in[i]->get_port() == a_port &&
m_buses_in_active[i] == false
)
{
replacement = true;
bus_slot = i;
}
}
m_buses_in[bus_slot] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_in_buses,
m_queue
);
m_buses_in_active[bus_slot] = true;
m_buses_in_init[bus_slot] = true;
if (! replacement)
m_num_in_buses++;
}
} /* end loop for clients */
/*
* Get the number of MIDI input poll file descriptors.
*/
m_num_poll_descriptors = snd_seq_poll_descriptors_count(m_alsa_seq, POLLIN);
m_poll_descriptors = new pollfd[m_num_poll_descriptors]; /* allocate info */
snd_seq_poll_descriptors /* get input descriptors */
(
m_alsa_seq, m_poll_descriptors, m_num_poll_descriptors, POLLIN
);
#endif // HAVE_LIBASOUND
}
void
mastermidibus::port_start( int a_client, int a_port )
{
lock();
/* client info */
snd_seq_client_info_t *cinfo;
snd_seq_client_info_alloca(&cinfo);
snd_seq_get_any_client_info( m_alsa_seq, a_client, cinfo );
/* port info */
snd_seq_port_info_t *pinfo;
/* fill pinfo */
snd_seq_port_info_alloca(&pinfo);
snd_seq_get_any_port_info( m_alsa_seq, a_client, a_port, pinfo );
/* get its capability */
int cap = snd_seq_port_info_get_capability(pinfo);
if ( snd_seq_client_id( m_alsa_seq ) != snd_seq_port_info_get_client(pinfo)){
/* the outs */
if ( (cap & (SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_WRITE ))
== (SND_SEQ_PORT_CAP_SUBS_WRITE | SND_SEQ_PORT_CAP_WRITE )
&& snd_seq_client_id( m_alsa_seq ) != snd_seq_port_info_get_client(pinfo)){
bool replacement = false;
int bus_slot = m_num_out_buses;
for( int i=0; i< m_num_out_buses; i++ ){
if( m_buses_out[i]->get_client() == a_client &&
m_buses_out[i]->get_port() == a_port &&
m_buses_out_active[i] == false ){
replacement = true;
bus_slot = i;
}
}
m_buses_out[bus_slot] =
new midibus( snd_seq_client_id( m_alsa_seq ),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_out_buses, m_queue );
m_buses_out[bus_slot]->init_out();
m_buses_out_active[bus_slot] = true;
m_buses_out_init[bus_slot] = true;
if ( !replacement ){
m_num_out_buses++;
}
}
/* the ins */
if ( (cap & (SND_SEQ_PORT_CAP_SUBS_READ | SND_SEQ_PORT_CAP_READ ))
== (SND_SEQ_PORT_CAP_SUBS_READ | SND_SEQ_PORT_CAP_READ )
&& snd_seq_client_id( m_alsa_seq ) != snd_seq_port_info_get_client(pinfo)){
bool replacement = false;
int bus_slot = m_num_in_buses;
for( int i=0; i< m_num_in_buses; i++ ){
if( m_buses_in[i]->get_client() == a_client &&
m_buses_in[i]->get_port() == a_port &&
m_buses_in_active[i] == false ){
replacement = true;
bus_slot = i;
}
}
//printf( "in [%d] [%d]\n", replacement, bus_slot );
m_buses_in[bus_slot] =
new midibus( snd_seq_client_id( m_alsa_seq ),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_in_buses, m_queue);
//m_buses_in[bus_slot]->init_in();
m_buses_in_active[bus_slot] = true;
m_buses_in_init[bus_slot] = true;
if ( !replacement ){
m_num_in_buses++;
}
}
}
/* end loop for clients */
/* midi input */
/* poll descriptors */
/* get number of file descriptors */
m_num_poll_descriptors = snd_seq_poll_descriptors_count(m_alsa_seq, POLLIN);
/* allocate into */
m_poll_descriptors = new pollfd[m_num_poll_descriptors];
/* get descriptors */
snd_seq_poll_descriptors(m_alsa_seq,
m_poll_descriptors,
m_num_poll_descriptors,
POLLIN);
unlock();
}
void
mastermidibus::init( )
{
/* client info */
snd_seq_client_info_t *cinfo;
/* port info */
snd_seq_port_info_t *pinfo;
int client;
snd_seq_client_info_alloca(&cinfo);
snd_seq_client_info_set_client(cinfo, -1);
//printf( "global_ports %d\n", global_manual_alsa_ports );
if ( global_manual_alsa_ports )
{
int num_buses = 16;
for( int i=0; i<num_buses; ++i )
{
m_buses_out[i] =
new midibus( snd_seq_client_id( m_alsa_seq ), m_alsa_seq, i+1, m_queue );
m_buses_out[i]->init_out_sub();
m_buses_out_active[i] = true;
m_buses_out_init[i] = true;
}
m_num_out_buses = num_buses;
/* only one in */
m_buses_in[0] =
new midibus( snd_seq_client_id( m_alsa_seq ),
m_alsa_seq,
m_num_in_buses, m_queue);
m_buses_in[0]->init_in_sub();
m_buses_in_active[0] = true;
m_buses_in_init[0] = true;
m_num_in_buses = 1;
}
else
{
/* while the next client one the sequencer is avaiable */
while (snd_seq_query_next_client(m_alsa_seq, cinfo) >= 0){
/* get client from cinfo */
client = snd_seq_client_info_get_client(cinfo);
/* fill pinfo */
snd_seq_port_info_alloca(&pinfo);
snd_seq_port_info_set_client(pinfo, client);
snd_seq_port_info_set_port(pinfo, -1);
/* while the next port is avail */
while (snd_seq_query_next_port(m_alsa_seq, pinfo) >= 0 ){
/* get its capability */
int cap = snd_seq_port_info_get_capability(pinfo);
if ( snd_seq_client_id( m_alsa_seq ) != snd_seq_port_info_get_client(pinfo) &&
snd_seq_port_info_get_client(pinfo) != SND_SEQ_CLIENT_SYSTEM){
/* the outs */
if ( (cap & SND_SEQ_PORT_CAP_SUBS_WRITE) != 0 &&
snd_seq_client_id( m_alsa_seq ) != snd_seq_port_info_get_client(pinfo)){
m_buses_out[m_num_out_buses] =
new midibus( snd_seq_client_id( m_alsa_seq ),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_out_buses, m_queue );
if ( m_buses_out[m_num_out_buses]->init_out() ){
m_buses_out_active[m_num_out_buses] = true;
m_buses_out_init[m_num_out_buses] = true;
} else {
m_buses_out_init[m_num_out_buses] = true;
}
m_num_out_buses++;
}
/* the ins */
if ( (cap & SND_SEQ_PORT_CAP_SUBS_READ) != 0 &&
snd_seq_client_id( m_alsa_seq ) != snd_seq_port_info_get_client(pinfo)){
m_buses_in[m_num_in_buses] =
new midibus( snd_seq_client_id( m_alsa_seq ),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_in_buses, m_queue);
//if ( m_buses_in[m_num_in_buses]->init_in() ){
m_buses_in_active[m_num_in_buses] = true;
m_buses_in_init[m_num_in_buses] = true;
//} else {
//m_buses_in_init[m_num_in_buses] = true;
//}
m_num_in_buses++;
}
}
}
} /* end loop for clients */
}
set_bpm( c_bpm );
set_ppqn( c_ppqn );
/* midi input */
/* poll descriptors */
/* get number of file descriptors */
m_num_poll_descriptors = snd_seq_poll_descriptors_count(m_alsa_seq, POLLIN);
/* allocate into */
m_poll_descriptors = new pollfd[m_num_poll_descriptors];
/* get descriptors */
snd_seq_poll_descriptors(m_alsa_seq,
m_poll_descriptors,
m_num_poll_descriptors,
POLLIN);
set_sequence_input( false, NULL );
/* sizes */
snd_seq_set_output_buffer_size(m_alsa_seq, c_midibus_output_size );
snd_seq_set_input_buffer_size(m_alsa_seq, c_midibus_input_size );
m_bus_announce =
new midibus( snd_seq_client_id( m_alsa_seq ),
SND_SEQ_CLIENT_SYSTEM,
SND_SEQ_PORT_SYSTEM_ANNOUNCE,
m_alsa_seq,
"system","annouce",
0, m_queue);
m_bus_announce->set_input(true);
for ( int i=0; i<m_num_out_buses; i++ )
set_clock(i,m_init_clock[i]);
for ( int i=0; i<m_num_in_buses; i++ )
set_input(i,m_init_input[i]);
}
static int midi_hardware_refresh(MidiHardware *midi_hardware) {
MidiDevicesInfo *info = create_zero<MidiDevicesInfo>();
if (!info) {
destroy_devices_info(info);
return GenesisErrorNoMem;
}
info->devices.clear();
info->default_device_index = -1;
// don't default to MIDI through except as a last resort
bool default_is_midi_through = false;
snd_seq_client_info_set_client(midi_hardware->client_info, -1);
while (snd_seq_query_next_client(midi_hardware->seq, midi_hardware->client_info) >= 0) {
int client = snd_seq_client_info_get_client(midi_hardware->client_info);
snd_seq_port_info_set_client(midi_hardware->port_info, client);
snd_seq_port_info_set_port(midi_hardware->port_info, -1);
while (snd_seq_query_next_port(midi_hardware->seq, midi_hardware->port_info) >= 0) {
if ((snd_seq_port_info_get_capability(midi_hardware->port_info)
& (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
!= (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
{
continue;
}
GenesisMidiDevice *device = create_zero<GenesisMidiDevice>();
if (!device) {
genesis_midi_device_unref(device);
return GenesisErrorNoMem;
}
device->midi_hardware = midi_hardware;
device->ref_count = 1;
device->set_index = -1;
device->client_id = snd_seq_port_info_get_client(midi_hardware->port_info);
device->port_id = snd_seq_port_info_get_port(midi_hardware->port_info);
device->client_name = strdup(snd_seq_client_info_get_name(midi_hardware->client_info));
device->port_name = strdup(snd_seq_port_info_get_name(midi_hardware->port_info));
if (!device->client_name || !device->port_name) {
genesis_midi_device_unref(device);
return GenesisErrorNoMem;
}
if (strcmp(device->client_name, "System") == 0 &&
strcmp(device->port_name, "Timer") == 0)
{
genesis_midi_device_unref(midi_hardware->system_timer_device);
midi_hardware->system_timer_device = device;
} else if (strcmp(device->client_name, "System") == 0 &&
strcmp(device->port_name, "Announce") == 0)
{
genesis_midi_device_unref(midi_hardware->system_announce_device);
midi_hardware->system_announce_device = device;
} else {
if (info->default_device_index == -1 || default_is_midi_through) {
info->default_device_index = info->devices.length();
default_is_midi_through = strcmp(device->client_name, "Midi Through") == 0;
}
int err = info->devices.append(device);
if (err) {
genesis_midi_device_unref(device);
return GenesisErrorNoMem;
}
}
}
}
os_mutex_lock(midi_hardware->mutex);
MidiDevicesInfo *old_devices_info = midi_hardware->ready_devices_info;
midi_hardware->ready_devices_info = info;
os_mutex_unlock(midi_hardware->mutex);
destroy_devices_info(old_devices_info);
midi_hardware->events_signal(midi_hardware);
return 0;
}
// MIDI Input(readable) / Output(writable) device connects.
bool qxgeditMidiDevice::connectDeviceList (
bool bReadable, const QStringList& list ) const
{
if (m_pAlsaSeq == NULL)
return false;
if (list.isEmpty())
return false;
snd_seq_addr_t seq_addr;
snd_seq_port_subscribe_t *pPortSubs;
snd_seq_port_subscribe_alloca(&pPortSubs);
snd_seq_client_info_t *pClientInfo;
snd_seq_port_info_t *pPortInfo;
snd_seq_client_info_alloca(&pClientInfo);
snd_seq_port_info_alloca(&pPortInfo);
unsigned int uiPortFlags;
if (bReadable)
uiPortFlags = SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
else
uiPortFlags = SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
int iConnects = 0;
while (snd_seq_query_next_client(m_pAlsaSeq, pClientInfo) >= 0) {
int iAlsaClient = snd_seq_client_info_get_client(pClientInfo);
if (iAlsaClient > 0 && iAlsaClient != m_iAlsaClient) {
QString sClientName = snd_seq_client_info_get_name(pClientInfo);
snd_seq_port_info_set_client(pPortInfo, iAlsaClient);
snd_seq_port_info_set_port(pPortInfo, -1);
while (snd_seq_query_next_port(m_pAlsaSeq, pPortInfo) >= 0) {
unsigned int uiPortCapability
= snd_seq_port_info_get_capability(pPortInfo);
if (((uiPortCapability & uiPortFlags) == uiPortFlags) &&
((uiPortCapability & SND_SEQ_PORT_CAP_NO_EXPORT) == 0)) {
int iAlsaPort = snd_seq_port_info_get_port(pPortInfo);
QString sPortName = snd_seq_port_info_get_name(pPortInfo);
QStringListIterator iter(list);
while (iter.hasNext()) {
const QString& sItem = iter.next();
const QString& sClientItem
= sItem.section(c_pszItemSep, 0, 0);
const QString& sPortItem
= sItem.section(c_pszItemSep, 1, 1);
if (sClientName != sClientItem.section(':', 1, 1))
continue;
if (sPortName != sPortItem .section(':', 1, 1))
continue;
if (bReadable) {
seq_addr.client = iAlsaClient;
seq_addr.port = iAlsaPort;
snd_seq_port_subscribe_set_sender(pPortSubs, &seq_addr);
seq_addr.client = m_iAlsaClient;
seq_addr.port = m_iAlsaPort;
snd_seq_port_subscribe_set_dest(pPortSubs, &seq_addr);
} else {
seq_addr.client = m_iAlsaClient;
seq_addr.port = m_iAlsaPort;
snd_seq_port_subscribe_set_sender(pPortSubs, &seq_addr);
seq_addr.client = iAlsaClient;
seq_addr.port = iAlsaPort;
snd_seq_port_subscribe_set_dest(pPortSubs, &seq_addr);
}
if (snd_seq_subscribe_port(m_pAlsaSeq, pPortSubs) == 0)
iConnects++;
}
}
}
}
}
return (iConnects > 0);
}
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;
}
struct a2j_port *
a2j_port_create (alsa_midi_driver_t * driver, int dir, snd_seq_addr_t addr, const snd_seq_port_info_t * info)
{
struct a2j_port *port;
int err;
int client;
snd_seq_client_info_t * client_info_ptr;
int jack_caps;
struct a2j_stream * stream_ptr;
stream_ptr = &driver->stream[dir];
if ((err = snd_seq_client_info_malloc (&client_info_ptr)) != 0) {
a2j_error("Failed to allocate client info");
goto fail;
}
client = snd_seq_port_info_get_client (info);
err = snd_seq_get_any_client_info (driver->seq, client, client_info_ptr);
if (err != 0) {
a2j_error("Failed to get client info");
goto fail_free_client_info;
}
a2j_debug ("client name: '%s'", snd_seq_client_info_get_name(client_info_ptr));
a2j_debug ("port name: '%s'", snd_seq_port_info_get_name(info));
port = calloc (1, sizeof(struct a2j_port));
if (!port) {
goto fail_free_client_info;
}
port->driver_ptr = driver;
port->jack_port = JACK_INVALID_PORT;
port->remote = addr;
a2j_port_fill_name (port, dir, client_info_ptr, info, false);
/* Add port to list early, before registering to JACK, so map functionality is guaranteed to work during port registration */
list_add_tail (&port->siblings, &stream_ptr->list);
if (dir == A2J_PORT_CAPTURE) {
jack_caps = JackPortIsOutput;
} else {
jack_caps = JackPortIsInput;
}
/* mark anything that looks like a hardware port as physical&terminal */
if (snd_seq_port_info_get_type (info) & (SND_SEQ_PORT_TYPE_HARDWARE|SND_SEQ_PORT_TYPE_PORT|SND_SEQ_PORT_TYPE_SPECIFIC)) {
jack_caps |= JackPortIsPhysical|JackPortIsTerminal;
}
port->jack_port = jack_port_register (driver->jack_client, port->name, JACK_DEFAULT_MIDI_TYPE, jack_caps, 0);
if (port->jack_port == JACK_INVALID_PORT) {
a2j_error("jack_port_register() failed for '%s'", port->name);
goto fail_free_port;
}
if (dir == A2J_PORT_CAPTURE) {
err = a2j_alsa_connect_from (driver, port->remote.client, port->remote.port);
} else {
err = snd_seq_connect_to (driver->seq, driver->port_id, port->remote.client, port->remote.port);
}
if (err) {
a2j_debug("port skipped: %s", port->name);
goto fail_free_port;
}
port->inbound_events = jack_ringbuffer_create(MAX_EVENT_SIZE*16);
a2j_debug("port created: %s", port->name);
return port;
fail_free_port:
list_del (&port->siblings);
a2j_port_free (port);
fail_free_client_info:
snd_seq_client_info_free (client_info_ptr);
fail:
return NULL;
}
void
mastermidibus::port_start (int client, int port)
{
#ifdef SEQ64_HAVE_LIBASOUND
automutex locker(m_mutex);
snd_seq_client_info_t * cinfo; /* client info */
snd_seq_client_info_alloca(&cinfo);
snd_seq_get_any_client_info(m_alsa_seq, client, cinfo);
snd_seq_port_info_t * pinfo; /* port info */
snd_seq_port_info_alloca(&pinfo);
snd_seq_get_any_port_info(m_alsa_seq, client, port, pinfo);
int cap = snd_seq_port_info_get_capability(pinfo); /* get its capability */
if (ALSA_CLIENT_CHECK(pinfo))
{
if (CAP_FULL_WRITE(cap) && ALSA_CLIENT_CHECK(pinfo)) /* outputs */
{
bool replacement = false;
int bus_slot = m_num_out_buses;
for (int i = 0; i < m_num_out_buses; ++i)
{
if
(
m_buses_out[i]->get_client() == client &&
m_buses_out[i]->get_port() == port &&
! m_buses_out_active[i]
)
{
replacement = true;
bus_slot = i;
}
}
if (not_nullptr(m_buses_out[bus_slot]))
{
delete m_buses_out[bus_slot];
errprintf
(
"mastermidibus::port_start(): m_buses_out[%d] not null\n",
bus_slot
);
}
m_buses_out[bus_slot] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_out_buses,
m_queue
);
m_buses_out[bus_slot]->init_out();
m_buses_out_active[bus_slot] = true;
m_buses_out_init[bus_slot] = true;
if (! replacement)
++m_num_out_buses;
}
if (CAP_FULL_READ(cap) && ALSA_CLIENT_CHECK(pinfo)) /* inputs */
{
bool replacement = false;
int bus_slot = m_num_in_buses;
for (int i = 0; i < m_num_in_buses; ++i)
{
if
(
m_buses_in[i]->get_client() == client &&
m_buses_in[i]->get_port() == port && ! m_buses_in_active[i]
)
{
replacement = true;
bus_slot = i;
}
}
if (not_nullptr(m_buses_in[bus_slot]))
{
delete m_buses_in[bus_slot];
errprintf
(
"mmbus::port_start(): m_buses_in[%d] not null\n", bus_slot
);
}
m_buses_in[bus_slot] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_in_buses,
m_queue
);
m_buses_in_active[bus_slot] = true;
m_buses_in_init[bus_slot] = true;
if (! replacement)
m_num_in_buses++;
}
} /* end loop for clients */
/*
* Get the number of MIDI input poll file descriptors.
*/
m_num_poll_descriptors = snd_seq_poll_descriptors_count(m_alsa_seq, POLLIN);
m_poll_descriptors = new pollfd[m_num_poll_descriptors]; /* allocate info */
snd_seq_poll_descriptors /* get input descriptors */
(
m_alsa_seq, m_poll_descriptors, m_num_poll_descriptors, POLLIN
);
#endif // SEQ64_HAVE_LIBASOUND
}
void
mastermidibus::init (int ppqn)
{
#ifdef SEQ64_HAVE_LIBASOUND
snd_seq_client_info_t * cinfo; /* client info */
snd_seq_port_info_t * pinfo; /* port info */
snd_seq_client_info_alloca(&cinfo);
snd_seq_client_info_set_client(cinfo, -1);
if (rc().manual_alsa_ports())
{
/*
* Output busses
*/
int num_buses = SEQ64_ALSA_OUTPUT_BUSS_MAX;
for (int i = 0; i < num_buses; ++i)
{
if (not_nullptr(m_buses_out[i]))
{
delete m_buses_out[i];
errprintf("mmbus::init() manual: m_buses_out[%d] not null\n", i);
}
m_buses_out[i] = new midibus
(
snd_seq_client_id(m_alsa_seq), m_alsa_seq, i+1, m_queue
);
m_buses_out[i]->init_out_sub();
m_buses_out_active[i] = m_buses_out_init[i] = true;
}
m_num_out_buses = num_buses;
if (not_nullptr(m_buses_in[0]))
{
delete m_buses_in[0];
errprint("mmbus::init() manual: m_buses_[0] not null");
}
/*
* Input buss. Only the first element is set up. The rest are used
* only for non-manual ALSA ports in the else-class below.
*/
m_num_in_buses = 1;
m_buses_in[0] = new midibus
(
snd_seq_client_id(m_alsa_seq), m_alsa_seq, m_num_in_buses, m_queue
);
m_buses_in[0]->init_in_sub();
m_buses_in_active[0] = m_buses_in_init[0] = true;
}
else
{
/*
* While the next client for the sequencer is available, get the client
* from cinfo. Fill pinfo.
*/
while (snd_seq_query_next_client(m_alsa_seq, cinfo) >= 0)
{
int client = snd_seq_client_info_get_client(cinfo);
snd_seq_port_info_alloca(&pinfo); /* will fill pinfo */
snd_seq_port_info_set_client(pinfo, client);
snd_seq_port_info_set_port(pinfo, -1);
while (snd_seq_query_next_port(m_alsa_seq, pinfo) >= 0)
{
/*
* While the next port is available, get its capability.
*/
int cap = snd_seq_port_info_get_capability(pinfo);
if
(
ALSA_CLIENT_CHECK(pinfo) &&
snd_seq_port_info_get_client(pinfo) != SND_SEQ_CLIENT_SYSTEM
)
{
/*
* Output busses:
*
* Why are we doing the ALSA client check again here?
* Because it could be altered in the if-clause above.
*/
if (CAP_WRITE(cap) && ALSA_CLIENT_CHECK(pinfo))
{
if (not_nullptr(m_buses_out[m_num_out_buses]))
{
delete m_buses_out[m_num_out_buses];
errprintf
(
"mmbus::init(): m_buses_out[%d] not null\n",
m_num_out_buses
);
}
m_buses_out[m_num_out_buses] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo), m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_out_buses, m_queue
);
if (m_buses_out[m_num_out_buses]->init_out())
{
m_buses_out_active[m_num_out_buses] = true;
m_buses_out_init[m_num_out_buses] = true;
}
else
m_buses_out_init[m_num_out_buses] = true;
++m_num_out_buses;
}
/*
* Input busses
*/
if (CAP_READ(cap) && ALSA_CLIENT_CHECK(pinfo)) /* inputs */
{
if (not_nullptr(m_buses_in[m_num_in_buses]))
{
delete m_buses_in[m_num_in_buses];
errprintf
(
"mmbus::init(): m_buses_in[%d] not null\n",
m_num_in_buses
);
}
m_buses_in[m_num_in_buses] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo), m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_in_buses, m_queue
);
m_buses_in_active[m_num_in_buses] =
m_buses_in_init[m_num_in_buses] = true;
++m_num_in_buses;
}
}
}
} /* end loop for clients */
}
set_beats_per_minute(m_beats_per_minute);
set_ppqn(ppqn);
/*
* Get the number of MIDI input poll file descriptors. Allocate the
* poll-descriptors array. Then get the input poll-descriptors into the
* array
*/
m_num_poll_descriptors = snd_seq_poll_descriptors_count(m_alsa_seq, POLLIN);
m_poll_descriptors = new pollfd[m_num_poll_descriptors];
snd_seq_poll_descriptors
(
m_alsa_seq, m_poll_descriptors, m_num_poll_descriptors, POLLIN
);
set_sequence_input(false, nullptr);
/* Set the input and output buffer sizes */
snd_seq_set_output_buffer_size(m_alsa_seq, c_midibus_output_size);
snd_seq_set_input_buffer_size(m_alsa_seq, c_midibus_input_size);
m_bus_announce = new midibus
(
snd_seq_client_id(m_alsa_seq),
SND_SEQ_CLIENT_SYSTEM, SND_SEQ_PORT_SYSTEM_ANNOUNCE,
m_alsa_seq, "system", "announce", // was "annouce" ca 2016-04-03
0, m_queue
);
m_bus_announce->set_input(true);
for (int i = 0; i < m_num_out_buses; ++i)
set_clock(i, m_init_clock[i]);
for (int i = 0; i < m_num_in_buses; ++i)
set_input(i, m_init_input[i]);
#endif // SEQ64_HAVE_LIBASOUND
}
// Client:port refreshner.
int qjackctlAlsaClientList::updateClientPorts (void)
{
qjackctlMainForm *pMainForm = qjackctlMainForm::getInstance();
if (pMainForm == NULL)
return 0;
snd_seq_t *pAlsaSeq = pMainForm->alsaSeq();
if (pAlsaSeq == NULL)
return 0;
int iDirtyCount = 0;
markClientPorts(0);
#ifdef CONFIG_ALSA_SEQ
unsigned int uiAlsaFlags;
if (isReadable())
uiAlsaFlags = SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
else
uiAlsaFlags = SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
snd_seq_client_info_t *pClientInfo;
snd_seq_port_info_t *pPortInfo;
snd_seq_client_info_alloca(&pClientInfo);
snd_seq_port_info_alloca(&pPortInfo);
snd_seq_client_info_set_client(pClientInfo, -1);
while (snd_seq_query_next_client(pAlsaSeq, pClientInfo) >= 0) {
int iAlsaClient = snd_seq_client_info_get_client(pClientInfo);
if (iAlsaClient > 0) {
qjackctlAlsaClient *pClient = findClient(iAlsaClient);
snd_seq_port_info_set_client(pPortInfo, iAlsaClient);
snd_seq_port_info_set_port(pPortInfo, -1);
while (snd_seq_query_next_port(pAlsaSeq, pPortInfo) >= 0) {
unsigned int uiPortCapability
= snd_seq_port_info_get_capability(pPortInfo);
if (((uiPortCapability & uiAlsaFlags) == uiAlsaFlags) &&
((uiPortCapability & SND_SEQ_PORT_CAP_NO_EXPORT) == 0)) {
QString sClientName = QString::number(iAlsaClient) + ':';
sClientName += QString::fromUtf8(
snd_seq_client_info_get_name(pClientInfo));
qjackctlAlsaPort *pPort = 0;
int iAlsaPort = snd_seq_port_info_get_port(pPortInfo);
if (pClient == 0) {
pClient = new qjackctlAlsaClient(this,
sClientName, iAlsaClient);
iDirtyCount++;
} else {
pPort = pClient->findPort(iAlsaPort);
if (sClientName != pClient->clientName()) {
pClient->setClientName(sClientName);
iDirtyCount++;
}
}
if (pClient) {
QString sPortName = QString::number(iAlsaPort) + ':';
sPortName += QString::fromUtf8(
snd_seq_port_info_get_name(pPortInfo));
if (pPort == 0) {
pPort = new qjackctlAlsaPort(pClient,
sPortName, iAlsaPort);
iDirtyCount++;
} else if (sPortName != pPort->portName()) {
pPort->setPortName(sPortName);
iDirtyCount++;
}
}
if (pPort)
pPort->markClientPort(1);
}
}
}
}
#endif // CONFIG_ALSA_SEQ
iDirtyCount += cleanClientPorts(0);
return iDirtyCount;
}
const char *aseq_output_get_name(void *addr)
{
aseq_output_t *output = (aseq_output_t *) addr;
return snd_seq_port_info_get_name(output->info);
}
void
mastermidibus::init()
{
#ifdef HAVE_LIBASOUND
snd_seq_client_info_t * cinfo; /* client info */
snd_seq_port_info_t * pinfo; /* port info */
snd_seq_client_info_alloca(&cinfo);
snd_seq_client_info_set_client(cinfo, -1);
if (global_manual_alsa_ports)
{
int num_buses = 16;
for (int i = 0; i < num_buses; ++i)
{
m_buses_out[i] = new midibus
(
snd_seq_client_id(m_alsa_seq), m_alsa_seq, i+1, m_queue
);
m_buses_out[i]->init_out_sub();
m_buses_out_active[i] = true;
m_buses_out_init[i] = true;
}
m_num_out_buses = num_buses;
m_num_in_buses = 1; /* only one in, or 0? */
m_buses_in[0] = new midibus
(
snd_seq_client_id(m_alsa_seq), m_alsa_seq, m_num_in_buses, m_queue
);
m_buses_in[0]->init_in_sub();
m_buses_in_active[0] = true;
m_buses_in_init[0] = true;
}
else
{
/* While the next client for the sequencer is available */
while (snd_seq_query_next_client(m_alsa_seq, cinfo) >= 0)
{
int client = snd_seq_client_info_get_client(cinfo);
snd_seq_port_info_alloca(&pinfo); /* will fill pinfo */
snd_seq_port_info_set_client(pinfo, client);
snd_seq_port_info_set_port(pinfo, -1);
while (snd_seq_query_next_port(m_alsa_seq, pinfo) >= 0)
{
/* While the next port is available, get its capability */
int cap = snd_seq_port_info_get_capability(pinfo);
if
(
snd_seq_client_id(m_alsa_seq) !=
snd_seq_port_info_get_client(pinfo) &&
snd_seq_port_info_get_client(pinfo) != SND_SEQ_CLIENT_SYSTEM
)
{
if /* the outputs */
(
(cap & SND_SEQ_PORT_CAP_SUBS_WRITE) != 0 &&
snd_seq_client_id(m_alsa_seq) !=
snd_seq_port_info_get_client(pinfo)
)
{
m_buses_out[m_num_out_buses] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_out_buses,
m_queue
);
if (m_buses_out[m_num_out_buses]->init_out())
{
m_buses_out_active[m_num_out_buses] = true;
m_buses_out_init[m_num_out_buses] = true;
}
else
m_buses_out_init[m_num_out_buses] = true;
m_num_out_buses++;
}
if /* the inputs */
(
(cap & SND_SEQ_PORT_CAP_SUBS_READ) != 0 &&
snd_seq_client_id(m_alsa_seq) !=
snd_seq_port_info_get_client(pinfo)
)
{
m_buses_in[m_num_in_buses] = new midibus
(
snd_seq_client_id(m_alsa_seq),
snd_seq_port_info_get_client(pinfo),
snd_seq_port_info_get_port(pinfo),
m_alsa_seq,
snd_seq_client_info_get_name(cinfo),
snd_seq_port_info_get_name(pinfo),
m_num_in_buses,
m_queue
);
m_buses_in_active[m_num_in_buses] = true;
m_buses_in_init[m_num_in_buses] = true;
m_num_in_buses++;
}
}
}
} /* end loop for clients */
}
set_bpm(c_bpm);
set_ppqn(c_ppqn);
/*
* Get the number of MIDI input poll file descriptors.
*/
m_num_poll_descriptors = snd_seq_poll_descriptors_count(m_alsa_seq, POLLIN);
m_poll_descriptors = new pollfd[m_num_poll_descriptors]; /* allocate into */
snd_seq_poll_descriptors /* get input poll descriptors */
(
m_alsa_seq, m_poll_descriptors, m_num_poll_descriptors, POLLIN
);
set_sequence_input(false, nullptr);
/* Set the input and output buffer sizes */
snd_seq_set_output_buffer_size(m_alsa_seq, c_midibus_output_size);
snd_seq_set_input_buffer_size(m_alsa_seq, c_midibus_input_size);
m_bus_announce = new midibus
(
snd_seq_client_id(m_alsa_seq),
SND_SEQ_CLIENT_SYSTEM, SND_SEQ_PORT_SYSTEM_ANNOUNCE,
m_alsa_seq, "system", "annouce", 0, m_queue
);
m_bus_announce->set_input(true);
for (int i = 0; i < m_num_out_buses; i++)
set_clock(i, m_init_clock[i]);
for (int i = 0; i < m_num_in_buses; i++)
set_input(i, m_init_input[i]);
#endif // HAVE_LIBASOUND
}
