void
gam_app_update_visibility (GamApp *gam_app, GtkWidget *widget,
snd_mixer_elem_t *elem, gboolean saved_state){
g_return_if_fail (GAM_IS_APP (gam_app));
GamMixer *gam_mixer=gam_app_get_current_mixer(gam_app);
int is_playback= snd_mixer_selem_has_playback_volume(elem)
|| snd_mixer_selem_has_playback_switch(elem)
|| (snd_mixer_selem_is_enumerated(elem)
&& snd_mixer_selem_is_enum_playback(elem));
int is_capture = snd_mixer_selem_has_capture_volume(elem)
|| snd_mixer_selem_has_capture_switch(elem)
|| (snd_mixer_selem_is_enumerated(elem)
&& snd_mixer_selem_is_enum_capture(elem));
//If nothing showed set show all
if(!(gam_mixer_get_show_playback_elements(gam_mixer)||gam_mixer_get_show_capture_elements(gam_mixer)))
gam_mixer_set_capture_playback(gam_app_get_current_mixer(gam_app), TRUE, TRUE);
if(saved_state
&& ((is_playback && gam_mixer_get_show_playback_elements(gam_mixer))
|| (is_capture && gam_mixer_get_show_capture_elements(gam_mixer))))
gtk_widget_show(widget);
else
gtk_widget_hide(widget);
}
MixerElem *lamixer_volelem_new(snd_mixer_elem_t *elem)
{
MixerElem *mixer_elem;
guint voltype=0, elemidx=0, mono;
long minrange=0,maxrange=0,rangevalue_left=0,rangevalue_right=0;
const char* selem_name = NULL;
char elem_name[64];
mixer_elem = g_malloc(sizeof(MixerElem));
mixer_elem->elem = elem;
mixer_elem->playback = NULL;
mixer_elem->capture = NULL;
mixer_elem->pswitch = NULL;
mixer_elem->cswitch = NULL;
mixer_elem->penum = NULL;
mixer_elem->cenum = NULL;
elemidx = snd_mixer_selem_get_index(elem);
selem_name = snd_mixer_selem_id_get_name(sid);
strcpy(elem_name, selem_name);
if(elemidx > 0) {
sprintf(elem_name,"%s %i",elem_name, elemidx);
}
if (!snd_mixer_selem_is_enumerated(elem)) {
if (snd_mixer_selem_has_playback_volume(elem)) {
voltype = 1;
snd_mixer_selem_get_playback_volume_range (elem, &minrange, &maxrange);
mono = snd_mixer_selem_is_playback_mono(elem);
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
if(!mono)
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
mixer_elem->playback = lamixer_volbox_new(elem_name,mono, \
(snd_mixer_selem_has_playback_switch(elem) || snd_mixer_selem_has_playback_switch_joined(elem)), minrange, maxrange, elem, voltype);
}
else if (snd_mixer_selem_has_playback_switch(elem)) {
voltype = 1;
mixer_elem->pswitch = lamixer_switchbox_add(elem_name, elem, voltype);
}
if (snd_mixer_selem_has_capture_volume(elem)) {
voltype = 2;
snd_mixer_selem_get_capture_volume_range (elem, &minrange, &maxrange);
mono = snd_mixer_selem_is_capture_mono(elem);
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
if(!mono)
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
mixer_elem->capture = lamixer_volbox_new(elem_name,mono, \
(snd_mixer_selem_has_capture_switch(elem) || snd_mixer_selem_has_capture_switch_joined(elem)), minrange, maxrange, elem, voltype);
}
else if (snd_mixer_selem_has_capture_switch(elem)) {
voltype = 2;
mixer_elem->cswitch = lamixer_switchbox_add(elem_name, elem, voltype);
}
}
else {
if (snd_mixer_selem_is_enum_playback(elem)) {
voltype = 1;
mixer_elem->penum = lamixer_enumbox_add(elem_name, elem, voltype);
}
else if (snd_mixer_selem_is_enum_capture(elem)) {
voltype = 2;
mixer_elem->cenum = lamixer_enumbox_add(elem_name, elem, voltype);
}
}
return mixer_elem;
}
static void
gst_alsa_mixer_ensure_track_list (GstAlsaMixer * mixer)
{
gint i, count;
snd_mixer_elem_t *element, *master;
GList *item;
g_return_if_fail (mixer->handle != NULL);
if (mixer->tracklist)
return;
g_static_rec_mutex_lock (mixer->rec_mutex);
master = gst_alsa_mixer_find_master_mixer (mixer, mixer->handle);
count = snd_mixer_get_count (mixer->handle);
element = snd_mixer_first_elem (mixer->handle);
/* build track list
*
* Some ALSA tracks may have playback and capture capabilities.
* Here we model them as two separate GStreamer tracks.
*/
for (i = 0; i < count; i++) {
GstMixerTrack *play_track = NULL;
GstMixerTrack *cap_track = NULL;
const gchar *name;
GList *item;
gint samename = 0;
name = snd_mixer_selem_get_name (element);
/* prevent dup names */
for (item = mixer->tracklist; item != NULL; item = item->next) {
snd_mixer_elem_t *temp;
if (GST_IS_ALSA_MIXER_OPTIONS (item->data))
temp = GST_ALSA_MIXER_OPTIONS (item->data)->element;
else
temp = GST_ALSA_MIXER_TRACK (item->data)->element;
if (strcmp (name, snd_mixer_selem_get_name (temp)) == 0)
samename++;
}
GST_LOG ("[%s] probing element #%u, mixer->dir=%u", name, i, mixer->dir);
if (mixer->dir & GST_ALSA_MIXER_PLAYBACK) {
gboolean has_playback_switch, has_playback_volume;
has_playback_switch = snd_mixer_selem_has_playback_switch (element);
has_playback_volume = snd_mixer_selem_has_playback_volume (element);
GST_LOG ("[%s] PLAYBACK: has_playback_volume=%d, has_playback_switch=%d"
"%s", name, has_playback_volume, has_playback_switch,
(element == master) ? " MASTER" : "");
if (has_playback_volume) {
gint flags = GST_MIXER_TRACK_OUTPUT;
if (element == master)
flags |= GST_MIXER_TRACK_MASTER;
play_track = gst_alsa_mixer_track_new (element, samename, i,
flags, FALSE, NULL, FALSE);
} else if (has_playback_switch) {
/* simple mute switch */
play_track = gst_alsa_mixer_track_new (element, samename, i,
GST_MIXER_TRACK_OUTPUT, TRUE, NULL, FALSE);
}
if (snd_mixer_selem_is_enumerated (element)) {
GstMixerOptions *opts = gst_alsa_mixer_options_new (element, i);
GST_LOG ("[%s] is enumerated (%d)", name, i);
mixer->tracklist = g_list_append (mixer->tracklist, opts);
}
}
if (mixer->dir & GST_ALSA_MIXER_CAPTURE) {
gboolean has_capture_switch, has_common_switch;
gboolean has_capture_volume, has_common_volume;
has_capture_switch = snd_mixer_selem_has_capture_switch (element);
has_common_switch = snd_mixer_selem_has_common_switch (element);
has_capture_volume = snd_mixer_selem_has_capture_volume (element);
has_common_volume = snd_mixer_selem_has_common_volume (element);
GST_LOG ("[%s] CAPTURE: has_capture_volume=%d, has_common_volume=%d, "
"has_capture_switch=%d, has_common_switch=%d, play_track=%p", name,
has_capture_volume, has_common_volume, has_capture_switch,
has_common_switch, play_track);
if (has_capture_volume && !(play_track && has_common_volume)) {
cap_track = gst_alsa_mixer_track_new (element, samename, i,
GST_MIXER_TRACK_INPUT, FALSE, NULL, play_track != NULL);
} else if (has_capture_switch && !(play_track && has_common_switch)) {
cap_track = gst_alsa_mixer_track_new (element, samename, i,
GST_MIXER_TRACK_INPUT, TRUE, NULL, play_track != NULL);
}
}
if (play_track && cap_track) {
GST_ALSA_MIXER_TRACK (play_track)->shared_mute =
GST_ALSA_MIXER_TRACK (cap_track);
GST_ALSA_MIXER_TRACK (cap_track)->shared_mute =
GST_ALSA_MIXER_TRACK (play_track);
}
if (play_track)
mixer->tracklist = g_list_append (mixer->tracklist, play_track);
if (cap_track)
mixer->tracklist = g_list_append (mixer->tracklist, cap_track);
element = snd_mixer_elem_next (element);
}
for (item = mixer->tracklist; item != NULL; item = item->next) {
snd_mixer_elem_t *temp;
if (GST_IS_ALSA_MIXER_OPTIONS (item->data))
temp = GST_ALSA_MIXER_OPTIONS (item->data)->element;
else
temp = GST_ALSA_MIXER_TRACK (item->data)->element;
snd_mixer_elem_set_callback (temp, gst_alsa_mixer_elem_handle_callback);
snd_mixer_elem_set_callback_private (temp, mixer);
}
g_static_rec_mutex_unlock (mixer->rec_mutex);
}
