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 }