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