INT32 PORT_GetPortMixerDescription(INT32 mixerIndex, PortMixerDescription* description) {
snd_ctl_t* handle;
snd_ctl_card_info_t* card_info;
char devname[16];
int err;
char buffer[100];
TRACE0("> PORT_GetPortMixerDescription\n");
snd_ctl_card_info_malloc(&card_info);
sprintf(devname, ALSA_HARDWARE_CARD, (int) mixerIndex);
TRACE1("Opening alsa device \"%s\"...\n", devname);
err = snd_ctl_open(&handle, devname, 0);
if (err < 0) {
ERROR2("ERROR: snd_ctl_open, card=%d: %s\n", (int) mixerIndex, snd_strerror(err));
return FALSE;
}
err = snd_ctl_card_info(handle, card_info);
if (err < 0) {
ERROR2("ERROR: snd_ctl_card_info, card=%d: %s\n", (int) mixerIndex, snd_strerror(err));
}
strncpy(description->name, snd_ctl_card_info_get_id(card_info), PORT_STRING_LENGTH - 1);
sprintf(buffer, " [%s]", devname);
strncat(description->name, buffer, PORT_STRING_LENGTH - 1 - strlen(description->name));
strncpy(description->vendor, "ALSA (http://www.alsa-project.org)", PORT_STRING_LENGTH - 1);
strncpy(description->description, snd_ctl_card_info_get_name(card_info), PORT_STRING_LENGTH - 1);
strncat(description->description, ", ", PORT_STRING_LENGTH - 1 - strlen(description->description));
strncat(description->description, snd_ctl_card_info_get_mixername(card_info), PORT_STRING_LENGTH - 1 - strlen(description->description));
getALSAVersion(description->version, PORT_STRING_LENGTH - 1);
snd_ctl_close(handle);
snd_ctl_card_info_free(card_info);
TRACE0("< PORT_GetPortMixerDescription\n");
return TRUE;
}
static int cards(lua_State *lstate) {
snd_ctl_t *handle;
int ret, card, ord;
char buf[32];
snd_ctl_card_info_t *info;
snd_ctl_card_info_alloca(&info);
ord = 1;
card = -1;
lua_newtable(lstate);
while (1) {
if ((snd_card_next(&card) < 0) || (card < 0)) break;
sprintf(buf, "hw:%d", card);
if ((ret = snd_ctl_open(&handle, buf, 0)) < 0) {
logmsg("control open: %s\n", snd_strerror(ret));
continue;
}
if ((ret = snd_ctl_card_info(handle, info)) < 0) {
logmsg("control info: %s\n", snd_strerror(ret));
continue;
}
lua_pushinteger(lstate, ord++);
lua_newtable(lstate);
set_string(lstate, "dev", buf);
set_string(lstate, "name",
snd_ctl_card_info_get_name(info));
lua_settable(lstate, -3);
snd_ctl_close(handle);
//view_card(buf);
}
return 1;
}
/**
* \brief Convert card string to an integer value.
* \param string String containing card identifier
* \return zero if success, otherwise a negative error code
*
* The accepted format is an integer value in ASCII representation
* or the card identifier (the id parameter for sound-card drivers).
*/
int snd_card_get_index(const char *string)
{
int card;
snd_ctl_t *handle;
snd_ctl_card_info_t info;
if (!string || *string == '\0')
return -EINVAL;
if ((isdigit(*string) && *(string + 1) == 0) ||
(isdigit(*string) && isdigit(*(string + 1)) && *(string + 2) == 0)) {
if (sscanf(string, "%i", &card) != 1)
return -EINVAL;
if (card < 0 || card > 31)
return -EINVAL;
if (snd_card_load(card))
return card;
return -ENODEV;
}
for (card = 0; card < 32; card++) {
if (! snd_card_load(card))
continue;
if (snd_ctl_hw_open(&handle, NULL, card, 0) < 0)
continue;
if (snd_ctl_card_info(handle, &info) < 0) {
snd_ctl_close(handle);
continue;
}
snd_ctl_close(handle);
if (!strcmp((const char *)info.id, string))
return card;
}
return -ENODEV;
}
/**
* Partly based on get_cards function in alsamixer.
* This gets all alsa cards and fills the global
* GSList 'cards'.
* The list always starts with the 'default' card.
*/
static void
get_cards(void)
{
int err, num;
snd_ctl_card_info_t *info;
snd_ctl_t *ctl;
char buf[10];
struct acard *cur_card, *default_card;
if (cards != NULL)
g_slist_free_full(cards, card_free);
cards = NULL;
default_card = g_malloc(sizeof(struct acard));
default_card->name = g_strdup("(default)");
default_card->dev = g_strdup("default");
default_card->channels = get_channels("default");
cards = g_slist_append(cards, default_card);
// don't need to free this as it's alloca'd
snd_ctl_card_info_alloca(&info);
num = -1;
for (;;) {
err = snd_card_next(&num);
if (err < 0) {
report_error("Can't get sounds cards: %s", snd_strerror(err));
return;
}
if (num < 0)
break;
sprintf(buf, "hw:%d", num);
if (snd_ctl_open(&ctl, buf, 0) < 0)
continue;
err = snd_ctl_card_info(ctl, info);
snd_ctl_close(ctl);
if (err < 0)
continue;
cur_card = g_malloc(sizeof(struct acard));
cur_card->name = g_strdup(snd_ctl_card_info_get_name(info));
sprintf(buf, "hw:%d", num);
cur_card->dev = g_strdup(buf);
cur_card->channels = get_channels(buf);
cards = g_slist_append(cards, cur_card);
}
#ifdef DEBUG
GSList *tmp = cards;
if (tmp) {
printf("------ Card list ------\n");
while (tmp) {
struct acard *c = tmp->data;
printf("\t%s\t%s\t%s\n", c->dev, c->name,
c->channels ? "" : "No chann");
tmp = tmp->next;
}
printf("-----------------------\n");
}
#endif
}
static PyObject *
pyalsacontrol_cardinfo(struct pyalsacontrol *self, PyObject *args)
{
snd_ctl_card_info_t *info;
PyObject *d;
snd_ctl_card_info_alloca(&info);
int err = snd_ctl_card_info(self->handle, info);
if (err < 0) {
PyErr_Format(PyExc_IOError,
"Control card info error: %s", strerror(-err));
return NULL;
}
d = PyDict_New();
if (d) {
PyDict_SetItem(d, PyString_FromString("card"), PyInt_FromLong(snd_ctl_card_info_get_card(info)));
PyDict_SetItem(d, PyString_FromString("id"), PyString_FromString(snd_ctl_card_info_get_id(info)));
PyDict_SetItem(d, PyString_FromString("driver"), PyString_FromString(snd_ctl_card_info_get_driver(info)));
PyDict_SetItem(d, PyString_FromString("name"), PyString_FromString(snd_ctl_card_info_get_driver(info)));
PyDict_SetItem(d, PyString_FromString("longname"), PyString_FromString(snd_ctl_card_info_get_longname(info)));
PyDict_SetItem(d, PyString_FromString("mixername"), PyString_FromString(snd_ctl_card_info_get_mixername(info)));
PyDict_SetItem(d, PyString_FromString("components"), PyString_FromString(snd_ctl_card_info_get_components(info)));
}
return d;
}
int main(int argc, char **argv)
{
register int err;
int cardNum;
// Start with first card
cardNum = -1;
for (;;)
{
snd_ctl_t *cardHandle;
// Get next sound card's card number. When "cardNum" == -1, then ALSA
// fetches the first card
if ((err = snd_card_next(&cardNum)) < 0)
{
printf("Can't get the next card number: %s\n", snd_strerror(err));
break;
}
// No more cards? ALSA sets "cardNum" to -1 if so
if (cardNum < 0) break;
// Open this card's control interface. We specify only the card number -- not
// any device nor sub-device too
{
char str[64];
sprintf(str, "hw:%i", cardNum);
if ((err = snd_ctl_open(&cardHandle, str, 0)) < 0)
{
printf("Can't open card %i: %s\n", cardNum, snd_strerror(err));
continue;
}
}
{
snd_ctl_card_info_t *cardInfo;
// We need to get a snd_ctl_card_info_t. Just alloc it on the stack
snd_ctl_card_info_alloca(&cardInfo);
// Tell ALSA to fill in our snd_ctl_card_info_t with info about this card
if ((err = snd_ctl_card_info(cardHandle, cardInfo)) < 0)
printf("Can't get info for card %i: %s\n", cardNum, snd_strerror(err));
else
printf("Card %i = %s\n", cardNum, snd_ctl_card_info_get_name(cardInfo));
}
// Close the card's control interface after we're done with it
snd_ctl_close(cardHandle);
}
// ALSA allocates some mem to load its config file when we call some of the
// above functions. Now that we're done getting the info, let's tell ALSA
// to unload the info and free up that mem
snd_config_update_free_global();
}
static char *ListAvailableDevices( demux_t *p_demux, bool b_probe )
{
snd_ctl_card_info_t *p_info = NULL;
snd_ctl_card_info_alloca( &p_info );
snd_pcm_info_t *p_pcminfo = NULL;
snd_pcm_info_alloca( &p_pcminfo );
if( !b_probe )
msg_Dbg( p_demux, "Available alsa capture devices:" );
int i_card = -1;
while( !snd_card_next( &i_card ) && i_card >= 0 )
{
char psz_devname[10];
snprintf( psz_devname, 10, "hw:%d", i_card );
snd_ctl_t *p_ctl = NULL;
if( snd_ctl_open( &p_ctl, psz_devname, 0 ) < 0 ) continue;
snd_ctl_card_info( p_ctl, p_info );
if( !b_probe )
msg_Dbg( p_demux, " %s (%s)",
snd_ctl_card_info_get_id( p_info ),
snd_ctl_card_info_get_name( p_info ) );
int i_dev = -1;
while( !snd_ctl_pcm_next_device( p_ctl, &i_dev ) && i_dev >= 0 )
{
snd_pcm_info_set_device( p_pcminfo, i_dev );
snd_pcm_info_set_subdevice( p_pcminfo, 0 );
snd_pcm_info_set_stream( p_pcminfo, SND_PCM_STREAM_CAPTURE );
if( snd_ctl_pcm_info( p_ctl, p_pcminfo ) < 0 ) continue;
if( !b_probe )
msg_Dbg( p_demux, " hw:%d,%d : %s (%s)", i_card, i_dev,
snd_pcm_info_get_id( p_pcminfo ),
snd_pcm_info_get_name( p_pcminfo ) );
else
{
char *psz_device;
if( asprintf( &psz_device, "hw:%d,%d", i_card, i_dev ) > 0 )
{
if( ProbeAudioDevAlsa( p_demux, psz_device ) )
{
snd_ctl_close( p_ctl );
return psz_device;
}
else
free( psz_device );
}
}
}
snd_ctl_close( p_ctl );
}
return NULL;
}
bool MainWindowImpl::FindRadioshark(string& device)
{
int card = -1;
int dev = -1;
snd_ctl_t *handle = NULL;
snd_ctl_card_info_t *info = NULL;
snd_pcm_info_t *pcminfo = NULL;
snd_pcm_stream_t stream = SND_PCM_STREAM_CAPTURE;
char card_id[32];
char *name = NULL;
snd_ctl_card_info_alloca (&info);
snd_pcm_info_alloca (&pcminfo);
if (snd_card_next (&card) < 0 || card < 0)
{
return false;
}
while(card >= 0)
{
snprintf (card_id, 32, "hw:%d", card);
if (snd_ctl_open (&handle, card_id, 0) == 0)
{
snd_ctl_card_info (handle, info);
while (1)
{
snd_ctl_pcm_next_device (handle, &dev);
if (dev < 0){
break;
}
snd_pcm_info_set_device (pcminfo, dev);
snd_pcm_info_set_subdevice (pcminfo, 0);
snd_pcm_info_set_stream (pcminfo, stream);
if (snd_ctl_pcm_info (handle, pcminfo) >= 0)
{
snd_card_get_name (card, &name);
if(strncmp(name,"radioSHARK",32) == 0)
{void PokeScreensaver(void);
snd_ctl_close(handle);
free (name);
snprintf (card_id, 32, "hw:%d,%d", card,dev);
device = string(card_id);
return true;
}
free (name);
}
}
snd_ctl_close(handle);
}
snd_card_next (&card);
}
return false;//didn't find the proper Radioshark card.
}
std::vector<HwIDPair>
AlsaLayer::getAudioDeviceIndexMap(bool getCapture) const
{
snd_ctl_t* handle;
snd_ctl_card_info_t *info;
snd_pcm_info_t* pcminfo;
snd_ctl_card_info_alloca(&info);
snd_pcm_info_alloca(&pcminfo);
int numCard = -1;
std::vector<HwIDPair> audioDevice;
if (snd_card_next(&numCard) < 0 || numCard < 0)
return audioDevice;
do {
std::stringstream ss;
ss << numCard;
std::string name = "hw:" + ss.str();
if (snd_ctl_open(&handle, name.c_str(), 0) == 0) {
if (snd_ctl_card_info(handle, info) == 0) {
snd_pcm_info_set_device(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, getCapture ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK);
int err;
if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
WARN("Cannot get info for %s %s: %s", getCapture ?
"capture device" : "playback device", name.c_str(),
snd_strerror(err));
} else {
DEBUG("card %i : %s [%s]",
numCard,
snd_ctl_card_info_get_id(info),
snd_ctl_card_info_get_name(info));
std::string description = snd_ctl_card_info_get_name(info);
description.append(" - ");
description.append(snd_pcm_info_get_name(pcminfo));
// The number of the sound card is associated with a string description
audioDevice.push_back(HwIDPair(numCard, description));
}
}
snd_ctl_close(handle);
}
} while (snd_card_next(&numCard) >= 0 && numCard >= 0);
return audioDevice;
}
/**
* ags_devout_list_cards:
* @soundcard: the #AgsSoundcard
* @card_id: alsa identifier
* @card_name: card name
*
* List available soundcards.
*
* Since: 0.4
*/
void
ags_devout_list_cards(AgsSoundcard *soundcard,
GList **card_id, GList **card_name)
{
snd_ctl_t *card_handle;
snd_ctl_card_info_t *card_info;
char *name;
gchar *str;
int card_num;
int error;
*card_id = NULL;
*card_name = NULL;
card_num = -1;
while(TRUE){
error = snd_card_next(&card_num);
if(card_num < 0){
break;
}
if(error < 0){
continue;
}
str = g_strdup_printf("hw:%i\0", card_num);
error = snd_ctl_open(&card_handle, str, 0);
if(error < 0){
continue;
}
snd_ctl_card_info_alloca(&card_info);
error = snd_ctl_card_info(card_handle, card_info);
if(error < 0){
continue;
}
*card_id = g_list_prepend(*card_id, str);
*card_name = g_list_prepend(*card_name, g_strdup(snd_ctl_card_info_get_name(card_info)));
snd_ctl_close(card_handle);
}
snd_config_update_free_global();
*card_id = g_list_reverse(*card_id);
*card_name = g_list_reverse(*card_name);
}
/**
* \brief Obtain the card long name.
* \param card Card number
* \param name Result - card long name corresponding to card number
* \result zero if success, otherwise a negative error code
*/
int snd_card_get_longname(int card, char **name)
{
snd_ctl_t *handle;
snd_ctl_card_info_t info;
int err;
if (name == NULL)
return -EINVAL;
if ((err = snd_ctl_hw_open(&handle, NULL, card, 0)) < 0)
return err;
if ((err = snd_ctl_card_info(handle, &info)) < 0) {
snd_ctl_close(handle);
return err;
}
snd_ctl_close(handle);
*name = strdup((const char *)info.longname);
if (*name == NULL)
return -ENOMEM;
return 0;
}
const std::string AlsaWork::getCardName(int index)
{
const std::string card(AlsaDevice::formatCardName(index));
snd_ctl_t *ctl;
int err = snd_ctl_open(&ctl, card.c_str(), SND_CTL_NONBLOCK);
if (err < 0) {
checkError(err);
return std::string();
}
snd_ctl_card_info_t *cardInfo;
snd_ctl_card_info_alloca(&cardInfo);
err = snd_ctl_card_info(ctl, cardInfo);
if (err < 0) {
checkError(err);
return std::string();
}
const std::string cardName = snd_ctl_card_info_get_name(cardInfo);
checkError(snd_ctl_close(ctl));
return cardName;
}
static void
as_setup_card_combo (GtkWidget *combo , SoundParams *sparams)
{
int card;
int i ;
int err;
snd_ctl_t *handle;
snd_ctl_card_info_t *info;
char name[32];
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "- default");
snd_ctl_card_info_alloca(&info);
sparams->firstcard = -1;
card = -1;
for( i = 0 ; ; i++ ){
if (snd_card_next(&card) < 0 || card < 0) {
if ( i == 0 ) {
msg_error(_("no soundcards found..."));
}
return;
}
if ( sparams->firstcard < 0 ) {
sparams->firstcard = card;
}
sprintf(name, "hw:%d", card);
if ((err = snd_ctl_open(&handle, name, 0)) < 0) {
msg_error(_("control open (%i): %s"), card, snd_strerror(err));
continue;
}
if ((err = snd_ctl_card_info(handle, info)) < 0) {
msg_error(_("control hardware info (%i): %s"), card, snd_strerror(err));
snd_ctl_close(handle);
continue;
}
sprintf(name, "%d %s", card, snd_ctl_card_info_get_name(info) );
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), name );
snd_ctl_close(handle);
}
}
void list_cards(void)
{
snd_ctl_card_info_t *p_info = NULL;
snd_ctl_card_info_alloca(&p_info);
snd_pcm_info_t *p_pcminfo = NULL;
snd_pcm_info_alloca(&p_pcminfo);
printf("Availible alsa capture devices:\n");
int i_card = -1;
while (!snd_card_next(&i_card) && i_card >= 0)
{
char devname[10];
snprintf( devname, 10, "hw:%d", i_card );
snd_ctl_t *p_ctl = NULL;
if ( snd_ctl_open( &p_ctl, devname, 0 ) < 0) continue;
snd_ctl_card_info( p_ctl, p_info);
printf("\t%s (%s)\n", snd_ctl_card_info_get_id(p_info), snd_ctl_card_info_get_name(p_info));
int i_dev = -1;
while (!snd_ctl_pcm_next_device(p_ctl, &i_dev) && i_dev >= 0)
{
snd_pcm_info_set_device(p_pcminfo, i_dev);
snd_pcm_info_set_subdevice(p_pcminfo, 0);
snd_pcm_info_set_stream(p_pcminfo, SND_PCM_STREAM_CAPTURE);
if (snd_ctl_pcm_info(p_ctl, p_pcminfo) < 0) continue;
printf("\t\thw:%d,%d : %s (%s)\n", i_card, i_dev,
snd_pcm_info_get_id(p_pcminfo),
snd_pcm_info_get_name(p_pcminfo));
}
snd_ctl_close(p_ctl);
}
}
static int card_to_num(const char* device)
{
int err;
char* ctl_name;
snd_ctl_card_info_t *card_info;
snd_ctl_t* ctl_handle;
int i = -1;
snd_ctl_card_info_alloca (&card_info);
ctl_name = get_control_device_name(device);
if (ctl_name == NULL) {
jack_error("get_control_device_name() failed.");
goto fail;
}
if ((err = snd_ctl_open (&ctl_handle, ctl_name, 0)) < 0) {
jack_error ("control open \"%s\" (%s)", ctl_name,
snd_strerror(err));
goto free;
}
if ((err = snd_ctl_card_info(ctl_handle, card_info)) < 0) {
jack_error ("control hardware info \"%s\" (%s)",
device, snd_strerror (err));
goto close;
}
i = snd_ctl_card_info_get_card(card_info);
close:
snd_ctl_close(ctl_handle);
free:
free(ctl_name);
fail:
return i;
}
// for each ALSA device, call iterator. userData is passed to the iterator
// returns total number of iterations
int iteratePCMDevices(DeviceIteratorPtr iterator, void* userData) {
int count = 0;
int subdeviceCount;
int card, dev, subDev;
char devname[16];
int err;
snd_ctl_t *handle;
snd_pcm_t *pcm;
snd_pcm_info_t* pcminfo;
snd_ctl_card_info_t *cardinfo, *defcardinfo = NULL;
UINT32 deviceID;
int doContinue = TRUE;
snd_pcm_info_malloc(&pcminfo);
snd_ctl_card_info_malloc(&cardinfo);
// 1st try "default" device
err = snd_pcm_open(&pcm, ALSA_DEFAULT_DEVICE_NAME,
SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
if (err < 0) {
// try with the other direction
err = snd_pcm_open(&pcm, ALSA_DEFAULT_DEVICE_NAME,
SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
}
if (err < 0) {
ERROR1("ERROR: snd_pcm_open (\"default\"): %s\n", snd_strerror(err));
} else {
err = snd_pcm_info(pcm, pcminfo);
snd_pcm_close(pcm);
if (err < 0) {
ERROR1("ERROR: snd_pcm_info (\"default\"): %s\n",
snd_strerror(err));
} else {
// try to get card info
card = snd_pcm_info_get_card(pcminfo);
if (card >= 0) {
sprintf(devname, ALSA_HARDWARE_CARD, card);
if (snd_ctl_open(&handle, devname, SND_CTL_NONBLOCK) >= 0) {
if (snd_ctl_card_info(handle, cardinfo) >= 0) {
defcardinfo = cardinfo;
}
snd_ctl_close(handle);
}
}
// call callback function for the device
if (iterator != NULL) {
doContinue = (*iterator)(ALSA_DEFAULT_DEVICE_ID, pcminfo,
defcardinfo, userData);
}
count++;
}
}
// iterate cards
card = -1;
while (doContinue) {
if (snd_card_next(&card) < 0) {
break;
}
if (card < 0) {
break;
}
sprintf(devname, ALSA_HARDWARE_CARD, card);
TRACE1("Opening alsa device \"%s\"...\n", devname);
err = snd_ctl_open(&handle, devname, SND_CTL_NONBLOCK);
if (err < 0) {
ERROR2("ERROR: snd_ctl_open, card=%d: %s\n",
card, snd_strerror(err));
} else {
err = snd_ctl_card_info(handle, cardinfo);
if (err < 0) {
ERROR2("ERROR: snd_ctl_card_info, card=%d: %s\n",
card, snd_strerror(err));
} else {
dev = -1;
while (doContinue) {
if (snd_ctl_pcm_next_device(handle, &dev) < 0) {
ERROR0("snd_ctl_pcm_next_device\n");
}
if (dev < 0) {
break;
}
snd_pcm_info_set_device(pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, SND_PCM_STREAM_PLAYBACK);
err = snd_ctl_pcm_info(handle, pcminfo);
if (err == -ENOENT) {
// try with the other direction
snd_pcm_info_set_stream(pcminfo, SND_PCM_STREAM_CAPTURE);
err = snd_ctl_pcm_info(handle, pcminfo);
}
if (err < 0) {
if (err != -ENOENT) {
ERROR2("ERROR: snd_ctl_pcm_info, card=%d: %s",
card, snd_strerror(err));
}
} else {
subdeviceCount = needEnumerateSubdevices(ALSA_PCM) ?
snd_pcm_info_get_subdevices_count(pcminfo) : 1;
if (iterator!=NULL) {
for (subDev = 0; subDev < subdeviceCount; subDev++) {
deviceID = encodeDeviceID(card, dev, subDev);
doContinue = (*iterator)(deviceID, pcminfo,
cardinfo, userData);
count++;
if (!doContinue) {
break;
}
}
} else {
count += subdeviceCount;
}
}
} // of while(doContinue)
}
snd_ctl_close(handle);
}
}
snd_ctl_card_info_free(cardinfo);
snd_pcm_info_free(pcminfo);
return count;
}
static int findSoundCards(char **cardname)
{
int idx, dev, err;
snd_ctl_t *handle;
snd_hctl_t *hctlhandle;
snd_ctl_card_info_t *cardinfo;
snd_pcm_info_t *pcminfo;
char str[32];
snd_ctl_card_info_alloca(&cardinfo);
snd_pcm_info_alloca(&pcminfo);
snd_hctl_elem_t *elem;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
idx = -1;
while (1) {
if ((err = snd_card_next(&idx)) < 0) {
LOGE("Card next error: %s\n", snd_strerror(err));
break;
}
if (idx < 0)
break;
sprintf(str, "hw:CARD=%i", idx);
if ((err = snd_ctl_open(&handle, str, 0)) < 0) {
LOGE("Open error: %s\n", snd_strerror(err));
continue;
}
if ((err = snd_ctl_card_info(handle, cardinfo)) < 0) {
LOGE("HW info error: %s\n", snd_strerror(err));
continue;
}
LOGD("Soundcard #%i:\n", idx + 1);
LOGD(" card - %i\n", snd_ctl_card_info_get_card(cardinfo));
LOGD(" id - '%s'\n", snd_ctl_card_info_get_id(cardinfo));
LOGD(" driver - '%s'\n", snd_ctl_card_info_get_driver(cardinfo));
LOGD(" name - '%s'\n", snd_ctl_card_info_get_name(cardinfo));
LOGD(" longname - '%s'\n", snd_ctl_card_info_get_longname(cardinfo));
LOGD(" mixername - '%s'\n", snd_ctl_card_info_get_mixername(cardinfo));
LOGD(" components - '%s'\n", snd_ctl_card_info_get_components(cardinfo));
strcpy(cardname[idx], snd_ctl_card_info_get_name(cardinfo));
LOGD("\n\n-----get cart name and id: %s : %d",cardname[idx],idx);
snd_ctl_close(handle);
if ((err = snd_hctl_open(&hctlhandle, str, 0)) < 0) {
LOGE("Control %s open error: %s", str, snd_strerror(err));
return err;
}
if ((err = snd_hctl_load(hctlhandle)) < 0) {
LOGE("Control %s local error: %s\n", str, snd_strerror(err));
return err;
}
for (elem = snd_hctl_first_elem(hctlhandle); elem; elem = snd_hctl_elem_next(elem)) {
if ((err = snd_hctl_elem_info(elem, info)) < 0) {
LOGE("Control %s snd_hctl_elem_info error: %s\n", str, snd_strerror(err));
return err;
}
snd_hctl_elem_get_id(elem, id);
show_control_id(id);
}
snd_hctl_close(hctlhandle);
}
snd_config_update_free_global();
return 0;
}
/* First some utils, then the mixer implementation */
static gboolean
gst_alsa_mixer_open (GstAlsaMixer * mixer)
{
gint err;
snd_ctl_t *ctl;
snd_ctl_card_info_t *card_info;
g_return_val_if_fail (mixer->handle == NULL, FALSE);
/* open and initialize the mixer device */
err = snd_mixer_open (&mixer->handle, 0);
if (err < 0 || mixer->handle == NULL)
goto open_failed;
if ((err = snd_mixer_attach (mixer->handle, mixer->device)) < 0) {
GST_WARNING ("Cannot open mixer for sound device '%s': %s", mixer->device,
snd_strerror (err));
goto error;
}
if ((err = snd_mixer_selem_register (mixer->handle, NULL, NULL)) < 0) {
GST_WARNING ("Cannot register mixer elements: %s", snd_strerror (err));
goto error;
}
if ((err = snd_mixer_load (mixer->handle)) < 0) {
GST_WARNING ("Cannot load mixer settings: %s", snd_strerror (err));
goto error;
}
snd_mixer_set_callback_private (mixer->handle, mixer);
snd_mixer_set_callback (mixer->handle, gst_alsa_mixer_handle_callback);
/* now get the device name, any of this is not fatal */
g_free (mixer->cardname);
if ((err = snd_ctl_open (&ctl, mixer->device, 0)) < 0) {
GST_WARNING ("Cannot open CTL: %s", snd_strerror (err));
goto no_card_name;
}
snd_ctl_card_info_malloc (&card_info);
if ((err = snd_ctl_card_info (ctl, card_info)) < 0) {
GST_WARNING ("Cannot get card info: %s", snd_strerror (err));
snd_ctl_close (ctl);
goto no_card_name;
}
mixer->cardname = g_strdup (snd_ctl_card_info_get_name (card_info));
GST_DEBUG ("Card name = %s", GST_STR_NULL (mixer->cardname));
snd_ctl_card_info_free (card_info);
snd_ctl_close (ctl);
no_card_name:
if (mixer->cardname == NULL) {
mixer->cardname = g_strdup ("Unknown");
GST_DEBUG ("Cannot find card name");
}
GST_INFO ("Successfully opened mixer for device '%s'.", mixer->device);
return TRUE;
/* ERROR */
open_failed:
{
GST_WARNING ("Cannot open mixer: %s", snd_strerror (err));
mixer->handle = NULL;
return FALSE;
}
error:
{
snd_mixer_close (mixer->handle);
mixer->handle = NULL;
return FALSE;
}
}
static
jack_driver_param_constraint_desc_t *
enum_alsa_devices()
{
snd_ctl_t * handle;
snd_ctl_card_info_t * info;
snd_pcm_info_t * pcminfo_capture;
snd_pcm_info_t * pcminfo_playback;
int card_no = -1;
jack_driver_param_value_t card_id;
jack_driver_param_value_t device_id;
char description[64];
int device_no;
bool has_capture;
bool has_playback;
jack_driver_param_constraint_desc_t * constraint_ptr;
uint32_t array_size = 0;
snd_ctl_card_info_alloca(&info);
snd_pcm_info_alloca(&pcminfo_capture);
snd_pcm_info_alloca(&pcminfo_playback);
constraint_ptr = NULL;
while(snd_card_next(&card_no) >= 0 && card_no >= 0)
{
snprintf(card_id.str, sizeof(card_id.str), "hw:%d", card_no);
if (snd_ctl_open(&handle, card_id.str, 0) >= 0 &&
snd_ctl_card_info(handle, info) >= 0)
{
snprintf(card_id.str, sizeof(card_id.str), "hw:%s", snd_ctl_card_info_get_id(info));
if (!jack_constraint_add_enum(
&constraint_ptr,
&array_size,
&card_id,
snd_ctl_card_info_get_name(info)))
goto fail;
device_no = -1;
while (snd_ctl_pcm_next_device(handle, &device_no) >= 0 && device_no != -1)
{
snprintf(device_id.str, sizeof(device_id.str), "%s,%d", card_id.str, device_no);
snd_pcm_info_set_device(pcminfo_capture, device_no);
snd_pcm_info_set_subdevice(pcminfo_capture, 0);
snd_pcm_info_set_stream(pcminfo_capture, SND_PCM_STREAM_CAPTURE);
has_capture = snd_ctl_pcm_info(handle, pcminfo_capture) >= 0;
snd_pcm_info_set_device(pcminfo_playback, device_no);
snd_pcm_info_set_subdevice(pcminfo_playback, 0);
snd_pcm_info_set_stream(pcminfo_playback, SND_PCM_STREAM_PLAYBACK);
has_playback = snd_ctl_pcm_info(handle, pcminfo_playback) >= 0;
if (has_capture && has_playback)
{
snprintf(description, sizeof(description),"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture));
}
else if (has_capture)
{
snprintf(description, sizeof(description),"%s (capture)", snd_pcm_info_get_name(pcminfo_capture));
}
else if (has_playback)
{
snprintf(description, sizeof(description),"%s (playback)", snd_pcm_info_get_name(pcminfo_playback));
}
else
{
continue;
}
if (!jack_constraint_add_enum(
&constraint_ptr,
&array_size,
&device_id,
description))
goto fail;
}
snd_ctl_close(handle);
}
}
return constraint_ptr;
fail:
jack_constraint_free(constraint_ptr);
return NULL;
}
void bg_alsa_create_card_parameters(bg_parameter_info_t * ret,
int record)
{
snd_ctl_card_info_t *info;
snd_ctl_t *handle;
snd_pcm_info_t *pcminfo;
snd_pcm_stream_t stream;
int err;
int card, dev;
stream = record ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK;
ret->name = gavl_strdup("card");
ret->long_name = gavl_strdup(TRS("Card"));
ret->type = BG_PARAMETER_STRINGLIST;
snd_ctl_card_info_malloc(&info);
card = -1;
if (snd_card_next(&card) < 0 || card < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "No soundcards found");
return;
}
/* Default is always supported */
ret->val_default.val_str = gavl_strdup("default");
append_card(ret, gavl_strdup("default"),
gavl_strdup(TRS("Default")));
while (card >= 0)
{
char name[32];
sprintf(name, "hw:%d", card);
if ((err = snd_ctl_open(&handle, name, 0)) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN,
"control open failed (%i): %s",
card, snd_strerror(err));
goto next_card;
}
if ((err = snd_ctl_card_info(handle, info)) < 0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN,
"control hardware info failed (%i): %s",
card, snd_strerror(err));
snd_ctl_close(handle);
goto next_card;
}
dev = -1;
while (1)
{
char * name, *label;
snd_pcm_info_malloc(&pcminfo);
if (snd_ctl_pcm_next_device(handle, &dev)<0)
{
bg_log(BG_LOG_ERROR, LOG_DOMAIN, "snd_ctl_pcm_next_device failed");
snd_pcm_info_free(pcminfo);
break;
}
if (dev < 0)
{
snd_pcm_info_free(pcminfo);
break;
}
snd_pcm_info_set_device(pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, stream);
if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0)
{
if (err != -ENOENT)
bg_log(BG_LOG_ERROR, LOG_DOMAIN,
"control digital audio info failed (%i): %s",
card, snd_strerror(err));
snd_pcm_info_free(pcminfo);
continue;
}
name = bg_sprintf("hw:%d,%d", card, dev);
label = gavl_strdup(snd_pcm_info_get_name(pcminfo));
append_card(ret, name, label);
snd_pcm_info_free(pcminfo);
}
snd_ctl_close(handle);
next_card:
if (snd_card_next(&card) < 0)
break;
}
snd_ctl_card_info_free(info);
}
static int find_hwdep_device(int *cardP, int *devP)
{
snd_ctl_t *ctl_handle;
snd_ctl_card_info_t *card_info;
snd_hwdep_info_t *hwdep_info;
int card;
int dev;
int err;
char card_id[32];
ctl_handle = NULL;
snd_ctl_card_info_alloca(&card_info);
snd_hwdep_info_alloca(&hwdep_info);
for (card = 0; card < 7; card++) {
*cardP = card;
if (ctl_handle) {
snd_ctl_close(ctl_handle);
ctl_handle = NULL;
}
// Get control handle for selected card
sprintf(card_id, "hw:%i", card);
if ((err = snd_ctl_open(&ctl_handle, card_id, 0)) < 0) {
fprintf(stderr, "control open (%s): %s", card_id, snd_strerror(err));
return -1;
}
// Read control hardware info from card
if ((err = snd_ctl_card_info(ctl_handle, card_info)) < 0) {
fprintf(stderr, "control hardware info (%s): %s", card_id, snd_strerror(err));
continue;
}
//if (strcmp(snd_ctl_card_info_get_driver(card_info),"BT SCO (d)"))
// continue;
dev = -1;
err = 1;
while (1) {
int if_type;
if (snd_ctl_hwdep_next_device(ctl_handle, &dev) < 0)
fprintf(stderr, "hwdep next device (%s): %s", card_id, snd_strerror(err));
if (dev < 0)
break;
snd_hwdep_info_set_device(hwdep_info, dev);
if (snd_ctl_hwdep_info(ctl_handle, hwdep_info) < 0) {
if (err != -ENOENT)
fprintf(stderr, "control hwdep info (%s): %s", card_id, snd_strerror(err));
continue;
}
if_type = snd_hwdep_info_get_iface(hwdep_info);
if (if_type == SNDRV_HWDEP_IFACE_BT_SCO || if_type==12) {
snd_ctl_close(ctl_handle);
*devP = dev;
return 0;
}
}
}
if (ctl_handle)
snd_ctl_close(ctl_handle);
return -1;
}
static GList *
gst_alsa_get_device_list (snd_pcm_stream_t stream)
{
snd_ctl_t *handle;
int card, dev;
snd_ctl_card_info_t *info;
snd_pcm_info_t *pcminfo;
gboolean mixer = (stream == -1);
GList *list = NULL;
if (stream == -1)
stream = 0;
snd_ctl_card_info_malloc (&info);
snd_pcm_info_malloc (&pcminfo);
card = -1;
if (snd_card_next (&card) < 0 || card < 0) {
/* no soundcard found */
GST_WARNING ("No soundcard found");
goto beach;
}
while (card >= 0) {
gchar name[32];
g_snprintf (name, sizeof (name), "hw:%d", card);
if (snd_ctl_open (&handle, name, 0) < 0) {
goto next_card;
}
if (snd_ctl_card_info (handle, info) < 0) {
snd_ctl_close (handle);
goto next_card;
}
if (mixer) {
list = g_list_append (list, g_strdup (name));
} else {
dev = -1;
while (1) {
gchar *gst_device;
snd_ctl_pcm_next_device (handle, &dev);
if (dev < 0)
break;
snd_pcm_info_set_device (pcminfo, dev);
snd_pcm_info_set_subdevice (pcminfo, 0);
snd_pcm_info_set_stream (pcminfo, stream);
if (snd_ctl_pcm_info (handle, pcminfo) < 0) {
continue;
}
gst_device = g_strdup_printf ("hw:%d,%d", card, dev);
list = g_list_append (list, gst_device);
}
}
snd_ctl_close (handle);
next_card:
if (snd_card_next (&card) < 0) {
break;
}
}
beach:
snd_ctl_card_info_free (info);
snd_pcm_info_free (pcminfo);
return list;
}
static int get_controls(int cardno, snd_config_t *top)
{
snd_ctl_t *handle;
snd_ctl_card_info_t *info;
snd_config_t *state, *card, *control;
snd_ctl_elem_list_t *list;
unsigned int idx;
int err;
char name[32];
unsigned int count;
const char *id;
snd_ctl_card_info_alloca(&info);
snd_ctl_elem_list_alloca(&list);
sprintf(name, "hw:%d", cardno);
err = snd_ctl_open(&handle, name, SND_CTL_READONLY);
if (err < 0) {
error("snd_ctl_open error: %s", snd_strerror(err));
return err;
}
err = snd_ctl_card_info(handle, info);
if (err < 0) {
error("snd_ctl_card_info error: %s", snd_strerror(err));
goto _close;
}
id = snd_ctl_card_info_get_id(info);
err = snd_config_search(top, "state", &state);
if (err == 0 &&
snd_config_get_type(state) != SND_CONFIG_TYPE_COMPOUND) {
error("config state node is not a compound");
err = -EINVAL;
goto _close;
}
if (err < 0) {
err = snd_config_compound_add(top, "state", 1, &state);
if (err < 0) {
error("snd_config_compound_add: %s", snd_strerror(err));
goto _close;
}
}
err = snd_config_search(state, id, &card);
if (err == 0 &&
snd_config_get_type(card) != SND_CONFIG_TYPE_COMPOUND) {
error("config state.%s node is not a compound", id);
err = -EINVAL;
goto _close;
}
if (err < 0) {
err = snd_config_compound_add(state, id, 0, &card);
if (err < 0) {
error("snd_config_compound_add: %s", snd_strerror(err));
goto _close;
}
}
err = snd_config_search(card, "control", &control);
if (err == 0) {
err = snd_config_delete(control);
if (err < 0) {
error("snd_config_delete: %s", snd_strerror(err));
goto _close;
}
}
err = snd_ctl_elem_list(handle, list);
if (err < 0) {
error("Cannot determine controls: %s", snd_strerror(err));
goto _close;
}
count = snd_ctl_elem_list_get_count(list);
err = snd_config_compound_add(card, "control", count > 0, &control);
if (err < 0) {
error("snd_config_compound_add: %s", snd_strerror(err));
goto _close;
}
if (count == 0) {
err = 0;
goto _close;
}
snd_ctl_elem_list_set_offset(list, 0);
if (snd_ctl_elem_list_alloc_space(list, count) < 0) {
error("No enough memory...");
goto _close;
}
if ((err = snd_ctl_elem_list(handle, list)) < 0) {
error("Cannot determine controls (2): %s", snd_strerror(err));
goto _free;
}
for (idx = 0; idx < count; ++idx) {
snd_ctl_elem_id_t *id;
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_list_get_id(list, idx, id);
err = get_control(handle, id, control);
if (err < 0)
goto _free;
}
err = 0;
_free:
snd_ctl_elem_list_free_space(list);
_close:
snd_ctl_close(handle);
return err;
}
// for each ALSA device, call iterator. userData is passed to the iterator
// returns total number of iterations
static int iterateRawmidiDevices(snd_rawmidi_stream_t direction,
DeviceIteratorPtr iterator,
void* userData) {
int count = 0;
int subdeviceCount;
int card, dev, subDev;
char devname[16];
int err;
snd_ctl_t *handle;
snd_rawmidi_t *rawmidi;
snd_rawmidi_info_t *rawmidi_info;
snd_ctl_card_info_t *card_info, *defcardinfo = NULL;
UINT32 deviceID;
int doContinue = TRUE;
snd_rawmidi_info_malloc(&rawmidi_info);
snd_ctl_card_info_malloc(&card_info);
// 1st try "default" device
if (direction == SND_RAWMIDI_STREAM_INPUT) {
err = snd_rawmidi_open(&rawmidi, NULL, ALSA_DEFAULT_DEVICE_NAME,
SND_RAWMIDI_NONBLOCK);
} else if (direction == SND_RAWMIDI_STREAM_OUTPUT) {
err = snd_rawmidi_open(NULL, &rawmidi, ALSA_DEFAULT_DEVICE_NAME,
SND_RAWMIDI_NONBLOCK);
} else {
ERROR0("ERROR: iterateRawmidiDevices(): direction is neither"
" SND_RAWMIDI_STREAM_INPUT nor SND_RAWMIDI_STREAM_OUTPUT\n");
err = MIDI_INVALID_ARGUMENT;
}
if (err < 0) {
ERROR1("ERROR: snd_rawmidi_open (\"default\"): %s\n",
snd_strerror(err));
} else {
err = snd_rawmidi_info(rawmidi, rawmidi_info);
snd_rawmidi_close(rawmidi);
if (err < 0) {
ERROR1("ERROR: snd_rawmidi_info (\"default\"): %s\n",
snd_strerror(err));
} else {
// try to get card info
card = snd_rawmidi_info_get_card(rawmidi_info);
if (card >= 0) {
sprintf(devname, ALSA_HARDWARE_CARD, card);
if (snd_ctl_open(&handle, devname, SND_CTL_NONBLOCK) >= 0) {
if (snd_ctl_card_info(handle, card_info) >= 0) {
defcardinfo = card_info;
}
snd_ctl_close(handle);
}
}
// call calback function for the device
if (iterator != NULL) {
doContinue = (*iterator)(ALSA_DEFAULT_DEVICE_ID, rawmidi_info,
defcardinfo, userData);
}
count++;
}
}
// iterate cards
card = -1;
TRACE0("testing for cards...\n");
if (snd_card_next(&card) >= 0) {
TRACE1("Found card %d\n", card);
while (doContinue && (card >= 0)) {
sprintf(devname, ALSA_HARDWARE_CARD, card);
TRACE1("Opening control for alsa rawmidi device \"%s\"...\n", devname);
err = snd_ctl_open(&handle, devname, SND_CTL_NONBLOCK);
if (err < 0) {
ERROR2("ERROR: snd_ctl_open, card=%d: %s\n", card, snd_strerror(err));
} else {
TRACE0("snd_ctl_open() SUCCESS\n");
err = snd_ctl_card_info(handle, card_info);
if (err < 0) {
ERROR2("ERROR: snd_ctl_card_info, card=%d: %s\n", card, snd_strerror(err));
} else {
TRACE0("snd_ctl_card_info() SUCCESS\n");
dev = -1;
while (doContinue) {
if (snd_ctl_rawmidi_next_device(handle, &dev) < 0) {
ERROR0("snd_ctl_rawmidi_next_device\n");
}
TRACE0("snd_ctl_rawmidi_next_device() SUCCESS\n");
if (dev < 0) {
break;
}
snd_rawmidi_info_set_device(rawmidi_info, dev);
snd_rawmidi_info_set_subdevice(rawmidi_info, 0);
snd_rawmidi_info_set_stream(rawmidi_info, direction);
err = snd_ctl_rawmidi_info(handle, rawmidi_info);
TRACE0("after snd_ctl_rawmidi_info()\n");
if (err < 0) {
if (err != -ENOENT) {
ERROR2("ERROR: snd_ctl_rawmidi_info, card=%d: %s", card, snd_strerror(err));
}
} else {
TRACE0("snd_ctl_rawmidi_info() SUCCESS\n");
subdeviceCount = needEnumerateSubdevices(ALSA_RAWMIDI)
? snd_rawmidi_info_get_subdevices_count(rawmidi_info)
: 1;
if (iterator!=NULL) {
for (subDev = 0; subDev < subdeviceCount; subDev++) {
TRACE3(" Iterating %d,%d,%d\n", card, dev, subDev);
deviceID = encodeDeviceID(card, dev, subDev);
doContinue = (*iterator)(deviceID, rawmidi_info,
card_info, userData);
count++;
TRACE0("returned from iterator\n");
if (!doContinue) {
break;
}
}
} else {
count += subdeviceCount;
}
}
} // of while(doContinue)
}
snd_ctl_close(handle);
}
if (snd_card_next(&card) < 0) {
break;
}
}
} else {
ERROR0("No cards found!\n");
}
snd_ctl_card_info_free(card_info);
snd_rawmidi_info_free(rawmidi_info);
return count;
}
static
jack_driver_param_constraint_desc_t *
enum_alsa_devices()
{
snd_ctl_t * handle;
snd_ctl_card_info_t * info;
snd_pcm_info_t * pcminfo_capture;
snd_pcm_info_t * pcminfo_playback;
int card_no = -1;
char card_id[JACK_DRIVER_PARAM_STRING_MAX + 1];
char device_id[JACK_DRIVER_PARAM_STRING_MAX + 1];
char description[64];
int device_no;
bool has_capture;
bool has_playback;
jack_driver_param_constraint_desc_t * constraint_ptr;
uint32_t array_size = 0;
snd_ctl_card_info_alloca(&info);
snd_pcm_info_alloca(&pcminfo_capture);
snd_pcm_info_alloca(&pcminfo_playback);
constraint_ptr = NULL;
while(snd_card_next(&card_no) >= 0 && card_no >= 0)
{
snprintf(card_id, sizeof(card_id), "hw:%d", card_no);
if (snd_ctl_open(&handle, card_id, 0) >= 0 &&
snd_ctl_card_info(handle, info) >= 0)
{
fill_device(&constraint_ptr, &array_size, card_id, snd_ctl_card_info_get_name(info));
device_no = -1;
while (snd_ctl_pcm_next_device(handle, &device_no) >= 0 && device_no != -1)
{
snprintf(device_id, sizeof(device_id), "%s,%d", card_id, device_no);
snd_pcm_info_set_device(pcminfo_capture, device_no);
snd_pcm_info_set_subdevice(pcminfo_capture, 0);
snd_pcm_info_set_stream(pcminfo_capture, SND_PCM_STREAM_CAPTURE);
has_capture = snd_ctl_pcm_info(handle, pcminfo_capture) >= 0;
snd_pcm_info_set_device(pcminfo_playback, device_no);
snd_pcm_info_set_subdevice(pcminfo_playback, 0);
snd_pcm_info_set_stream(pcminfo_playback, SND_PCM_STREAM_PLAYBACK);
has_playback = snd_ctl_pcm_info(handle, pcminfo_playback) >= 0;
if (has_capture && has_playback)
{
snprintf(description, sizeof(description),"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture));
}
else if (has_capture)
{
snprintf(description, sizeof(description),"%s (capture)", snd_pcm_info_get_name(pcminfo_capture));
}
else if (has_playback)
{
snprintf(description, sizeof(description),"%s (playback)", snd_pcm_info_get_name(pcminfo_playback));
}
else
{
continue;
}
fill_device(&constraint_ptr, &array_size, device_id, description);
}
snd_ctl_close(handle);
}
}
return constraint_ptr;
}
/* returns the card name when the device number is unknown or -1 */
static gchar *
gst_alsa_find_device_name_no_handle (GstObject * obj, const gchar * devcard,
gint device_num, snd_pcm_stream_t stream)
{
snd_ctl_card_info_t *info = NULL;
snd_ctl_t *ctl = NULL;
gchar *ret = NULL;
gint dev = -1;
GST_LOG_OBJECT (obj, "[%s] device=%d", devcard, device_num);
if (snd_ctl_open (&ctl, devcard, 0) < 0)
return NULL;
snd_ctl_card_info_malloc (&info);
if (snd_ctl_card_info (ctl, info) < 0)
goto done;
if (device_num != -1) {
while (snd_ctl_pcm_next_device (ctl, &dev) == 0 && dev >= 0) {
if (dev == device_num) {
snd_pcm_info_t *pcminfo;
snd_pcm_info_malloc (&pcminfo);
snd_pcm_info_set_device (pcminfo, dev);
snd_pcm_info_set_subdevice (pcminfo, 0);
snd_pcm_info_set_stream (pcminfo, stream);
if (snd_ctl_pcm_info (ctl, pcminfo) < 0) {
snd_pcm_info_free (pcminfo);
break;
}
ret = (gchar *) snd_pcm_info_get_name (pcminfo);
if (ret) {
ret = g_strdup (ret);
GST_LOG_OBJECT (obj, "name from pcminfo: %s", ret);
}
snd_pcm_info_free (pcminfo);
if (ret)
break;
}
}
}
if (ret == NULL) {
char *name = NULL;
gint card;
GST_LOG_OBJECT (obj, "trying card name");
card = snd_ctl_card_info_get_card (info);
snd_card_get_name (card, &name);
ret = g_strdup (name);
free (name);
}
done:
snd_ctl_card_info_free (info);
snd_ctl_close (ctl);
return ret;
}
void
ManglerAlsa::getDeviceList(std::vector<ManglerAudioDevice*>& inputDevices, std::vector<ManglerAudioDevice*>& outputDevices) {/*{{{*/
snd_pcm_stream_t stream[2] = { SND_PCM_STREAM_PLAYBACK, SND_PCM_STREAM_CAPTURE };
int ctr;
for (ctr = 0; ctr < 2; ctr++) { // the rest is just copypasta, with bad code from alsa
snd_ctl_t *handle;
int card, err, dev, idx_p = 0, idx_c = 0;
snd_ctl_card_info_t *info;
snd_pcm_info_t *pcminfo;
card = -1;
snd_ctl_card_info_alloca(&info);
snd_pcm_info_alloca(&pcminfo);
if (snd_card_next(&card) < 0 || card < 0) {
fputs("alsa: no sound cards found!\n", stderr);
return;
}
while (card >= 0) {
char hw[256] = "";
snprintf(hw, 255, "hw:%i", card);
if ((err = snd_ctl_open(&handle, hw, 0)) < 0) {
fprintf(stderr, "alsa: control open (%i): %s\n", card, snd_strerror(err));
if (snd_card_next(&card) < 0) {
fprintf(stderr, "alsa: snd_ctl_open: snd_card_next\n");
break;
}
continue;
}
if ((err = snd_ctl_card_info(handle, info)) < 0) {
fprintf(stderr, "alsa: control hardware info (%i): %s\n", card, snd_strerror(err));
snd_ctl_close(handle);
if (snd_card_next(&card) < 0) {
fprintf(stderr, "alsa: snd_ctl_card_info: snd_card_next\n");
break;
}
continue;
}
dev = -1;
for (;;) {
if (snd_ctl_pcm_next_device(handle, &dev) < 0) {
fprintf(stderr, "alsa: snd_ctl_pcm_next_device\n");
}
if (dev < 0) {
break;
}
snd_pcm_info_set_device(pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, stream[ctr]);
if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
if (err != -ENOENT) {
fprintf(stderr, "alsa: control digital audio info (%i): %s\n", card, snd_strerror(err));
}
continue;
}
char name[256] = "", desc[512] = "";
snprintf(name, 255, "hw:%i,%i", card, dev);
snprintf(desc, 511, "%s: %s (%s)",
snd_ctl_card_info_get_name(info),
snd_pcm_info_get_name(pcminfo),
name
);
switch (stream[ctr]) {
case SND_PCM_STREAM_PLAYBACK:
outputDevices.push_back(
new ManglerAudioDevice(
idx_p++,
name,
desc)
);
break;
case SND_PCM_STREAM_CAPTURE:
inputDevices.push_back(
new ManglerAudioDevice(
idx_c++,
name,
desc)
);
break;
}
}
snd_ctl_close(handle);
if (snd_card_next(&card) < 0) {
fprintf(stderr, "alsa: snd_card_next\n");
break;
}
}
}
}/*}}}*/
static void probe_devices(snd_pcm_stream_t stream, vector_DevMap *DeviceList)
{
const char *main_prefix = "plughw:";
snd_ctl_t *handle;
snd_ctl_card_info_t *info;
snd_pcm_info_t *pcminfo;
int card, err, dev;
DevMap entry;
clear_devlist(DeviceList);
snd_ctl_card_info_malloc(&info);
snd_pcm_info_malloc(&pcminfo);
AL_STRING_INIT(entry.name);
AL_STRING_INIT(entry.device_name);
al_string_copy_cstr(&entry.name, alsaDevice);
al_string_copy_cstr(&entry.device_name, GetConfigValue(NULL, "alsa", (stream==SND_PCM_STREAM_PLAYBACK) ?
"device" : "capture", "default"));
VECTOR_PUSH_BACK(*DeviceList, entry);
card = -1;
if((err=snd_card_next(&card)) < 0)
ERR("Failed to find a card: %s\n", snd_strerror(err));
ConfigValueStr(NULL, "alsa", prefix_name(stream), &main_prefix);
while(card >= 0)
{
const char *card_prefix = main_prefix;
const char *cardname, *cardid;
char name[256];
snprintf(name, sizeof(name), "hw:%d", card);
if((err = snd_ctl_open(&handle, name, 0)) < 0)
{
ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
goto next_card;
}
if((err = snd_ctl_card_info(handle, info)) < 0)
{
ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
snd_ctl_close(handle);
goto next_card;
}
cardname = snd_ctl_card_info_get_name(info);
cardid = snd_ctl_card_info_get_id(info);
snprintf(name, sizeof(name), "%s-%s", prefix_name(stream), cardid);
ConfigValueStr(NULL, "alsa", name, &card_prefix);
dev = -1;
while(1)
{
const char *device_prefix = card_prefix;
const char *devname;
char device[128];
if(snd_ctl_pcm_next_device(handle, &dev) < 0)
ERR("snd_ctl_pcm_next_device failed\n");
if(dev < 0)
break;
snd_pcm_info_set_device(pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, stream);
if((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
if(err != -ENOENT)
ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
continue;
}
devname = snd_pcm_info_get_name(pcminfo);
snprintf(name, sizeof(name), "%s-%s-%d", prefix_name(stream), cardid, dev);
ConfigValueStr(NULL, "alsa", name, &device_prefix);
snprintf(name, sizeof(name), "%s, %s (CARD=%s,DEV=%d)",
cardname, devname, cardid, dev);
snprintf(device, sizeof(device), "%sCARD=%s,DEV=%d",
device_prefix, cardid, dev);
TRACE("Got device \"%s\", \"%s\"\n", name, device);
AL_STRING_INIT(entry.name);
AL_STRING_INIT(entry.device_name);
al_string_copy_cstr(&entry.name, name);
al_string_copy_cstr(&entry.device_name, device);
VECTOR_PUSH_BACK(*DeviceList, entry);
}
snd_ctl_close(handle);
next_card:
if(snd_card_next(&card) < 0) {
ERR("snd_card_next failed\n");
break;
}
}
snd_pcm_info_free(pcminfo);
snd_ctl_card_info_free(info);
}
static DevMap *probe_devices(snd_pcm_stream_t stream, ALuint *count)
{
const char *main_prefix = "plughw:";
snd_ctl_t *handle;
int card, err, dev, idx;
snd_ctl_card_info_t *info;
snd_pcm_info_t *pcminfo;
DevMap *DevList;
snd_ctl_card_info_malloc(&info);
snd_pcm_info_malloc(&pcminfo);
DevList = malloc(sizeof(DevMap) * 1);
DevList[0].name = strdup(alsaDevice);
DevList[0].device = strdup(GetConfigValue("alsa", (stream==SND_PCM_STREAM_PLAYBACK) ?
"device" : "capture", "default"));
idx = 1;
card = -1;
if((err=snd_card_next(&card)) < 0)
ERR("Failed to find a card: %s\n", snd_strerror(err));
ConfigValueStr("alsa", prefix_name(stream), &main_prefix);
while(card >= 0)
{
const char *card_prefix = main_prefix;
const char *cardname, *cardid;
char name[256];
snprintf(name, sizeof(name), "hw:%d", card);
if((err = snd_ctl_open(&handle, name, 0)) < 0)
{
ERR("control open (hw:%d): %s\n", card, snd_strerror(err));
goto next_card;
}
if((err = snd_ctl_card_info(handle, info)) < 0)
{
ERR("control hardware info (hw:%d): %s\n", card, snd_strerror(err));
snd_ctl_close(handle);
goto next_card;
}
cardname = snd_ctl_card_info_get_name(info);
cardid = snd_ctl_card_info_get_id(info);
snprintf(name, sizeof(name), "%s-%s", prefix_name(stream), cardid);
ConfigValueStr("alsa", name, &card_prefix);
dev = -1;
while(1)
{
const char *devname;
void *temp;
if(snd_ctl_pcm_next_device(handle, &dev) < 0)
ERR("snd_ctl_pcm_next_device failed\n");
if(dev < 0)
break;
snd_pcm_info_set_device(pcminfo, dev);
snd_pcm_info_set_subdevice(pcminfo, 0);
snd_pcm_info_set_stream(pcminfo, stream);
if((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
if(err != -ENOENT)
ERR("control digital audio info (hw:%d): %s\n", card, snd_strerror(err));
continue;
}
temp = realloc(DevList, sizeof(DevMap) * (idx+1));
if(temp)
{
const char *device_prefix = card_prefix;
char device[128];
DevList = temp;
devname = snd_pcm_info_get_name(pcminfo);
snprintf(name, sizeof(name), "%s-%s-%d", prefix_name(stream), cardid, dev);
ConfigValueStr("alsa", name, &device_prefix);
snprintf(name, sizeof(name), "%s, %s (CARD=%s,DEV=%d)",
cardname, devname, cardid, dev);
snprintf(device, sizeof(device), "%sCARD=%s,DEV=%d",
device_prefix, cardid, dev);
TRACE("Got device \"%s\", \"%s\"\n", name, device);
DevList[idx].name = strdup(name);
DevList[idx].device = strdup(device);
idx++;
}
}
snd_ctl_close(handle);
next_card:
if(snd_card_next(&card) < 0) {
ERR("snd_card_next failed\n");
break;
}
}
snd_pcm_info_free(pcminfo);
snd_ctl_card_info_free(info);
*count = idx;
return DevList;
}
bool LapsusAlsaMixer::init()
{
int err;
snd_ctl_t *ctl_handle;
snd_ctl_card_info_t *hw_info;
snd_ctl_card_info_alloca(&hw_info);
if ((err = snd_ctl_open (&ctl_handle, "default", 0)) < 0)
return false;
if ((err = snd_ctl_card_info (ctl_handle, hw_info)) < 0)
return false;
snd_ctl_close (ctl_handle);
if ((err = snd_mixer_open (&_handle, 0)) < 0)
return false;
if ((err = snd_mixer_attach (_handle, "default")) < 0)
return false;
if ((err = snd_mixer_selem_register (_handle, 0, 0)) < 0)
return false;
if ((err = snd_mixer_load (_handle)) < 0)
return false;
// printf("Card name: '%s'\n", snd_ctl_card_info_get_name(hw_info));
// printf("Device name: '%s'\n", snd_ctl_card_info_get_mixername(hw_info));
snd_mixer_elem_t *elem;
snd_mixer_selem_id_t *tmp_sid = 0;
for (elem = snd_mixer_first_elem(_handle); elem; elem = snd_mixer_elem_next(elem))
{
if (snd_mixer_selem_is_active(elem))
{
if (!tmp_sid) tmp_sid = (snd_mixer_selem_id_t*) malloc(snd_mixer_selem_id_sizeof());
snd_mixer_selem_get_id(elem, tmp_sid);
const char *name = snd_mixer_selem_id_get_name( tmp_sid );
if (!strcasecmp(name, "Headphone"))
{
if (sids[ID_HP]) delete sids[ID_HP];
sids[ID_HP] = new SIDInfo(_handle, tmp_sid);
tmp_sid = 0;
}
else if (!strcasecmp(name, "Front"))
{
if (sids[ID_F]) delete sids[ID_F];
sids[ID_F] = new SIDInfo(_handle, tmp_sid);
tmp_sid = 0;
}
else if (!strcasecmp(name, "Master"))
{
if (sids[ID_M]) delete sids[ID_M];
sids[ID_M] = new SIDInfo(_handle, tmp_sid);
tmp_sid = 0;
}
}
}
if (tmp_sid) free(tmp_sid);
bool foundAny = false;
for (int i = 0; i < ID_LAST; ++i)
{
if (sids[i])
{
if (sids[i]->hasMute)
{
foundAny = true;
}
if (sids[i]->hasVolume)
{
foundAny = true;
long range = sids[i]->max - sids[i]->min;
if (range > _globalMax)
_globalMax = range;
}
}
}
if (_globalMax > INT_MAX)
_globalMax = INT_MAX;
if (!foundAny) return false;
for (int i = 0; i < ID_LAST; ++i)
{
if (sids[i]) sids[i]->setGlobalMax(_globalMax);
}
if ((_count = snd_mixer_poll_descriptors_count(_handle)) < 0)
return false;
_fds = (struct pollfd*) calloc(_count, sizeof(struct pollfd));
if (!_fds) return false;
if ((err = snd_mixer_poll_descriptors(_handle, _fds, _count)) < 0)
return false;
if (err != _count) return 0;
_sns = new QSocketNotifier*[_count];
for ( int i = 0; i < _count; ++i )
{
_sns[i] = new QSocketNotifier(_fds[i].fd, QSocketNotifier::Read);
connect(_sns[i], SIGNAL(activated(int)), this, SLOT(alsaEvent()));
}
// To read our current parameters. Signals will be emited, but those signals
// are not yet connected to anything - this method is called from constructor
// only.
getVolume();
mixerIsMuted();
return true;
}
