static void elem_set_vol_percent(snd_mixer_elem_t *elem, int vol_percent)
{
int i;
long pmin, pmax, value;
//sdbg("%s: set mixer element volume\n", __func__);
for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) {
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);
/* playback volume */
if (snd_mixer_selem_has_playback_volume(elem)) {
value = (int)rint((double)pmin + 0.01 * vol_percent * ((double)pmax - (double)pmin));
snd_mixer_selem_set_playback_volume(elem, i, value);
}
} else if (snd_mixer_selem_has_capture_channel(elem, i) &&
!snd_mixer_selem_has_common_volume(elem)) {
/* capture volume */
snd_mixer_selem_get_capture_volume_range(elem, &pmin, &pmax);
if (snd_mixer_selem_has_capture_volume(elem)) {
value = (int)rint((double)pmin + 0.01 * vol_percent * ((double)pmax - (double)pmin));
snd_mixer_selem_set_capture_volume(elem, i, value);
}
} else {
/* Misc. ex: Boost */
snd_mixer_selem_get_playback_volume_range(elem, &pmin, &pmax);
value = (int)rint((double)pmin + 0.01 * vol_percent * ((double)pmax - (double)pmin));
snd_mixer_selem_set_playback_volume(elem, i, value);
snd_mixer_selem_get_capture_volume_range(elem, &pmin, &pmax);
value = (int)rint((double)pmin + 0.01 * vol_percent * ((double)pmax - (double)pmin));
snd_mixer_selem_set_capture_volume(elem, i, value);
}
}
}
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;
}
void set_volume(GtkAdjustment *adjustment, gpointer user_data)
{
int value = (int) 100 - gtk_adjustment_get_value(adjustment);
g_debug("Setting master volume to: %d", value);
if(value == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_mute), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_mute), FALSE);
long min, max;
snd_mixer_t *mix;
snd_mixer_selem_id_t *sid;
const char *card = "default";
const char *selem_name = "Master";
snd_mixer_open(&mix, 0);
snd_mixer_attach(mix, card);
snd_mixer_selem_register(mix, NULL, NULL);
snd_mixer_load(mix);
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(mix, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_set_playback_volume_all(elem, value * max / 100);
snd_mixer_close(mix);
}
static gint
_j4status_alsa_section_elem_callback(snd_mixer_elem_t *elem, guint mask)
{
J4statusAlsaSection *section = snd_mixer_elem_get_callback_private(elem);
if ( mask == SND_CTL_EVENT_MASK_REMOVE )
return 0;
if ( mask & SND_CTL_EVENT_MASK_INFO )
{
glong min, max;
int error;
error = snd_mixer_selem_get_playback_dB_range(elem, &min, &max);
if ( ( error == 0 ) && ( min < max ) )
section->use_dB = TRUE;
else
{
section->use_dB = FALSE;
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
}
section->min = min;
section->max = max;
}
if ( mask & SND_CTL_EVENT_MASK_VALUE )
_j4status_alsa_section_update(section, elem);
return 0;
}
/**
* @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);
}
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;
}
int volume_up(int vol_min, int vol_max)
{
long min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
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);
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
for (int i = vol_min; i<vol_max; i++) {
int v = i*max /100;
snd_mixer_selem_set_playback_volume_all(elem, v);
//printf("min = %d, max= %d, volume = %d\n", min, max, volume);
usleep(50000);
}
snd_mixer_close(handle);
}
int volume_set(int volume)
{
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 = "Digital";
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);
int v = volume*max /100;
snd_mixer_selem_set_playback_volume_all(elem, v);
snd_mixer_close(handle);
return v;
}
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;
}
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;
}
SIDInfo::SIDInfo(snd_mixer_t* handle, snd_mixer_selem_id_t* sid) :
min(0), max(0), globalMax(0), hasMute(false), hasVolume(false),
_isEmulMuted(false), _lastVol(0), _handle(handle), _sid(sid)
{
if (!_sid) return;
snd_mixer_elem_t *elem;
elem = snd_mixer_find_selem(_handle, _sid);
if (!elem) return;
if (snd_mixer_selem_has_playback_volume(elem))
{
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
if (max > min) hasVolume = true;
else min = max = 0;
}
_lastVol = min;
if (snd_mixer_selem_has_playback_switch(elem))
{
hasMute = true;
}
}
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 int alsa_mixer_set_muted(snd_mixer_elem_t *elem, gboolean muted) {
long val, min, max;
/**if switch is available, get switch status directly*/
if(snd_mixer_selem_has_playback_switch(elem)) {
snd_mixer_selem_set_playback_switch(elem, 0, !muted);
snd_mixer_selem_set_playback_switch(elem, 1, !muted);
return 0;
} else if(snd_mixer_selem_has_capture_switch(elem)) {
snd_mixer_selem_set_capture_switch(elem, 0, !muted);
snd_mixer_selem_set_capture_switch(elem, 1, !muted);
return 0;
}
if(snd_mixer_selem_has_playback_volume(elem)) {
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
val = muted ? min : max;
snd_mixer_selem_set_playback_volume(elem, 0, val);
snd_mixer_selem_set_playback_volume(elem, 1, val);
return 0;
} else if(snd_mixer_selem_has_capture_volume(elem)) {
snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
val = muted ? min : max;
snd_mixer_selem_set_capture_volume(elem, 0, val);
snd_mixer_selem_set_capture_volume(elem, 1, val);
return 0;
}
return -1;
}
void set_volume(int vol)
{
long min, max;
snd_mixer_t *handlev;
snd_mixer_selem_id_t *sid;
const char *card = "default";
const char *selem_name = "Master";
if (vol < 1 || vol > 100) {
printf("ERROR: Volume out of range [0,100] %%\n");
printf("\tSetting volume to 50%%...\n");
vol = 50;
}
snd_mixer_open(&handlev, 0);
snd_mixer_attach(handlev, card);
snd_mixer_selem_register(handlev, NULL, NULL);
snd_mixer_load(handlev);
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(handlev, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_set_playback_volume_all(elem, vol * max / 100 + min);
snd_mixer_close(handlev);
}
/* Volume toggler between 0 <--> element default volume.
* Now excepts new_vol to be in default hardware range of the sound card in use. */
void toggle_volume(
struct sound_profile* sp,
long int const new_vol, // If INT_MAX or negative then toggle to sound
// profiles default volume
enum Volume_type volume_type)
{
// TODO: USE "avolt" SEMAPHORE
long int current_vol;
get_vol(sp->volume_cntrl_mixer_element, hardware, ¤t_vol);
long int min, _;
snd_mixer_selem_get_playback_volume_range(sp->volume_cntrl_mixer_element, &min, &_);
// If current volume is lowest possible
if (current_vol == min) {
if (new_vol > 0 && new_vol != INT_MAX)
set_vol(sp->volume_cntrl_mixer_element, volume_type, new_vol, 0);
else
set_vol(sp->volume_cntrl_mixer_element, sp->volume_type, sp->default_volume, 0);
}
else {
// Else zero current volume
set_vol(sp->volume_cntrl_mixer_element, hardware_percentage, 0, 0);
}
return;
}
mixerVolume::mixerVolume(const char *name, const char *card, long volume) {
snd_mixer_selem_id_t *sid = NULL;
elem = NULL;
handle = NULL;
min = 0;
max = 100;
char cardId[10];
if (!name || !card)
return;
int cx = snd_card_get_index(card);
if (cx < 0 || cx > 31)
return;
snprintf(cardId, sizeof(cardId), "hw:%i", cx);
if (0 > snd_mixer_open(&handle, 0))
return;
if (0 > snd_mixer_attach(handle, cardId))
return;
if (0 > snd_mixer_selem_register(handle, NULL, NULL))
return;
if (0 > snd_mixer_load(handle))
return;
snd_mixer_selem_id_alloca(&sid);
if (!sid)
return;
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, name);
elem = snd_mixer_find_selem(handle, sid);
if (elem) {
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
setVolume(volume);
}
}
static snd_mixer_elem_t *alsa_init_mixer_channel (const char *name,
long *vol_min, long *vol_max)
{
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t *elem = NULL;
snd_mixer_selem_id_malloc (&sid);
snd_mixer_selem_id_set_index (sid, 0);
snd_mixer_selem_id_set_name (sid, name);
if (!(elem = snd_mixer_find_selem(mixer_handle, sid)))
error ("Can't find mixer %s", name);
else if (!snd_mixer_selem_has_playback_volume(elem)) {
error ("Mixer device has no playback volume (%s).", name);
elem = NULL;
}
else {
snd_mixer_selem_get_playback_volume_range (elem, vol_min,
vol_max);
logit ("Opened mixer (%s), volume range: %ld-%ld", name,
*vol_min, *vol_max);
}
snd_mixer_selem_id_free (sid);
return elem;
}
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;
}
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;
}
/**
* Adjusts the current volume and sends a notification (if enabled).
*
* @param vol new volume value
* @param dir select direction (-1 = accurate or first bellow, 0 = accurate,
* 1 = accurate or first above)
* @param notify whether to send notification
* @return 0 on success otherwise negative error code
*/
int
setvol(int vol, int dir, gboolean notify)
{
long min = 0, max = 0, value;
int cur_perc = getvol();
double dvol = 0.01 * vol;
int err = snd_mixer_selem_get_playback_dB_range(elem, &min, &max);
if (err < 0 || min >= max || !normalize_vol()) {
err = snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
value = lrint_dir(dvol * (max - min), dir) + min;
snd_mixer_selem_set_playback_volume_all(elem, value);
if (enable_noti && notify && cur_perc != getvol())
do_notify_volume(getvol(), FALSE);
// intentionally set twice
return snd_mixer_selem_set_playback_volume_all(elem, value);
}
if (use_linear_dB_scale(min, max)) {
value = lrint_dir(dvol * (max - min), dir) + min;
return snd_mixer_selem_set_playback_dB_all(elem, value, dir);
}
if (min != SND_CTL_TLV_DB_GAIN_MUTE) {
double min_norm = exp10((min - max) / 6000.0);
dvol = dvol * (1 - min_norm) + min_norm;
}
value = lrint_dir(6000.0 * log10(dvol), dir) + max;
snd_mixer_selem_set_playback_dB_all(elem, value, dir);
if (enable_noti && notify && cur_perc != getvol())
do_notify_volume(getvol(), FALSE);
// intentionally set twice
return snd_mixer_selem_set_playback_dB_all(elem, value, dir);
}
static void
gam_slider_pan_update_volume (GamSliderPan *gam_slider_pan)
{
GamSliderPanPrivate *priv;
gint left_chn = 0, right_chn = 0;
glong pmin, pmax;
priv = GAM_SLIDER_PAN_GET_PRIVATE (gam_slider_pan);
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);
left_chn = right_chn = rint ((100 - GTK_ADJUSTMENT (priv->vol_adjustment)->value) / (100 / (gfloat)pmax));
if (!snd_mixer_selem_is_playback_mono (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)))) {
if (GTK_ADJUSTMENT (priv->pan_adjustment)->value < 0) {
right_chn = rint (left_chn - ((gfloat)ABS(GTK_ADJUSTMENT (priv->pan_adjustment)->value) / 100) * left_chn);
} else if (GTK_ADJUSTMENT (priv->pan_adjustment)->value > 0) {
left_chn = rint (right_chn - ((gfloat)GTK_ADJUSTMENT (priv->pan_adjustment)->value / 100) * right_chn);
}
}
if (snd_mixer_selem_has_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)))) {
snd_mixer_selem_set_playback_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))))
snd_mixer_selem_set_playback_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), SND_MIXER_SCHN_FRONT_RIGHT, right_chn);
} else {
snd_mixer_selem_set_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))))
snd_mixer_selem_set_capture_volume (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)), SND_MIXER_SCHN_FRONT_RIGHT, right_chn);
}
}
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)));
}
}
static int alsa_mixer_open(int *volume_max)
{
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t *elem;
int count;
int rc;
snd_mixer_selem_id_alloca(&sid);
rc = snd_mixer_open(&alsa_mixer_handle, 0);
if (rc < 0)
goto error;
rc = snd_mixer_attach(alsa_mixer_handle, alsa_mixer_device);
if (rc < 0)
goto error;
rc = snd_mixer_selem_register(alsa_mixer_handle, NULL, NULL);
if (rc < 0)
goto error;
rc = snd_mixer_load(alsa_mixer_handle);
if (rc < 0)
goto error;
count = snd_mixer_get_count(alsa_mixer_handle);
if (count == 0) {
d_print("error: mixer does not have elements\n");
return -2;
}
elem = snd_mixer_first_elem(alsa_mixer_handle);
while (elem) {
const char *name;
int has_vol, has_switch;
snd_mixer_selem_get_id(elem, sid);
name = snd_mixer_selem_id_get_name(sid);
d_print("name = %s\n", name);
d_print("has playback volume = %d\n", snd_mixer_selem_has_playback_volume(elem));
d_print("has playback switch = %d\n", snd_mixer_selem_has_playback_switch(elem));
if (strcasecmp(name, alsa_mixer_element)) {
elem = snd_mixer_elem_next(elem);
continue;
}
has_vol = snd_mixer_selem_has_playback_volume(elem);
if (!has_vol) {
d_print("mixer element `%s' does not have playback volume\n", name);
return -2;
}
snd_mixer_selem_get_playback_volume_range(elem,
&mixer_vol_min, &mixer_vol_max);
has_switch = snd_mixer_selem_has_playback_switch(elem);
/* FIXME: get number of channels */
mixer_elem = elem;
*volume_max = mixer_vol_max - mixer_vol_min;
return 0;
}
d_print("error: mixer element `%s' not found\n", alsa_mixer_element);
return -2;
error:
d_print("error: %s\n", snd_strerror(rc));
return -1;
}
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;
}
/*
* 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;
}
void asound_set_volume(int volume)
{
assert(m_elem != NULL);
assert(volume >= 0 && volume <= 100);
long pmin, pmax;
snd_mixer_selem_get_playback_volume_range(m_elem, &pmin, &pmax);
long value = pmax * volume / 100;
snd_mixer_selem_set_playback_volume_all(m_elem, value);
}
int asound_get_volume()
{
assert(m_elem != NULL);
// Return the current volume value from [0-100]
long pmin, pmax, value;
snd_mixer_selem_get_playback_volume_range(m_elem, &pmin, &pmax);
snd_mixer_selem_get_playback_volume(m_elem, 0, &value);
return 100 * value / pmax;
}
static void set_volume(AudioCapture *capture, int level) {
snd_mixer_t *mixer=NULL;
int err;
err=snd_mixer_open(&mixer,0);
if(err < 0) {
fprintf(stderr, "Could not open alsa mixer: %s\r\n",snd_strerror(err));
exit(1);
}
char hw_id[100];
snprintf(hw_id, sizeof(hw_id), "hw:%d", capture->pcm_id);
if ((err = snd_mixer_attach (mixer, hw_id)) < 0){
fprintf(stderr, "Could not attach mixer to card(%s): %s\r\n", hw_id, snd_strerror(err));
snd_mixer_close(mixer);
exit(1);
}
if ((err = snd_mixer_selem_register (mixer, NULL, NULL)) < 0){
fprintf(stderr, "snd_mixer_selem_register: %s\r\n",snd_strerror(err));
snd_mixer_close(mixer);
exit(1);
}
if ((err = snd_mixer_load (mixer)) < 0){
fprintf(stderr, "snd_mixer_load: %s\r\n",snd_strerror(err));
snd_mixer_close(mixer);
exit(1);
}
snd_mixer_elem_t *elem;
elem = snd_mixer_first_elem(mixer);
while(elem) {
const char *elemname = snd_mixer_selem_get_name(elem);
if(strcmp(elemname, "Capture") && strcmp(elemname, "Mic")) {
fprintf(stderr, "Skip setting volume for %s\r\n", elemname);
elem=snd_mixer_elem_next(elem);
continue;
}
if (snd_mixer_selem_has_capture_volume(elem)){
fprintf(stderr, "Set volume for %s\r\n", elemname);
long sndMixerPMin;
long sndMixerPMax;
long newvol;
snd_mixer_selem_get_playback_volume_range(elem, &sndMixerPMin, &sndMixerPMax);
newvol=(((sndMixerPMax-sndMixerPMin)*level)/100)+sndMixerPMin;
snd_mixer_selem_set_capture_volume_all(elem,newvol);
elem=snd_mixer_elem_next(elem);
} else {
fprintf(stderr, "Can't set capture volume\r\n");
exit(1);
}
}
}
int AlsaEngine::volumeMax(AudioDevice *device) const
{
AlsaDevice *dev = qobject_cast<AlsaDevice*>(device);
if (!dev || !dev->element())
return 100;
long vmin;
long vmax;
snd_mixer_selem_get_playback_volume_range(dev->element(), &vmin, &vmax);
return vmax;
}
char *
get_vol(snd_mixer_t *handle, snd_mixer_elem_t *elem) {
int mute = 0;
long vol, max, min;
snd_mixer_handle_events(handle);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_get_playback_volume(elem, 0, &vol);
snd_mixer_selem_get_playback_switch(elem, 0, &mute);
return smprintf(mute == 0 ? VOL_MUTE : VOL, (vol * 100) / max);
}
