static void balance_volumes(void)
{
struct control *control;
long left, right;
int err;
control = get_focus_control(TYPE_PVOLUME | TYPE_CVOLUME);
if (!control || !(control->flags & HAS_VOLUME_1))
return;
if (control->flags & TYPE_PVOLUME) {
err = snd_mixer_selem_get_playback_volume(control->elem, control->volume_channels[0], &left);
if (err < 0)
return;
err = snd_mixer_selem_get_playback_volume(control->elem, control->volume_channels[1], &right);
if (err < 0)
return;
} else {
err = snd_mixer_selem_get_capture_volume(control->elem, control->volume_channels[0], &left);
if (err < 0)
return;
err = snd_mixer_selem_get_capture_volume(control->elem, control->volume_channels[1], &right);
if (err < 0)
return;
}
left = (left + right) / 2;
if (control->flags & TYPE_PVOLUME) {
snd_mixer_selem_set_playback_volume(control->elem, control->volume_channels[0], left);
snd_mixer_selem_set_playback_volume(control->elem, control->volume_channels[1], left);
} else {
snd_mixer_selem_set_capture_volume(control->elem, control->volume_channels[0], left);
snd_mixer_selem_set_capture_volume(control->elem, control->volume_channels[1], left);
}
display_controls();
}
static int elem_get_vol_percent(snd_mixer_elem_t *elem)
{
int i, percent;
long pmin, pmax, volume;
for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) {
/* playback volume */
if (snd_mixer_selem_has_playback_channel(elem, i) &&
!snd_mixer_selem_has_common_volume(elem)) {
snd_mixer_selem_get_playback_volume_range(elem, &pmin, &pmax);
if (snd_mixer_selem_has_playback_volume(elem))
snd_mixer_selem_get_playback_volume(elem, i, &volume);
}
/* capture volume */
else if (snd_mixer_selem_has_capture_channel(elem, i) &&
!snd_mixer_selem_has_common_volume(elem)) {
snd_mixer_selem_get_capture_volume_range(elem, &pmin, &pmax);
if (snd_mixer_selem_has_capture_volume(elem))
snd_mixer_selem_get_capture_volume(elem, i, &volume);
} else {
/* Misc. ex: Boost */
snd_mixer_selem_get_playback_volume_range(elem, &pmin, &pmax);
snd_mixer_selem_get_playback_volume(elem, i, &volume);
}
}
percent = (int) ((double)(volume - pmin) / (double)(pmax - pmin) * 100);
return percent;
}
static gboolean alsa_mixer_is_muted(snd_mixer_elem_t *elem, gboolean *need_reset) {
int sw;
long Rvol, Lvol, min, max;
if(need_reset)
*need_reset = FALSE;
/**if switch is available, get switch status directly*/
if(snd_mixer_selem_has_playback_switch(elem)) {
snd_mixer_selem_get_playback_switch(elem, 0, &sw);
return sw ? FALSE: TRUE;
} else if(snd_mixer_selem_has_capture_switch(elem)) {
snd_mixer_selem_get_capture_switch(elem, 0, &sw);
return sw ? FALSE: TRUE;
}
if(snd_mixer_selem_has_playback_volume(elem)) {
snd_mixer_selem_get_playback_volume(elem, 0, &Rvol);
snd_mixer_selem_get_playback_volume(elem, 1, &Lvol);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
if(need_reset)
*need_reset = !!(max - Rvol);
return (Rvol + Lvol) ? FALSE: TRUE;
} else if(snd_mixer_selem_has_capture_volume(elem)) {
snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
snd_mixer_selem_get_capture_volume(elem, 0, &Rvol);
snd_mixer_selem_get_capture_volume(elem, 1, &Lvol);
if(need_reset)
*need_reset = !!(max - Rvol);
return (Rvol + Lvol) ? FALSE: TRUE;
}
}
static gint
gam_slider_pan_get_volume (GamSliderPan *gam_slider_pan)
{
glong left_chn, right_chn, pmin, pmax;
if (snd_mixer_selem_has_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan))))
snd_mixer_selem_get_playback_volume_range (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), &pmin, &pmax);
else
snd_mixer_selem_get_capture_volume_range (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), &pmin, &pmax);
if (snd_mixer_selem_has_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan))))
snd_mixer_selem_get_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), SND_MIXER_SCHN_FRONT_LEFT, &left_chn);
else
snd_mixer_selem_get_capture_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), SND_MIXER_SCHN_FRONT_LEFT, &left_chn);
if (snd_mixer_selem_is_playback_mono (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)))) {
return rint (100 - (left_chn * (100 / (gfloat)pmax)));
} else {
if (snd_mixer_selem_has_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan))))
snd_mixer_selem_get_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), SND_MIXER_SCHN_FRONT_RIGHT, &right_chn);
else
snd_mixer_selem_get_capture_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), SND_MIXER_SCHN_FRONT_RIGHT, &right_chn);
return rint (100 - (MAX(left_chn, right_chn) * (100 / (gfloat)pmax)));
}
}
void lamixer_volbox_show(VolBox *volumebox, snd_mixer_elem_t *elem, GtkWidget *mixerbox)
{
long rangevalue_left,rangevalue_right;
int mute, *bCols;
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
bCols = &pCols;
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue_left);
bCols = &cCols;
}
volumebox->curval = rangevalue_left;
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->vollabel, *bCols-1, *bCols, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_range_set_value(GTK_RANGE(volumebox->volbar), rangevalue_left);
gtk_box_pack_start(GTK_BOX(volumebox->volbarbox), volumebox->volbar, TRUE, TRUE, 0);
volumebox->hsignalid = g_signal_connect(G_OBJECT(volumebox->volbar), "value-changed", G_CALLBACK(lamixer_volbox_changed), volumebox);
if (volumebox->rvolbar != NULL) {
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
volumebox->rcurval = rangevalue_right;
gtk_box_pack_start(GTK_BOX(volumebox->volbarbox), volumebox->rvolbar, TRUE, TRUE, 0);
gtk_range_set_value(GTK_RANGE(volumebox->rvolbar), rangevalue_right);
volumebox->hsignalidr = g_signal_connect(G_OBJECT(volumebox->rvolbar), "value-changed", G_CALLBACK(lamixer_volboxr_changed), volumebox);
}
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->volbarbox, *bCols-1, *bCols, 1, 2, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
if (volumebox->lockswitch != NULL) {
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->lockswitch, *bCols-1, *bCols, 2, 3, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(volumebox->lockswitch), TRUE);
}
if (volumebox->muteswitch != NULL) {
snd_mixer_selem_get_playback_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mute);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(volumebox->muteswitch), !mute);
volumebox->hmutesignalid = g_signal_connect(G_OBJECT(volumebox->muteswitch), "toggled", G_CALLBACK(lamixer_muteswitch_changed), elem);
gtk_table_attach(GTK_TABLE(mixerbox), volumebox->muteswitch, *bCols-1, *bCols, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
}
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++(*bCols));
gtk_table_attach(GTK_TABLE(mixerbox), gtk_vseparator_new (), *bCols-1, *bCols, 0, 5, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 4, 0);
gtk_table_resize(GTK_TABLE(mixerbox), mRows, ++(*bCols));
}
int AlsaMixer::get_volume()
{
int value;
long left, right;
snd_mixer_handle_events(this->handle);
snd_mixer_selem_get_playback_volume(this->active_elem, LEFT, &left);
snd_mixer_selem_get_playback_volume(this->active_elem, RIGHT, &right);
value = (int)(((left + (right - left)/2)*100) / (this->max - this->min));
return value;
}
int AmeSystemSound::volume()
{
if (!mixer_element)
return 0;
long l, r;
snd_mixer_handle_events(mixer);
snd_mixer_selem_get_playback_volume(mixer_element, SND_MIXER_SCHN_FRONT_LEFT, &l);
snd_mixer_selem_get_playback_volume(mixer_element, SND_MIXER_SCHN_FRONT_RIGHT, &r);
return (l+r)/2;
}
static int alsa_mixer_get_volume(int *l, int *r)
{
long lv, rv;
if (mixer_elem == NULL)
return -1;
snd_mixer_handle_events(alsa_mixer_handle);
snd_mixer_selem_get_playback_volume(mixer_elem, SND_MIXER_SCHN_FRONT_LEFT, &lv);
snd_mixer_selem_get_playback_volume(mixer_elem, SND_MIXER_SCHN_FRONT_RIGHT, &rv);
*l = lv - mixer_vol_min;
*r = rv - mixer_vol_min;
return 0;
}
static int on_mixer_elem_event(snd_mixer_elem_t *elem, unsigned int mask) {
snd_mixer_selem_id_t *sid;
void *data = NULL;
if(elem)
data = snd_mixer_elem_get_callback_private(elem);
if(data) {
long min, max, Rvol, Lvol;
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_get_id(elem, sid);
DEBUG("mixer elem control = %s, mask = %x, data = %x\n", snd_mixer_selem_id_get_name(sid), mask, data);
if(mask & SND_CTL_EVENT_MASK_VALUE) {
char path[1024] = {0};
alsa_mixer_t *mixer = (alsa_mixer_t *)g_object_get_data(G_OBJECT(data), "mixer-obj");
GtkWidget *img = (GtkWidget *)g_object_get_data(G_OBJECT(data), "image-obj");
DEBUG("mixer = %x, img = %x\n", mixer, img);
if(snd_mixer_selem_has_playback_volume(elem)) {
if(mixer->pcm_muted != alsa_mixer_is_muted(elem, NULL)) {
mixer->pcm_muted = !mixer->pcm_muted;
g_snprintf(path, 1024, DVM_CONFIG_PATH"/%s", g_playback_iconset[mixer->pcm_muted ? 3: 0]);
DEBUG("playback switch detected, image path = %s\n", path);
gtk_image_set_from_file(GTK_IMAGE(img), path);
}
snd_mixer_selem_get_playback_volume(elem, 0, &Rvol);
snd_mixer_selem_get_playback_volume(elem, 1, &Lvol);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
DEBUG("new val = %d, %d, min = %d, max = %d\n", Rvol, Lvol, min, max);
} else if(snd_mixer_selem_has_capture_volume(elem)) {
if(mixer->mic_muted != alsa_mixer_is_muted(elem, NULL)) {
mixer->mic_muted = !mixer->mic_muted;
g_snprintf(path, 1024, DVM_CONFIG_PATH"/%s", g_capture_iconset[mixer->mic_muted ? 3: 0]);
DEBUG("capture switch detected, image path = %s\n", path);
gtk_image_set_from_file(GTK_IMAGE(img), path);
}
snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
snd_mixer_selem_get_capture_volume(elem, 0, &Rvol);
snd_mixer_selem_get_capture_volume(elem, 1, &Lvol);
DEBUG("new val = %d, %d, min = %d, max = %d\n", Rvol, Lvol, min, max);
}
g_mixer_ui_updated = TRUE;
gtk_adjustment_set_value(GTK_ADJUSTMENT(data), ((gdouble)(Rvol+Lvol)*50)/(max-min));
}
}
return 0;
}
int AmeSystemSound::setupMixer(QString card, QString device)
{
char *name;
long int a, b;
long alsa_min_vol = 0, alsa_max_vol = 100;
int err, index;
mixer_element = 0;
qDebug("AmeSystemSound::SoundOutput: setupMixer()");
if ((err = getMixer(&mixer, card)) < 0)
return err;
parseMixerName(device.toAscii().data(), &name, &index);
mixer_element = getMixerElem(mixer, name, index);
free(name);
if (!mixer_element)
{
qWarning("SoundOutput: Failed to find mixer element");
return -1;
}
/* This hack was copied from xmms.
* Work around a bug in alsa-lib up to 1.0.0rc2 where the
* new range don't take effect until the volume is changed.
* This hack should be removed once we depend on Alsa 1.0.0.
*/
snd_mixer_selem_get_playback_volume(mixer_element, SND_MIXER_SCHN_FRONT_LEFT, &a);
snd_mixer_selem_get_playback_volume(mixer_element, SND_MIXER_SCHN_FRONT_RIGHT, &b);
snd_mixer_selem_get_playback_volume_range(mixer_element,
&alsa_min_vol, &alsa_max_vol);
snd_mixer_selem_set_playback_volume_range(mixer_element, 0, 100);
if (alsa_max_vol == 0)
{
mixer_element = NULL;
return -1;
}
setVolume(a * 100 / alsa_max_vol);
qDebug("SoundOutput: setupMixer() success");
return 0;
}
/**
* Returns the currently set volume.
*
* @param dfCard [in] get the volume directly from card?
*
* @return Volume in percent
*/
int MMSAudioCtrl::getVolume(bool dfCard) {
long lval, rval;
int retval = this->volume;
if ((!this->muteFlag)||(dfCard)) {
/* get the current volume settings */
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &lval);
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &rval);
if ((lval != this->xval)||(rval != this->xval))
retval = (int)(((lval + (rval - lval) / 2) * 100) / (this->pmax - this->pmin));
if (!this->muteFlag) this->volume = retval;
return retval;
}
return this->volume;
}
static int
brightside_volume_alsa_get_volume (BrightsideVolume *vol)
{
BrightsideVolumeAlsa *self = (BrightsideVolumeAlsa *) vol;
long lval, rval;
int tmp;
snd_mixer_selem_get_playback_volume(self->_priv->elem,
SND_MIXER_SCHN_FRONT_LEFT, &lval);
snd_mixer_selem_get_playback_volume(self->_priv->elem,
SND_MIXER_SCHN_FRONT_RIGHT, &rval);
tmp = brightside_volume_alsa_vol_check (self, (int) (lval + rval) / 2);
return (tmp * 100 / self->_priv->pmax);
}
VolumeSettings VolumeALSA::volume() const
{
VolumeSettings vol;
if(pcm_element)
{
long value = 0;
snd_mixer_handle_events(m_mixer);
snd_mixer_selem_get_playback_volume(pcm_element, SND_MIXER_SCHN_FRONT_LEFT, &value);
vol.left = value;
snd_mixer_selem_get_playback_volume(pcm_element, SND_MIXER_SCHN_FRONT_RIGHT, &value);
vol.right = value;
}
return vol;
}
static PxVolume get_volume_indexed(PxDev *dev, int i, int playback)
{
snd_mixer_elem_t *elem;
long vol, min, max;
if (!dev->handle) {
return 0.0;
}
if (i < 0 || i > dev->numselems) {
return 0.0;
}
elem = dev->selems[i].elem;
if (playback) {
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
if (snd_mixer_selem_has_playback_channel(elem, SND_MIXER_SCHN_FRONT_LEFT)) {
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &vol);
return (PxVolume) vol / (max - min);
}
}
else {
snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
if (snd_mixer_selem_has_capture_channel(elem, SND_MIXER_SCHN_FRONT_LEFT)) {
snd_mixer_selem_get_capture_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &vol);
return (PxVolume) vol / (max - min);
}
}
return 0.0;
}
char *getvolume() {
char *buf;
int active;
long volume, min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t* elem;
const char *card = "default";
const char *selem_name = "Master";
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, card);
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
elem = snd_mixer_find_selem(handle, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &volume);
snd_mixer_selem_get_playback_switch(elem, SND_MIXER_SCHN_FRONT_LEFT, &active);
buf = xmalloc(10);
if (active)
snprintf(buf, 10, "%0.f%%", (double) volume / (double) max * 100);
else
snprintf(buf, 10, "off");
snd_mixer_close(handle);
return buf;
}
double getnormvolume(snd_mixer_elem_t *elem) {
long min=0, max=0, value = 0;
double normalized=0, min_norm = 0;
int err;
err = snd_mixer_selem_get_playback_dB_range(elem, &min, &max);
if (err < 0 || min >= max) {
err = snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
if (err < 0 || min == max)
return 0;
err = snd_mixer_selem_get_playback_volume(elem, channel, &value);
if (err < 0)
return 0;
return (value - min) / (double)(max - min);
}
err = snd_mixer_selem_get_playback_dB(elem, channel, &value);
if (err < 0)
return 0;
if (use_linear_dB_scale(min, max))
return (value - min) / (double)(max - min);
normalized = exp10((value - max) / 6000.0);
if (min != SND_CTL_TLV_DB_GAIN_MUTE) {
min_norm = exp10((min - max) / 6000.0);
normalized = (normalized - min_norm) / (1 - min_norm);
}
return normalized;
}
static long get_master_volume()
{
snd_mixer_t *handle;
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, Y50_CTL_NAME);
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_t *master_sid;
const char *master_selem_name = "Master";
snd_mixer_selem_id_alloca(&master_sid);
snd_mixer_selem_id_set_index(master_sid, 0);
snd_mixer_selem_id_set_name(master_sid, master_selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, master_sid);
long min, max;
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
long volume;
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_MONO, &volume);
snd_mixer_close(handle);
return volume * 100 / max;
}
long mpg321_alsa_get_volume(void)
{
long volume;
if(mixerelem)
snd_mixer_selem_get_playback_volume(mixerelem,SND_MIXER_SCHN_FRONT_RIGHT,&volume);
return volume;
}
long getvol(snd_mixer_elem_t *elem) {
long vol;
snd_mixer_selem_get_playback_volume(elem, 0, &vol);
return vol;
}
char *get_vol(char *buf) {
long max = 0, min = 0, vol = 0;
int mute = 0;
snd_mixer_t *handle;
snd_mixer_elem_t *pcm_mixer, *mas_mixer;
snd_mixer_selem_id_t *vol_info, *mute_info;
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, "default");
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_malloc(&vol_info);
snd_mixer_selem_id_malloc(&mute_info);
snd_mixer_selem_id_set_name(vol_info, VOL_CH);
snd_mixer_selem_id_set_name(mute_info, VOL_CH);
pcm_mixer = snd_mixer_find_selem(handle, vol_info);
mas_mixer = snd_mixer_find_selem(handle, mute_info);
snd_mixer_selem_get_playback_volume_range((snd_mixer_elem_t *)pcm_mixer, &min, &max);
snd_mixer_selem_get_playback_volume((snd_mixer_elem_t *)pcm_mixer, SND_MIXER_SCHN_MONO, &vol);
snd_mixer_selem_get_playback_switch(mas_mixer, SND_MIXER_SCHN_MONO, &mute);
sprintf(buf, !(mute) ? VOL_MUTE_S : VOL_S, (int)vol * 100 / (int)max);
if(vol_info)
snd_mixer_selem_id_free(vol_info);
if(mute_info)
snd_mixer_selem_id_free(mute_info);
if(handle)
snd_mixer_close(handle);
return buf;
}
/**
* @brief Get the Volume for the master channel.
*
* This function uses the Alsa API to get the volume
* for the master channel.
*
* @param [out] ptr pointer to long, output will be between 0 and 99.
* @return Void.
*/
void get_volume(long *ptr){
long min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
const char *card = "default";
//const char *selem_name = "Master";
const char *selem_name = "DAC2 Digital Course";
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, card);
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
printd("Volume range <%lu,%lu>\n", min, max);
snd_mixer_selem_get_playback_volume(elem,0,ptr);
printd("volume val = %lu\n",*ptr);
*ptr /= (max / 100);
snd_mixer_close(handle);
}
static void _get_volume(snd_mixer_elem_t *elem, int playback, int n, long *val)
{
if (playback)
snd_mixer_selem_get_playback_volume(elem, n, val);
else
snd_mixer_selem_get_capture_volume(elem, n, val);
}
static void
update_volume (MokoAlsaVolumeControl *control)
{
long volume;
MokoAlsaVolumeControlPrivate *priv = ALSA_VOLUME_CONTROL_PRIVATE (control);
/* TODO: Average out volume across channels? */
switch (priv->control_type) {
case PLAYBACK :
snd_mixer_selem_get_playback_volume (
priv->mixer_elem, 0, &volume);
break;
case CAPTURE :
snd_mixer_selem_get_capture_volume (
priv->mixer_elem, 0, &volume);
break;
case CONTROL :
default :
/* TODO: Handle switches? */
g_warning ("Unhandled control type");
return;
}
if (priv->volume != volume) {
priv->volume = volume;
g_signal_emit (control, signals[VOLUME_CHANGED],
0, (gdouble)(priv->volume - priv->min) /
(gdouble)(priv->max - priv->min));
}
}
static int lamixer_volbox_change(snd_mixer_elem_t *elem, unsigned int mask)
{
long rangevalue=0;
int mutesw;
MixerElem *mixer_elem;
if (mask == SND_CTL_EVENT_MASK_REMOVE)
return 0;
if (mask & SND_CTL_EVENT_MASK_VALUE) {
mixer_elem = snd_mixer_elem_get_callback_private(elem);
if(mixer_elem->playback != NULL) {
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue);
lamixer_volbox_check(mixer_elem->playback->volbar, mixer_elem->playback->hsignalid, rangevalue, &mixer_elem->playback->curval);
if(mixer_elem->playback->rvolbar != NULL)
{
rangevalue=0;
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue);
lamixer_volbox_check(mixer_elem->playback->rvolbar, mixer_elem->playback->hsignalidr, rangevalue, &mixer_elem->playback->rcurval);
}
if(mixer_elem->playback->muteswitch != NULL) {
snd_mixer_selem_get_playback_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mutesw);
lamixer_switch_checkvalue(mixer_elem->playback->muteswitch, mutesw, mixer_elem->playback->hmutesignalid);
}
}
if(mixer_elem->capture != NULL) {
rangevalue=0;
snd_mixer_selem_get_capture_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue);
lamixer_volbox_check(mixer_elem->capture->volbar, mixer_elem->capture->hsignalid, rangevalue, &mixer_elem->capture->curval);
if(mixer_elem->capture->rvolbar != NULL)
{
rangevalue=0;
snd_mixer_selem_get_capture_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue);
lamixer_volbox_check(mixer_elem->capture->rvolbar, mixer_elem->capture->hsignalidr, rangevalue, &mixer_elem->capture->rcurval);
}
if(mixer_elem->capture->muteswitch != NULL) {
snd_mixer_selem_get_capture_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mutesw);
lamixer_switch_checkvalue(mixer_elem->capture->muteswitch, mutesw, mixer_elem->capture->hmutesignalid);
}
}
}
return 0;
}
static long volume_get() {
long volume;
if(snd_mixer_selem_get_playback_volume(alsa.elem, 0, &volume)<0)
return -1;
volume-=alsa.minv;
return (100L*volume)/(alsa.maxv-alsa.minv);
}
bool AlsaMixer::GetVolumePercent( const char* channel, int* value )
{
LOG( Logger::LOG_DEBUG, "AlsaMixer::GetVolume( %s )", channel);
bool success = false;
snd_mixer_elem_t *elem;
snd_mixer_selem_id_t *sid;
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index( sid, 0);
snd_mixer_selem_id_set_name( sid, channel);
elem = snd_mixer_find_selem(_handle, sid);
if (!elem) {
LOG( Logger::LOG_ERROR, "Unable to find simple control '%s',%i\n", snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
goto end;
}
if( snd_mixer_selem_has_playback_volume(elem) )
{
long min, max;
if( snd_mixer_selem_get_playback_volume_range(elem, &min, &max) < 0 )
{
LOG( Logger::LOG_ERROR, "Unable to get playback volume range for control '%s',%i\n", snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
goto end;
}
long volume;
for (int chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
if (snd_mixer_selem_get_playback_volume(elem, (snd_mixer_selem_channel_id_t)chn, &volume ) >= 0)
{
*value = (volume - min) * 100 / ( max - min );
success = true;
break;
}
}
}else if( snd_mixer_selem_has_capture_volume(elem) )
{
long min, max;
if( snd_mixer_selem_get_capture_volume_range(elem, &min, &max) < 0 )
{
LOG( Logger::LOG_ERROR, "Unable to get capture volume range for control '%s',%i\n", snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
goto end;
}
long volume;
for (int chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
if (snd_mixer_selem_get_capture_volume(elem, (snd_mixer_selem_channel_id_t)chn, &volume ) >= 0)
{
*value = (volume - min) * 100 / ( max - min );
success = true;
break;
}
}
}
if( !success )
{
LOG( Logger::LOG_ERROR, "Error getting control '%s',%i\n", snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
}
end:
return success;
}
void GetAlsaVolume(long* volume) {
const char *card = "default";
const char *selem_name = "Master";
// snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
struct alsa_control_struct c_struct = GetStruct(card,selem_name);
snd_mixer_selem_get_playback_volume(c_struct.elem,0,volume);
snd_mixer_close(c_struct.handle);
}
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);
}
/*
* originally from
* stackoverflow.com/questions/7657624/get-master-sound-volume-in-c-in-linux
*/
static int get_audio_volume(MixSelect select, long* outvol) {
int ret = 0;
snd_mixer_t* handle;
snd_mixer_elem_t* elem;
snd_mixer_selem_id_t* sid;
long minv, maxv;
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, select.mix_index);
snd_mixer_selem_id_set_name(sid, select.mix_name);
if ((snd_mixer_open(&handle, 0)) < 0) {
return -1;
}
if ((snd_mixer_attach(handle, select.card)) < 0) {
snd_mixer_close(handle);
return -2;
}
if ((snd_mixer_selem_register(handle, NULL, NULL)) < 0) {
snd_mixer_close(handle);
return -3;
}
ret = snd_mixer_load(handle);
if (ret < 0) {
snd_mixer_close(handle);
return -4;
}
elem = snd_mixer_find_selem(handle, sid);
if (!elem) {
snd_mixer_close(handle);
return -5;
}
snd_mixer_selem_get_playback_volume_range(elem, &minv, &maxv);
if(snd_mixer_selem_get_playback_volume(elem, 0, outvol) < 0) {
snd_mixer_close(handle);
return -6;
}
// make volume out of 100
*outvol -= minv;
maxv -= minv;
minv = 0;
*outvol = 100 * (*outvol) / maxv;
snd_mixer_close(handle);
return 0;
}
long SIDInfo::getRealVolume()
{
if (!hasVolume || !_sid) return min;
snd_mixer_elem_t* elem = snd_mixer_find_selem(_handle, _sid);
if (!elem) return min;
long vleft, vright;
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &vleft);
vright = vleft;
if (!snd_mixer_selem_is_playback_mono(elem))
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &vright);
return (vleft + vright)/2;
}
