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); }