void lamixer_mixerelem_show(MixerElem *mixer_elem)
{
if(mixer_elem->playback != NULL)
lamixer_volbox_show(mixer_elem->playback, mixer_elem->elem, mixerbox);
if(mixer_elem->capture != NULL)
lamixer_volbox_show(mixer_elem->capture, mixer_elem->elem, capturebox);
if(mixer_elem->pswitch != NULL)
lamixer_switchbox_show(mixer_elem->pswitch, switchvbox);
if(mixer_elem->cswitch != NULL)
lamixer_switchbox_show(mixer_elem->cswitch, switchcapturevbox);
if(mixer_elem->penum != NULL)
lamixer_enumbox_show(mixer_elem->penum, enumvbox);
if(mixer_elem->cenum != NULL)
lamixer_enumbox_show(mixer_elem->cenum, enumcapturevbox);
if(mixer_elem->playback != NULL || mixer_elem->capture != NULL) {
snd_mixer_elem_set_callback(mixer_elem->elem, lamixer_volbox_change);
snd_mixer_elem_set_callback_private(mixer_elem->elem, mixer_elem);
}
}
void lamixer_enumbox_show(EnumBox *enumbox, GtkWidget *enumvbox)
{
guint evalue;
snd_mixer_selem_get_enum_item(enumbox->volelem, SND_MIXER_SCHN_FRONT_LEFT, &evalue);
gtk_combo_box_set_active(GTK_COMBO_BOX(enumbox->enumswitch), evalue);
gtk_box_pack_start(GTK_BOX(enumvbox), enumbox->enumhbox, TRUE, FALSE, 0);
g_signal_connect(G_OBJECT(enumbox->enumswitch), "changed", G_CALLBACK(lamixer_enumbox_changed), enumbox->volelem);
snd_mixer_elem_set_callback(enumbox->volelem, lamixer_enumbox_change);
snd_mixer_elem_set_callback_private(enumbox->volelem, enumbox);
}
void lamixer_switchbox_show(SwitchBox *swbox, GtkWidget *swvbox)
{
int swstat;
snd_mixer_selem_get_playback_switch (swbox->volelem, SND_MIXER_SCHN_FRONT_LEFT, &swstat);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(swbox->volswitch), swstat);
swbox->hswsignalid = g_signal_connect(G_OBJECT(swbox->volswitch), "toggled", G_CALLBACK(lamixer_volswitch_changed), swbox->volelem);
gtk_box_pack_start(GTK_BOX(swvbox), swbox->volswitch, TRUE, TRUE, 0);
snd_mixer_elem_set_callback(swbox->volelem, lamixer_switchbox_change);
snd_mixer_elem_set_callback_private(swbox->volelem, swbox);
}
static void
attach_mixer (MokoAlsaVolumeControl *self)
{
MokoAlsaVolumeControlPrivate *priv = ALSA_VOLUME_CONTROL_PRIVATE (self);
g_debug ("Trying to attach... %p, %s, %p", priv->mixer_handle,
priv->device, priv->element);
open_mixer (self);
if (priv->mixer_handle && priv->device && priv->element &&
(snd_mixer_attach (priv->mixer_handle, priv->device) == 0) &&
(snd_mixer_selem_register (priv->mixer_handle, NULL, NULL) == 0) &&
(snd_mixer_load (priv->mixer_handle) == 0)) {
priv->mixer_elem = snd_mixer_find_selem (
priv->mixer_handle, priv->element);
if (!priv->mixer_elem) {
g_warning ("Unable to find mixer element");
snd_mixer_detach (priv->mixer_handle, priv->device);
close_mixer (self);
} else {
g_debug ("Attached to mixer");
if (snd_mixer_selem_has_playback_volume (
priv->mixer_elem)) {
priv->control_type = PLAYBACK;
snd_mixer_selem_get_playback_volume_range (
priv->mixer_elem,
&priv->min, &priv->max);
} else if (snd_mixer_selem_has_capture_volume (
priv->mixer_elem)) {
priv->control_type = CAPTURE;
snd_mixer_selem_get_capture_volume_range (
priv->mixer_elem,
&priv->min, &priv->max);
} else
priv->control_type = CONTROL;
snd_mixer_elem_set_callback (
priv->mixer_elem, mixer_elem_event_cb);
snd_mixer_elem_set_callback_private (
priv->mixer_elem, self);
start_polling (self);
update_volume (self);
}
} else {
close_mixer (self);
}
}
static void am_create_capture_mixer(GtkWidget *hbox, alsa_mixer_t *mixer) {
GtkWidget *switch_btn = NULL, *vbox = NULL, *adv_btn = NULL, *img = NULL;
GtkObject *adj = NULL;
char *icon = NULL;
gdouble dval = 0;
long cmin, cmax, Rvol, Lvol;
gboolean muted = TRUE, need_reset;
char path[1024] = {0};
if(mixer->mic)
muted = alsa_mixer_is_muted(mixer->mic, &need_reset);
mixer->mic_muted = muted;
g_snprintf(path, 1024, DVM_CONFIG_PATH"/%s", g_capture_iconset[muted ? 3: 0]);
switch_btn = gtk_event_box_new();
img = gtk_image_new_from_file(path);
gtk_container_add(GTK_CONTAINER(switch_btn), img);
g_object_set_data(G_OBJECT(switch_btn), "iconset", g_capture_iconset);
g_signal_connect(switch_btn, "enter-notify-event", G_CALLBACK(on_enter_switch_widget), mixer);
g_signal_connect(switch_btn, "leave-notify-event", G_CALLBACK(on_leave_switch_widget), mixer);
g_signal_connect(switch_btn, "button-press-event", G_CALLBACK(on_press_switch_widget), mixer);
g_signal_connect(switch_btn, "button-release-event", G_CALLBACK(on_release_switch_widget), mixer);
if(mixer->mic) {
snd_mixer_selem_get_capture_volume_range(mixer->mic, &cmin, &cmax);
snd_mixer_selem_get_capture_volume(mixer->mic, 0, &Rvol);
snd_mixer_selem_get_capture_volume(mixer->mic, 1, &Lvol);
dval = ((gdouble)(Rvol + Lvol)*50)/(cmax-cmin);
adj = gtk_adjustment_new(dval, 0, 100, 1, 6, 0);
snd_mixer_elem_set_callback_private(mixer->mic, adj);
} else {
adj = gtk_adjustment_new(0, 0, 100, 1, 6, 0);
}
g_object_set_data(G_OBJECT(adj), "image-obj", img);
g_object_set_data(G_OBJECT(adj), "mixer-obj", mixer);
DEBUG("capture set object data, img = %x, mixer = %x\n", img, mixer);
//g_signal_connect(adj, "value-changed", G_CALLBACK(on_capture_mixer_changed), mixer);
adv_btn = gtk_button_new_with_label("Advanced");
vbox = am_create_mixer_ui(switch_btn, "Microphone", GTK_ADJUSTMENT(adj), adv_btn);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
}
static gint
_j4status_alsa_section_mixer_callback(snd_mixer_t *mixer, guint mask, snd_mixer_elem_t *elem)
{
J4statusAlsaSection *section = snd_mixer_get_callback_private(mixer);
if ( mask & SND_CTL_EVENT_MASK_ADD )
{
if ( ( snd_mixer_selem_get_index(elem) == 0 )
&& ( g_strcmp0(snd_mixer_selem_get_name(elem), "Master") == 0 )
&& snd_mixer_selem_has_playback_channel(elem, SND_MIXER_SCHN_FRONT_LEFT)
&& ( snd_mixer_elem_get_callback_private(elem) == NULL )
)
{
snd_mixer_elem_set_callback(elem, _j4status_alsa_section_elem_callback);
snd_mixer_elem_set_callback_private(elem, section);
}
}
return 0;
}
static void am_create_playback_mixer(GtkWidget *hbox, alsa_mixer_t *mixer) {
GtkWidget *switch_btn = NULL, *vbox = NULL, *img = NULL, *vvbox = NULL;
GtkObject *adj = NULL;
char *icon = NULL;
gdouble dval = 0;
long Rvol, Lvol, pmin, pmax;
gboolean muted = TRUE, need_reset;
char path[1024] = {0};
if(mixer->master)
muted = alsa_mixer_is_muted(mixer->master, &need_reset);
mixer->pcm_muted = muted;
g_snprintf(path, 1024, DVM_CONFIG_PATH"/%s", g_playback_iconset[muted ? 3: 0]);
switch_btn = gtk_event_box_new();
img = gtk_image_new_from_file(path);
gtk_container_add(GTK_CONTAINER(switch_btn), img);
g_object_set_data(G_OBJECT(switch_btn), "iconset", g_playback_iconset);
g_signal_connect(switch_btn, "enter-notify-event", G_CALLBACK(on_enter_switch_widget), mixer);
g_signal_connect(switch_btn, "leave-notify-event", G_CALLBACK(on_leave_switch_widget), mixer);
g_signal_connect(switch_btn, "button-press-event", G_CALLBACK(on_press_switch_widget), mixer);
g_signal_connect(switch_btn, "button-release-event", G_CALLBACK(on_release_switch_widget), mixer);
if(mixer->pcm) {
snd_mixer_selem_get_playback_volume(mixer->pcm, 0, &Rvol);
snd_mixer_selem_get_playback_volume(mixer->pcm, 1, &Lvol);
snd_mixer_selem_get_playback_volume_range(mixer->pcm, &pmin, &pmax);
dval = ((gdouble)(Rvol + Lvol)*50)/(pmax-pmin);
DEBUG("Rvol = %d, Lvol = %d, pmin = %d, pmax = %d, dval = %f\n", Rvol, Lvol, pmin, pmax, dval);
}
adj = gtk_adjustment_new(dval, 0, 100, 1, 6, 0);
g_object_set_data(G_OBJECT(adj), "image-obj", img);
g_object_set_data(G_OBJECT(adj), "mixer-obj", mixer);
if(mixer->pcm) {
snd_mixer_elem_set_callback_private(mixer->pcm, adj);
g_signal_connect(adj, "value-changed", G_CALLBACK(on_playback_mixer_changed), mixer);
}
vbox = am_create_mixer_ui(switch_btn, "Main", GTK_ADJUSTMENT(adj), NULL);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
}
void
gam_toggle_set_elem (GamToggle *gam_toggle, snd_mixer_elem_t *elem)
{
GamTogglePrivate *priv;
g_return_if_fail (GAM_IS_TOGGLE (gam_toggle));
priv = GAM_TOGGLE_GET_PRIVATE (gam_toggle);
if (priv->elem)
snd_mixer_elem_set_callback (priv->elem, NULL);
if (elem) {
snd_mixer_elem_set_callback_private (elem, gam_toggle);
snd_mixer_elem_set_callback (elem, gam_toggle_refresh);
}
priv->elem = elem;
g_object_notify (G_OBJECT (gam_toggle), "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);
}
