bool AlsaMixer::Init( const char* card ) { LOG( Logger::LOG_DEBUG, "AlsaMixer::Init( %s )", card); int err = 0; bool success = false; if ( (err = snd_mixer_open(&_handle, 0)) < 0 ) { LOG( Logger::LOG_ERROR, "Mixer %s open error: %s", card, snd_strerror(err)); _handle = NULL; goto end; } if( (err = snd_mixer_attach(_handle, card)) < 0) { LOG( Logger::LOG_ERROR, "Mixer %s attach error: %s", card, snd_strerror(err)); goto end; } if ((err = snd_mixer_selem_register(_handle, NULL, NULL)) < 0) { LOG( Logger::LOG_ERROR, "Mixer register error: %s", snd_strerror(err)); goto end; } if ((err = snd_mixer_load(_handle)) < 0) { LOG( Logger::LOG_ERROR, "Mixer %s load error: %s", card, snd_strerror(err)); goto end; } success = true; end: if( !success ) { if( _handle ) { snd_mixer_close(_handle); _handle = NULL; } } return success; }
/** * init_alsa * must be called before other alsa functions * only needs to be called once * initializes alsa handle */ void init_alsa() { snd_mixer_open(&alsa, 0); snd_mixer_attach(alsa, SOUNDCARD); snd_mixer_selem_register(alsa, NULL, NULL); snd_mixer_load(alsa); if (alsa == NULL) { fprintf(stderr, "error opening sound card " SOUNDCARD); return; } 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, ALSAMIXER); alsamixer = snd_mixer_find_selem(alsa, sid); if (alsamixer == NULL) { fprintf(stderr, "error opening alsa mixer " ALSAMIXER); return; } }
/** * @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); }
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); }
void setVolume(int level) { int volume; snd_mixer_t *mixer_handle; if (snd_mixer_open (&mixer_handle, card, device) < 0) { slogf( _SLOG_SETCODE(_SLOGC_AUDIO, 0), _SLOG_CRITICAL, "Unable to open mixer\n"); return; } snd_mixer_group_read(mixer_handle, &group); volume = (float)(group.max - group.min) * ( level / 100.0) + group.min; if (group.channels & SND_MIXER_CHN_MASK_FRONT_LEFT) group.volume.names.front_left = volume; if (group.channels & SND_MIXER_CHN_MASK_REAR_LEFT) group.volume.names.rear_left = volume; if (group.channels & SND_MIXER_CHN_MASK_FRONT_CENTER) group.volume.names.front_center = volume; if (group.channels & SND_MIXER_CHN_MASK_FRONT_RIGHT) group.volume.names.front_right = volume; if (group.channels & SND_MIXER_CHN_MASK_REAR_RIGHT) group.volume.names.rear_right = volume; if (group.channels & SND_MIXER_CHN_MASK_WOOFER) group.volume.names.woofer = volume; snd_mixer_group_write(mixer_handle, &group); snd_mixer_close (mixer_handle); }
/** * Opens the mixer, attaches the alsa card to it, * registers the mixer simple element class and * loads the mixer elements. * * @param card HCTL name * @param opts Options container * @param level mixer level * @return the mixer handle, or NULL on failure */ static snd_mixer_t * open_mixer(const char *card, struct snd_mixer_selem_regopt *opts, int level) { int err; snd_mixer_t *mixer = NULL; DEBUG_PRINT("Card %s: opening mixer", card); if ((err = snd_mixer_open(&mixer, 0)) < 0) { DEBUG_PRINT("Card %s: mixer open error: %s", card, snd_strerror(err)); return NULL; } if (level == 0 && (err = snd_mixer_attach(mixer, card)) < 0) { DEBUG_PRINT("Card %s: mixer attach error: %s", card, snd_strerror(err)); snd_mixer_close(mixer); return NULL; } if ((err = snd_mixer_selem_register( mixer, level > 0 ? opts : NULL, NULL)) < 0) { DEBUG_PRINT("Card %s: mixer register error: %s", card, snd_strerror(err)); snd_mixer_close(mixer); return NULL; } if ((err = snd_mixer_load(mixer)) < 0) { DEBUG_PRINT("Card %s: mixer load error: %s", card, snd_strerror(err)); snd_mixer_close(mixer); return NULL; } return mixer; }
static snd_mixer_t *alsa_mixer_open(const char *mixdev){ snd_mixer_t *mixer=NULL; int err; err=snd_mixer_open(&mixer,0); if (err<0){ ms_warning("Could not open alsa mixer: %s",snd_strerror(err)); return NULL; } if ((err = snd_mixer_attach (mixer, mixdev)) < 0){ ms_warning("Could not attach mixer to card: %s",snd_strerror(err)); snd_mixer_close(mixer); return NULL; } if ((err = snd_mixer_selem_register (mixer, NULL, NULL)) < 0){ ms_warning("snd_mixer_selem_register: %s",snd_strerror(err)); snd_mixer_close(mixer); return NULL; } if ((err = snd_mixer_load (mixer)) < 0){ ms_warning("snd_mixer_load: %s",snd_strerror(err)); snd_mixer_close(mixer); return NULL; } return mixer; }
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; }
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); } }
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 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; }
int initMixer() { int result; if ((result = snd_mixer_open( &mixerFd, 0)) < 0) { printf("sucks1!\n"); mixerFd = NULL; return result; } if ((result = snd_mixer_attach( mixerFd, "default")) < 0) { printf("snd_mixer_attach error"); snd_mixer_close(mixerFd); mixerFd = NULL; return result; } if ((result = snd_mixer_selem_register( mixerFd, NULL, NULL)) < 0) { printf("snd_mixer_selem_register error"); snd_mixer_close(mixerFd); mixerFd = NULL; return result; } if ((result = snd_mixer_load( mixerFd)) < 0) { printf("snd_mixer_load error"); snd_mixer_close(mixerFd); mixerFd = NULL; return result; } return result; }
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; }
void AlsaPMO::SetVolume(int32 left, int32 right) { int err; snd_mixer_t *pMixer; err = snd_mixer_open(&pMixer, m_iCard, 0); if (err < 0) return; if (m_iChannel >= 0) { err = snd_mixer_group_read(pMixer, &m_group); if (err < 0) return; left = (int)((double)(m_group.max - m_group.min) * (double)left * 0.01) + m_group.min; right = (int)((double)(m_group.max - m_group.min) * (double)right * 0.01) + m_group.min; for (int chn = 0; chn <= SND_MIXER_CHN_LAST; chn++) { if (!(m_group.channels & (1<<chn))) continue; if (chn == 0) m_group.volume.values[chn] = left; else if (chn == 1) m_group.volume.values[chn] = right; else m_group.volume.values[chn] = (left + right) / 2; } snd_mixer_group_write(pMixer, &m_group); } snd_mixer_close(pMixer); }
void AlsaPMO::GetVolume(int32 &left, int32 &right) { int err; snd_mixer_t *pMixer = NULL; err = snd_mixer_open(&pMixer, m_iCard, 0); if (err != 0) { return; } if (m_iChannel >= 0) { err = snd_mixer_group_read(pMixer, &m_group); if (err < 0) return; } else return; snd_mixer_close(pMixer); left = (int)(((float)((m_group.volume.values[0] - m_group.min) * 100) / (float)(m_group.max - m_group.min)) + 0.5); right = (int)(((float)((m_group.volume.values[1] - m_group.min) * 100) / (float)(m_group.max - m_group.min)) + 0.5); }
static int mixer_init(char *name, char *iname) { int n, i; struct pollfd *fds; if (snd_mixer_open(&mixer, 0) < 0) { fprintf(stderr, "can't open mixer\n"); exit(1); } snd_mixer_attach(mixer, "default"); snd_mixer_selem_register(mixer, NULL, NULL); snd_mixer_load(mixer); get_element(name, 1, &ch[0]); get_element(iname, 0, &ch[1]); n = snd_mixer_poll_descriptors_count(mixer); fds = calloc(n, sizeof(struct pollfd)); snd_mixer_poll_descriptors(mixer, fds, n); for (i = 0; i < n; i++) { GIOChannel* channel = g_io_channel_unix_new( fds[i].fd ); g_io_add_watch(channel, G_IO_IN|G_IO_HUP, on_mixer_event, NULL); g_io_channel_unref(channel); } return 0; }
int NeoControl::openAlsaMixer() { system("alsactl -f /opt/qtmoko/etc/alsa-scenarios/gsmhandset.state restore"); int ret = 0; QString text(tr("Call volume settings\n\n")); if ((ret = snd_mixer_open(&mixerFd, 0)) < 0) { text += QString("snd_mixer_open error %1").arg(ret); goto err; } if ((ret = snd_mixer_attach(mixerFd, "default")) < 0) { text += QString("snd_mixer_attach error %1").arg(ret); goto err; } if ((ret = snd_mixer_selem_register(mixerFd, NULL, NULL)) < 0) { text += QString("snd_mixer_selem_register error %1").arg(ret); goto err; } if ((ret = snd_mixer_load(mixerFd)) < 0) { text += QString("snd_mixer_load error %1").arg(ret); goto err; } goto ok; err: if (mixerFd) snd_mixer_close(mixerFd); mixerFd = NULL; ok: label->setText(text); return ret; }
char* getvolume() { int sound_on; double normalized_volume; int err; snd_mixer_t *handle; snd_mixer_selem_id_t *sid; snd_mixer_open(&handle, 0); snd_mixer_attach(handle, soundcard); 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, soundelement); snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid); err = snd_mixer_selem_get_playback_switch(elem, channel, &sound_on); if (err < 0 || !sound_on) { snd_mixer_close(handle); /* return smprintf("\x9D "); */ return smprintf("Muted \x19 "); } normalized_volume = getnormvolume(elem); snd_mixer_close(handle); /* return smprintf("%.0f\x90 ", normalized_volume * 100); */ return smprintf("Vol %.0f%% \x19 ", normalized_volume * 100); }
void SetAlsaSwitchMute(const char* card, const char* selem_name) { // long min, max; snd_mixer_t *handle; snd_mixer_selem_id_t *sid; 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); int* muted; snd_mixer_selem_channel_id_t channel; snd_mixer_selem_get_playback_switch(elem,channel,muted); printf("Muted: %d\n",*muted); if (snd_mixer_selem_has_playback_switch(elem)) { snd_mixer_selem_set_playback_switch_all(elem, !*muted); } 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 AmeSystemSound::getMixer(snd_mixer_t **mixer, QString card) { char *dev; int err; dev = strdup(card.toAscii().data()); if ((err = snd_mixer_open(mixer, 0)) < 0) { qWarning("SoundOutput: Failed to open empty mixer: %s", snd_strerror(-err)); mixer = NULL; return -1; } if ((err = snd_mixer_attach(*mixer, dev)) < 0) { qWarning("SoundOutput: Attaching to mixer %s failed: %s", dev, snd_strerror(-err)); return -1; } if ((err = snd_mixer_selem_register(*mixer, NULL, NULL)) < 0) { qWarning("SoundOutput: Failed to register mixer: %s", snd_strerror(-err)); return -1; } if ((err = snd_mixer_load(*mixer)) < 0) { qWarning("SoundOutput: Failed to load mixer: %s", snd_strerror(-err)); return -1; } free(dev); return (*mixer != NULL); }
void mixerGuiAlsaMix::cardChanged( int card ) { #ifdef HAVE_ALSA channelSelect->clear(); // get the cards channels snd_mixer_t* alsaDev; snd_mixer_open( &alsaDev, 0); char device[16]; sprintf(device, "hw:%i", card); snd_mixer_attach(alsaDev, device ); snd_mixer_selem_register(alsaDev, NULL, NULL); snd_mixer_load(alsaDev); //load up the mixer snd_mixer_elem_t* mixerElem = snd_mixer_first_elem(alsaDev); while( mixerElem != snd_mixer_last_elem(alsaDev) ) { if(snd_mixer_selem_has_playback_volume(mixerElem) || snd_mixer_selem_has_capture_volume(mixerElem)) channelSelect->addItem( QString( snd_mixer_selem_get_name(mixerElem)), QVariant( snd_mixer_selem_get_name(mixerElem)) ); mixerElem=snd_mixer_elem_next( mixerElem ); } for(int i=0; i<= channelSelect->count(); i++ ) if( channelSelect->itemData(i) == settings["alsa_channel"].toString() ) channelSelect->setCurrentIndex( i ); #endif }
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; }
void OpenAudio() { int card = -1, dev = 0; snd_pcm_channel_info_t pi; snd_mixer_group_t group; snd_pcm_channel_params_t pp; snd_pcm_channel_setup_t setup; mixlen = 2*AUDIO_CHANNELS*AUDIO_SAMPLES; mixbuf = (uint8_t*)malloc(mixlen); if (mixbuf == NULL) return; memset(mixbuf, 0, mixlen); if ((snd_pcm_open_preferred(&pcm_handle, &card, &dev, SND_PCM_OPEN_PLAYBACK)) < 0) return; memset(&pi, 0, sizeof (pi)); pi.channel = SND_PCM_CHANNEL_PLAYBACK; if ((snd_pcm_plugin_info (pcm_handle, &pi)) < 0) return; memset(&pp, 0, sizeof (pp)); pp.mode = SND_PCM_MODE_BLOCK; pp.channel = SND_PCM_CHANNEL_PLAYBACK; pp.start_mode = SND_PCM_START_FULL; pp.stop_mode = SND_PCM_STOP_STOP; pp.buf.block.frag_size = pi.max_fragment_size; pp.buf.block.frags_max = -1; pp.buf.block.frags_min = 1; pp.format.interleave = 1; pp.format.rate = AUDIO_FREQ; pp.format.voices = AUDIO_CHANNELS; pp.format.format = SND_PCM_SFMT_S16_LE; if ((snd_pcm_plugin_params (pcm_handle, &pp)) < 0) return; snd_pcm_plugin_prepare(pcm_handle, SND_PCM_CHANNEL_PLAYBACK); memset (&setup, 0, sizeof(setup)); memset (&group, 0, sizeof(group)); setup.channel = SND_PCM_CHANNEL_PLAYBACK; setup.mixer_gid = &group.gid; if ((snd_pcm_plugin_setup (pcm_handle, &setup)) < 0) return; setup.buf.block.frag_size; if ((snd_mixer_open(&mixer_handle, card, setup.mixer_device)) < 0) return; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); pthread_create(&thread_handle, &attr, &BlackberryAudio::staticThreadProc, this); }
void* alsactl_open() { snd_mixer_t* handle; snd_mixer_open(&handle, 0); snd_mixer_attach(handle, card); snd_mixer_selem_register(handle, NULL, NULL); snd_mixer_load(handle); return handle; }
/* * 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; }
int AlsaMixer::load_handle() { int err; if (((err = snd_mixer_open(&this->handle, 0)) < 0) || ((err = snd_mixer_attach(this->handle, this->cardname.c_str())) < 0) || ((err = snd_mixer_selem_register(this->handle, NULL, NULL)) < 0) || ((err = snd_mixer_load(this->handle)) < 0)) return err; return 0; }
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); } } }
static int initialize_mixer_device(struct audio_info_struct *ai, char *error) { int sts; snd_mixer_t *mixer; char *mixerdev = "default"; const char *elemnam; snd_mixer_elem_t *mixerelem; sts = snd_mixer_open(&mixer, 0); if (sts) { if (error) { sprintf(error, "snd_mixer_open failed; %d\n", sts); } return 1; } if (mixer) { sts = snd_mixer_attach(mixer, mixerdev); if (sts) { if (error) { sprintf(error, "snd_mixer_attach: failed; %d\n", sts); } return 1; } sts = snd_mixer_selem_register(mixer, NULL, NULL); if (sts) { if (error) { sprintf(error, "snd_mixer_selem_register: failed; %d\n", sts); } return 1; } sts = snd_mixer_load(mixer); if (sts) { if (error) { sprintf(error, "snd_mixer_selem_register: failed; %d\n", sts); } return 1; } mixerelem = snd_mixer_first_elem(mixer); snd_mixer_set_callback(mixer, mixer_callback_func); while (mixerelem) { elemnam = snd_mixer_selem_get_name(mixerelem); if (strcasecmp(elemnam, "Master") == 0) { ai->vh = mixerelem; return 0; } mixerelem = snd_mixer_elem_next(mixerelem); } } return 1; }