static int initialize_mixer_device(struct audio_info_struct *ai, char *error)
{
int sts;
snd_mixer_t *mixer;
char *mixerdev = "default";
const char *elemnam;
snd_mixer_elem_t *mixerelem;
sts = snd_mixer_open(&mixer, 0);
if (sts) {
if (error) {
sprintf(error, "snd_mixer_open failed; %d\n", sts);
}
return 1;
}
if (mixer) {
sts = snd_mixer_attach(mixer, mixerdev);
if (sts) {
if (error) {
sprintf(error, "snd_mixer_attach: failed; %d\n", sts);
}
return 1;
}
sts = snd_mixer_selem_register(mixer, NULL, NULL);
if (sts) {
if (error) {
sprintf(error, "snd_mixer_selem_register: failed; %d\n", sts);
}
return 1;
}
sts = snd_mixer_load(mixer);
if (sts) {
if (error) {
sprintf(error, "snd_mixer_selem_register: failed; %d\n", sts);
}
return 1;
}
mixerelem = snd_mixer_first_elem(mixer);
snd_mixer_set_callback(mixer, mixer_callback_func);
while (mixerelem) {
elemnam = snd_mixer_selem_get_name(mixerelem);
if (strcasecmp(elemnam, "Master") == 0) {
ai->vh = mixerelem;
return 0;
}
mixerelem = snd_mixer_elem_next(mixerelem);
}
}
return 1;
}
static void
open_mixer (MokoAlsaVolumeControl *self)
{
MokoAlsaVolumeControlPrivate *priv = ALSA_VOLUME_CONTROL_PRIVATE (self);
if (snd_mixer_open (&priv->mixer_handle, 0) != 0) {
g_warning ("Failed to get mixer handle");
priv->mixer_handle = NULL;
return;
}
snd_mixer_set_callback (priv->mixer_handle, mixer_event_cb);
snd_mixer_set_callback_private (priv->mixer_handle, self);
g_debug ("Opened mixer");
}
void create_mixer_object(struct snd_mixer_selem_regopt *selem_regopt)
{
int err;
err = snd_mixer_open(&mixer, 0);
if (err < 0)
fatal_alsa_error(_("cannot open mixer"), err);
mixer_device_name = cstrdup(selem_regopt->device);
err = snd_mixer_selem_register(mixer, selem_regopt, NULL);
if (err < 0)
fatal_alsa_error(_("cannot open mixer"), err);
snd_mixer_set_callback(mixer, mixer_callback);
err = snd_mixer_load(mixer);
if (err < 0)
fatal_alsa_error(_("cannot load mixer controls"), err);
err = snd_mixer_selem_id_malloc(¤t_selem_id);
if (err < 0)
fatal_error("out of memory");
}
/* 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 int alsa_mixer_init(alsa_mixer_t *mixer, char *card) {
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t *elem;
snd_mixer_selem_id_alloca(&sid);
int err;
if ((err = snd_mixer_open(&mixer->handle, 0)) < 0) {
DEBUG("Mixer %s open error: %s", card, snd_strerror(err));
mixer->handle = NULL;
return err;
}
if ((err = snd_mixer_attach(mixer->handle, card)) < 0) {
DEBUG("Mixer %s local error: %s\n", card, snd_strerror(err));
snd_mixer_close(mixer->handle);
mixer->handle = NULL;
return err;
}
if ((err = snd_mixer_selem_register(mixer->handle, NULL, NULL)) < 0) {
DEBUG("Mixer register error: %s", snd_strerror(err));
snd_mixer_close(mixer->handle);
return err;
}
snd_mixer_set_callback(mixer->handle, on_mixer_event);
err = snd_mixer_load(mixer->handle);
if (err < 0) {
DEBUG("Mixer %s load error: %s", card, snd_strerror(err));
snd_mixer_close(mixer->handle);
return err;
}
for (elem = snd_mixer_first_elem(mixer->handle); elem; elem = snd_mixer_elem_next(elem)) {
const char *name = NULL;
snd_mixer_selem_get_id(elem, sid);
if (!snd_mixer_selem_is_active(elem))
continue;
name = snd_mixer_selem_id_get_name(sid);
if(snd_mixer_selem_has_playback_volume(elem)) {
if(strcmp(name, "Master") == 0)
mixer->master = elem;
else if(strcmp(name, "PCM") == 0)
mixer->pcm = elem;
} else if(snd_mixer_selem_has_capture_volume(elem) || snd_mixer_selem_has_capture_switch(elem)) {
DEBUG("capture elem name = %s\n", name);
/**make sure have one capture source if capture is available*/
if(NULL == mixer->mic) {
mixer->mic = elem;
}
/**if have Microphone, replace it*/
if(strcmp(name, "Microphone") == 0)
mixer->mic = elem;
if(strcmp(name, "Capture") == 0)
mixer->mic = elem;
}
}
DEBUG("master = %x, pcm = %x, microphone = %x\n", mixer->master, mixer->pcm, mixer->mic);
return 0;
}
