static void laudio_alsa_set_volume(int vol) { int pcm_vol; if (!mixer_hdl || !vol_elem) return; snd_mixer_handle_events(mixer_hdl); if (!snd_mixer_selem_is_active(vol_elem)) return; switch (vol) { case 0: pcm_vol = vol_min; break; case 100: pcm_vol = vol_max; break; default: pcm_vol = vol_min + (vol * (vol_max - vol_min)) / 100; break; } DPRINTF(E_DBG, L_LAUDIO, "Setting PCM volume to %d (%d)\n", pcm_vol, vol); snd_mixer_selem_set_playback_volume_all(vol_elem, pcm_vol); }
snd_mixer_elem_t* AlsaMixer::get_first_playback_elem() { snd_mixer_elem_t* elem; for (elem = snd_mixer_first_elem(this->handle); elem; elem = snd_mixer_elem_next(elem)) { if (snd_mixer_selem_is_active(elem) && snd_mixer_selem_has_playback_volume(elem)) return elem; } }
snd_mixer_elem_t* AlsaMixer::get_playback_elem(const std::string name) { snd_mixer_elem_t* elem; for (elem = snd_mixer_first_elem(this->handle); elem; elem = snd_mixer_elem_next(elem)) { if (snd_mixer_selem_is_active(elem) && snd_mixer_selem_has_playback_volume(elem) && (name == snd_mixer_selem_get_name(elem))) return elem; } }
/* * The purpose of this function is to let the user to select * the input where he plugged his signals. * Now if user select "default", as device, we have to select the input * on the mixer of the card used by "default". * What is the card used by device "default" ? */ static void as_setup_input_combo (GtkWidget *combo, SoundParams *sparams) { snd_mixer_t *handle; int i ; snd_mixer_selem_id_t *sid; snd_mixer_elem_t *elem; snd_mixer_selem_id_alloca(&sid); char *devname; char name[32]; devname = sparams->device_name; if ( *sparams->indexstr == '-' ) { sprintf(name, "hw:%d", sparams->firstcard); devname = name; } handle = sound_open_mixer(devname); if ( handle == NULL ){ return ; } for (elem = snd_mixer_first_elem(handle); elem; elem = snd_mixer_elem_next(elem)) { snd_mixer_selem_get_id(elem, sid); if (! snd_mixer_selem_is_active(elem)) { continue; } const char *control_name = snd_mixer_selem_id_get_name(sid); // printf("Simple mixer control '%s',%i\n", control_name, snd_mixer_selem_id_get_index(sid)); if (snd_mixer_selem_is_enum_capture(elem)) { int items; char itemname[40]; app_free(sparams->control_name); sparams->control_name = app_strdup(control_name); items = snd_mixer_selem_get_enum_items(elem); // printf(" Items:"); for (i = 0; i < items; i++) { snd_mixer_selem_get_enum_item_name(elem, i, sizeof(itemname) - 1, itemname); // printf(" '%s'", itemname); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), itemname ); if ( i == sparams->input ) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i); } } // printf("\n"); } } snd_mixer_close(handle); return ; }
/* * Class: org_tritonus_lowlevel_alsa_AlsaMixerElement * Method: isActive * Signature: ()Z */ JNIEXPORT jboolean JNICALL Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_isActive (JNIEnv* env, jobject obj) { snd_mixer_elem_t* handle; int nReturn; if (debug_flag) { (void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_isActive(): begin\n"); } handle = getHandle(env, obj); nReturn = snd_mixer_selem_is_active(handle); if (debug_flag) { (void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_isActive(): end\n"); } return (jboolean) nReturn; }
void SoundPref::getMixerDevices(int mode) { snd_mixer_t *mixer; QComboBox *cmb; if (mode == modePlayback) cmb = ui.playbackMixerDeviceCmb; else { // TODO : capture mixer devices } cmb->clear(); int err; if ((err = snd->getMixer(&mixer, mixerCard)) < 0) { return; } snd_mixer_elem_t *elem; snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); int indx = 0; int current = -1; cmb->addItem(""); for (elem = snd_mixer_first_elem(mixer); elem; elem = snd_mixer_elem_next(elem)) { snd_mixer_selem_get_id(elem, sid); if (!snd_mixer_selem_is_active(elem)) continue; QString device = snd_mixer_selem_id_get_name(sid); if (mode == modePlayback) { if (snd_mixer_selem_has_playback_volume(elem)) cmb->addItem(device); } else if (mode == modeCapture) { // TODO: } else continue; if (device == mixerDevice) { current = indx; } indx ++; } if (current >= 0) cmb->setCurrentIndex(current+1); snd_mixer_close(mixer); }
INT32 PORT_GetPortCount(void* id) { PortMixer* portMixer; snd_mixer_elem_t *elem; TRACE0("> PORT_GetPortCount\n"); if (id == NULL) { // $$mp: Should become a descriptive error code (invalid handle). return -1; } portMixer = (PortMixer*) id; if (portMixer->numElems == 0) { for (elem = snd_mixer_first_elem(portMixer->mixer_handle); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; TRACE2("Simple mixer control '%s',%i\n", snd_mixer_selem_get_name(elem), snd_mixer_selem_get_index(elem)); if (snd_mixer_selem_has_playback_volume(elem)) { portMixer->elems[portMixer->numElems] = elem; portMixer->types[portMixer->numElems] = PORT_DST_UNKNOWN; portMixer->numElems++; } // to prevent buffer overflow if (portMixer->numElems >= MAX_ELEMS) { break; } /* If an element has both playback an capture volume, it is put into the arrays twice. */ if (snd_mixer_selem_has_capture_volume(elem)) { portMixer->elems[portMixer->numElems] = elem; portMixer->types[portMixer->numElems] = PORT_SRC_UNKNOWN; portMixer->numElems++; } // to prevent buffer overflow if (portMixer->numElems >= MAX_ELEMS) { break; } } } TRACE0("< PORT_GetPortCount\n"); return portMixer->numElems; }
void lamixer_mixer_init(char card[64]) { snd_mixer_elem_t *elem; gint err; snd_mixer_selem_id_alloca(&sid); err = snd_mixer_open (&mixer_handle, 0); err = snd_mixer_attach (mixer_handle, card); err = snd_mixer_selem_register (mixer_handle, NULL, NULL); err = snd_mixer_load (mixer_handle); for (elem = snd_mixer_first_elem(mixer_handle); elem; elem = snd_mixer_elem_next(elem)) { snd_mixer_selem_get_id(elem, sid); if (!snd_mixer_selem_is_active(elem)) continue; VolumeBoxes = g_list_append(VolumeBoxes, lamixer_volelem_new(elem)); } }
static void get_mixer_name(struct alsa_factory *af) { snd_mixer_t *handle; snd_mixer_elem_t *elem; if (snd_mixer_open(&handle, 0) < 0) return; if (snd_mixer_attach(handle, "default") < 0) { snd_mixer_close(handle); return; } if (snd_mixer_selem_register(handle, NULL, NULL) < 0) { snd_mixer_close(handle); return; } if (snd_mixer_load(handle) < 0) { snd_mixer_close(handle); return; } for (elem = snd_mixer_first_elem(handle); elem; elem = snd_mixer_elem_next(elem)) { if (snd_mixer_selem_is_active(elem) && snd_mixer_selem_has_playback_volume(elem)) { pj_ansi_strncpy(af->pb_mixer_name, snd_mixer_selem_get_name(elem), sizeof(af->pb_mixer_name)); TRACE_((THIS_FILE, "Playback mixer name: %s", af->pb_mixer_name)); break; } } snd_mixer_close(handle); }
static int alsa_mixer_init(alsa_mixer_t *mixer, char *card) { snd_mixer_selem_id_t *sid; snd_mixer_elem_t *elem; snd_mixer_selem_id_alloca(&sid); int err; if ((err = snd_mixer_open(&mixer->handle, 0)) < 0) { DEBUG("Mixer %s open error: %s", card, snd_strerror(err)); mixer->handle = NULL; return err; } if ((err = snd_mixer_attach(mixer->handle, card)) < 0) { DEBUG("Mixer %s local error: %s\n", card, snd_strerror(err)); snd_mixer_close(mixer->handle); mixer->handle = NULL; return err; } if ((err = snd_mixer_selem_register(mixer->handle, NULL, NULL)) < 0) { DEBUG("Mixer register error: %s", snd_strerror(err)); snd_mixer_close(mixer->handle); return err; } snd_mixer_set_callback(mixer->handle, on_mixer_event); err = snd_mixer_load(mixer->handle); if (err < 0) { DEBUG("Mixer %s load error: %s", card, snd_strerror(err)); snd_mixer_close(mixer->handle); return err; } for (elem = snd_mixer_first_elem(mixer->handle); elem; elem = snd_mixer_elem_next(elem)) { const char *name = NULL; snd_mixer_selem_get_id(elem, sid); if (!snd_mixer_selem_is_active(elem)) continue; name = snd_mixer_selem_id_get_name(sid); if(snd_mixer_selem_has_playback_volume(elem)) { if(strcmp(name, "Master") == 0) mixer->master = elem; else if(strcmp(name, "PCM") == 0) mixer->pcm = elem; } else if(snd_mixer_selem_has_capture_volume(elem) || snd_mixer_selem_has_capture_switch(elem)) { DEBUG("capture elem name = %s\n", name); /**make sure have one capture source if capture is available*/ if(NULL == mixer->mic) { mixer->mic = elem; } /**if have Microphone, replace it*/ if(strcmp(name, "Microphone") == 0) mixer->mic = elem; if(strcmp(name, "Capture") == 0) mixer->mic = elem; } } DEBUG("master = %x, pcm = %x, microphone = %x\n", mixer->master, mixer->pcm, mixer->mic); return 0; }
bool LapsusAlsaMixer::init() { int err; snd_ctl_t *ctl_handle; snd_ctl_card_info_t *hw_info; snd_ctl_card_info_alloca(&hw_info); if ((err = snd_ctl_open (&ctl_handle, "default", 0)) < 0) return false; if ((err = snd_ctl_card_info (ctl_handle, hw_info)) < 0) return false; snd_ctl_close (ctl_handle); if ((err = snd_mixer_open (&_handle, 0)) < 0) return false; if ((err = snd_mixer_attach (_handle, "default")) < 0) return false; if ((err = snd_mixer_selem_register (_handle, 0, 0)) < 0) return false; if ((err = snd_mixer_load (_handle)) < 0) return false; // printf("Card name: '%s'\n", snd_ctl_card_info_get_name(hw_info)); // printf("Device name: '%s'\n", snd_ctl_card_info_get_mixername(hw_info)); snd_mixer_elem_t *elem; snd_mixer_selem_id_t *tmp_sid = 0; for (elem = snd_mixer_first_elem(_handle); elem; elem = snd_mixer_elem_next(elem)) { if (snd_mixer_selem_is_active(elem)) { if (!tmp_sid) tmp_sid = (snd_mixer_selem_id_t*) malloc(snd_mixer_selem_id_sizeof()); snd_mixer_selem_get_id(elem, tmp_sid); const char *name = snd_mixer_selem_id_get_name( tmp_sid ); if (!strcasecmp(name, "Headphone")) { if (sids[ID_HP]) delete sids[ID_HP]; sids[ID_HP] = new SIDInfo(_handle, tmp_sid); tmp_sid = 0; } else if (!strcasecmp(name, "Front")) { if (sids[ID_F]) delete sids[ID_F]; sids[ID_F] = new SIDInfo(_handle, tmp_sid); tmp_sid = 0; } else if (!strcasecmp(name, "Master")) { if (sids[ID_M]) delete sids[ID_M]; sids[ID_M] = new SIDInfo(_handle, tmp_sid); tmp_sid = 0; } } } if (tmp_sid) free(tmp_sid); bool foundAny = false; for (int i = 0; i < ID_LAST; ++i) { if (sids[i]) { if (sids[i]->hasMute) { foundAny = true; } if (sids[i]->hasVolume) { foundAny = true; long range = sids[i]->max - sids[i]->min; if (range > _globalMax) _globalMax = range; } } } if (_globalMax > INT_MAX) _globalMax = INT_MAX; if (!foundAny) return false; for (int i = 0; i < ID_LAST; ++i) { if (sids[i]) sids[i]->setGlobalMax(_globalMax); } if ((_count = snd_mixer_poll_descriptors_count(_handle)) < 0) return false; _fds = (struct pollfd*) calloc(_count, sizeof(struct pollfd)); if (!_fds) return false; if ((err = snd_mixer_poll_descriptors(_handle, _fds, _count)) < 0) return false; if (err != _count) return 0; _sns = new QSocketNotifier*[_count]; for ( int i = 0; i < _count; ++i ) { _sns[i] = new QSocketNotifier(_fds[i].fd, QSocketNotifier::Read); connect(_sns[i], SIGNAL(activated(int)), this, SLOT(alsaEvent())); } // To read our current parameters. Signals will be emited, but those signals // are not yet connected to anything - this method is called from constructor // only. getVolume(); mixerIsMuted(); return true; }
/** * Constructor of MMSAudioCtrl class. * * The first instance of this class assigns * an audio channel, attaches to the mixer * of the sound card and gets the current * settings. * * @param channel [in] audio channel */ MMSAudioCtrl::MMSAudioCtrl(string channel) { int err; if(this->channel=="") { this->channel=channel; } if (!this->handle) { /* open the mixer */ if ((err = snd_mixer_open(&(this->handle), 0)) < 0) throw MMSAudioCtrlError(err,"snd_mixer_open() failed"); /* attach the card */ if ((err = snd_mixer_attach(this->handle, this->card.c_str())) < 0) { snd_mixer_close(this->handle); throw MMSAudioCtrlError(err,"snd_mixer_attach() with card = '" + this->card + "' failed"); } /* register */ if ((err = snd_mixer_selem_register(this->handle, NULL, NULL)) < 0) { snd_mixer_close(this->handle); string s = snd_strerror(err); throw MMSAudioCtrlError(err,"snd_mixer_selem_register() failed with '" + s + "'"); } /* load */ if ((err = snd_mixer_load(this->handle)) < 0) { snd_mixer_close(this->handle); string s = snd_strerror(err); throw MMSAudioCtrlError(err,"snd_mixer_load() failed with '" + s + "'"); } } if (!this->elem) { /* searching for the first active element */ for (this->elem = snd_mixer_first_elem(this->handle); this->elem; this->elem = snd_mixer_elem_next(this->elem)) { string mix = snd_mixer_selem_get_name(this->elem); DEBUGMSG("MMSMedia", "got mixer channel: %s", mix.c_str()); /* is active? */ if (!snd_mixer_selem_is_active(this->elem)) continue; /* has playback volume? */ if (!snd_mixer_selem_has_playback_volume(this->elem)) continue; if (this->channel!="") { if(strcmp(this->channel.c_str(),snd_mixer_selem_get_name(this->elem))!=0) continue; } /* we have found our channel*/ /* get volume range */ snd_mixer_selem_get_playback_volume_range(this->elem, &(this->pmin), &(this->pmax)); /* check if this elem is mutable */ isSwitchable = (snd_mixer_selem_has_playback_switch(elem) > 0); /* get the current volume settings */ getVolume(); return; } throw MMSAudioCtrlError(0,"no element found"); } }
ALSAMixer::ALSAMixer(const char *sndcard) { int err; LOGI(" Init ALSAMIXER for SNDCARD : %s",sndcard); mixerMasterProp = ALSA_PROP(AudioSystem::DEVICE_OUT_ALL, "master", "PCM", "Capture"); mixerProp = { ALSA_PROP(AudioSystem::DEVICE_OUT_EARPIECE, "earpiece", "Earpiece", "Capture"), ALSA_PROP(AudioSystem::DEVICE_OUT_SPEAKER, "speaker", "Speaker", ""), ALSA_PROP(AudioSystem::DEVICE_OUT_WIRED_HEADSET, "headset", "Headphone", "Capture"), ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_SCO, "bluetooth.sco", "Bluetooth", "Bluetooth Capture"), ALSA_PROP(AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP, "bluetooth.a2dp", "Bluetooth A2DP", "Bluetooth A2DP Capture"), ALSA_PROP(static_cast<AudioSystem::audio_devices>(0), "", NULL, NULL) }; initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], sndcard); initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], sndcard); snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) { mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t; property_get (mixerMasterProp[i].propName, info->name, mixerMasterProp[i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found"); for (int j = 0; mixerProp[j][i].device; j++) { mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t; property_get (mixerProp[j][i].propName, info->name, mixerProp[j][i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found"); } } LOGV("mixer initialized."); }
/****************************************************************************** * setMixerVolume *****************************************************************************/ static Int setMixerVolume (Sound_Attrs *attrs) { Int status; snd_mixer_t *rcMixer; snd_mixer_elem_t *elem; snd_mixer_selem_id_t *sid; snd_mixer_selem_id_malloc (&sid); /* Open the mixer device */ status = snd_mixer_open (&rcMixer, 0); if ( status<0 ) { Dmai_err2 ("Failed to open mixer on %s (%s)\n", AUDIO_MIXER, snd_strerror (status)); return Dmai_EFAIL; } /* Attach mixer with sound card */ status = snd_mixer_attach (rcMixer,AUDIO_MIXER); if (status <0) { Dmai_err2 ("Failed to attach mixer on %s (%s)\n", AUDIO_MIXER, snd_strerror (status)); return Dmai_EFAIL; } /* Register mixer with selected elements */ status = snd_mixer_selem_register (rcMixer, NULL, NULL); if (status <0) { Dmai_err2 ("Failed to register mixer on %s (%s)\n", AUDIO_MIXER, snd_strerror (status)); return Dmai_EFAIL; } /* Load mixer */ status = snd_mixer_load (rcMixer); if (status <0) { Dmai_err2 ("Failed to load mixer on %s (%s)\n", AUDIO_MIXER, snd_strerror (status)); return Dmai_EFAIL; } for (elem = snd_mixer_first_elem (rcMixer); elem; elem=snd_mixer_elem_next(elem)) { snd_mixer_selem_get_id(elem,sid); if (!snd_mixer_selem_is_active(elem)) continue; if (attrs->mode == Sound_Mode_OUTPUT || attrs->mode == Sound_Mode_FULLDUPLEX) { if (snd_mixer_selem_has_playback_channel(elem, SND_MIXER_SCHN_FRONT_LEFT)) snd_mixer_selem_set_playback_volume (elem, SND_MIXER_SCHN_FRONT_LEFT,attrs->leftGain); if (snd_mixer_selem_has_playback_channel(elem, SND_MIXER_SCHN_FRONT_RIGHT)) snd_mixer_selem_set_playback_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT,attrs->rightGain); } if (attrs->mode == Sound_Mode_INPUT || attrs->mode == Sound_Mode_FULLDUPLEX) { if (snd_mixer_selem_has_capture_channel(elem, SND_MIXER_SCHN_FRONT_LEFT)) snd_mixer_selem_set_capture_volume (elem, SND_MIXER_SCHN_FRONT_LEFT,attrs->leftGain); if (snd_mixer_selem_has_capture_channel(elem, SND_MIXER_SCHN_FRONT_RIGHT)) snd_mixer_selem_set_capture_volume (elem, SND_MIXER_SCHN_FRONT_RIGHT,attrs->rightGain); } } snd_mixer_selem_id_free (sid); snd_mixer_close (rcMixer); return Dmai_EOK; }
ALSAMixer::ALSAMixer() { int err; initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidOut"); initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidIn"); snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) { mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t; property_get (mixerMasterProp[i].propName, info->name, mixerMasterProp[i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found"); for (int j = 0; mixerProp[j][i].device; j++) { mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t; property_get (mixerProp[j][i].propName, info->name, mixerProp[j][i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); info->volume = info->max; setVol[i] (elem, info->volume); if (i == SND_PCM_STREAM_PLAYBACK && snd_mixer_selem_has_playback_switch (elem)) snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } LOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found"); } } #ifdef AUDIO_MODEM_TI ALSAControl control("hw:00"); status_t error; #if 0//(WORKAROUND_AVOID_VOICE_VOLUME_SATURATION == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee LOGV("Workaround: Voice call max volume limited to: %d", WORKAROUND_MAX_VOICE_VOLUME); #endif #if 0//(WORKAROUND_SET_VOICE_VOLUME_MIN == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee LOGV("Workaround: Voice call min volume limited to: %d", WORKAROUND_MIN_VOICE_VOLUME); #endif for (int i = 0; inCallVolumeProp[i].device; i++) { mixer_incall_vol_info_t *info = inCallVolumeProp[i].mInfo = new mixer_incall_vol_info_t; property_get (inCallVolumeProp[i].propName, info->name, inCallVolumeProp[i].propDefault); error = control.get(info->name, info->volume, 0); error = control.getmin(info->name, info->min); error = control.getmax(info->name, info->max); #if 0//(WORKAROUND_AVOID_VOICE_VOLUME_SATURATION == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee info->max = WORKAROUND_MAX_VOICE_VOLUME; #endif #if 0//(WORKAROUND_SET_VOICE_VOLUME_MIN == 1) //[LG_FW_P970_MERGE] - jungsoo1221.lee info->min = WORKAROUND_MIN_VOICE_VOLUME; #endif if (error < 0) { LOGV("Mixer: In Call Volume '%s': not found", info->name); } else { LOGV("Mixer: In Call Volume '%s': vol. %d min. %d max. %d", info->name, info->volume, info->min, info->max); } } #endif LOGV("mixer initialized."); }
int play_sound(char* filename,int rate,int bits,int channel,int order) { long loops; int rc,size,dir; snd_pcm_t *handle; snd_pcm_hw_params_t *params; snd_pcm_uframes_t frames,periodsize; snd_mixer_t *mixer; snd_mixer_elem_t *pcm_element; char *buffer; unsigned int val; FILE *fp = fopen(filename,"rb"); rc = snd_pcm_open(&handle,"default",SND_PCM_STREAM_PLAYBACK,0); snd_pcm_hw_params_alloca(¶ms); snd_pcm_hw_params_any(handle,params); snd_pcm_hw_params_set_access(handle,params,SND_PCM_ACCESS_RW_INTERLEAVED); switch(order){ case 1: snd_pcm_hw_params_set_format(handle,params,SND_PCM_FORMAT_S16_LE); break; case 2: snd_pcm_hw_params_set_format(handle,params,SND_PCM_FORMAT_S16_BE); break; defualt: break; } snd_pcm_hw_params_set_channels(handle,params,channel); val = rate; snd_pcm_hw_params_set_rate_near(handle,params,&val,0); snd_pcm_hw_params_get_buffer_size_max(params,&frames); frames = frames < ALSA_MAX_BUF_SIZE? frames:ALSA_MAX_BUF_SIZE; rc = snd_pcm_hw_params_set_buffer_size_near(handle,params,&frames); snd_pcm_hw_params_get_period_size_min(params,&periodsize,NULL); if(!periodsize){ periodsize=size/4; } rc = snd_pcm_hw_params_set_period_size_near(handle,params,&periodsize,NULL); rc = snd_pcm_hw_params(handle,params); snd_mixer_open(&mixer,0); snd_mixer_attach(mixer,"default"); snd_mixer_selem_register(mixer,NULL,NULL); snd_mixer_load(mixer); for(pcm_element = snd_mixer_first_elem(mixer);pcm_element;pcm_element=snd_mixer_elem_next(pcm_element)) { if(snd_mixer_elem_get_type(pcm_element)==SND_MIXER_ELEM_SIMPLE && snd_mixer_selem_is_active(pcm_element)) { if(!strcmp(snd_mixer_selem_get_name(pcm_element),"Master")) { snd_mixer_selem_set_playback_volume_range(pcm_element,0,100); snd_mixer_selem_set_playback_volume_all(pcm_element,(long)100); } } } buffer = (char*)malloc(size); while(1) { rc = fread(buffer,1,size,fp); if(0== rc) break; while((rc = snd_pcm_writei(handle,buffer,size))<0) { usleep(200); if(-EPIPE == rc) snd_pcm_prepare(handle); else if(0 > rc) printf("error fomr writei\n"); } } snd_pcm_drain(handle); snd_pcm_close(handle); free(buffer); snd_mixer_close(mixer); fclose(fp); return 0; }
ALSAMixer::ALSAMixer() { int err; initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidOut"); initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidIn"); snd_mixer_selem_id_t *sid; snd_mixer_selem_id_alloca(&sid); for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) { if (!mMixer[i]) continue; mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t; property_get (mixerMasterProp[i].propName, info->name, mixerMasterProp[i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); //info->volume = info->max; //setVol[i] (elem, info->volume); //if (i == SND_PCM_STREAM_PLAYBACK && // snd_mixer_selem_has_playback_switch (elem)) // snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } ALOGV("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found"); for (int j = 0; mixerProp[j][i].device; j++) { mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t; property_get (mixerProp[j][i].propName, info->name, mixerProp[j][i].propDefault); for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]); elem; elem = snd_mixer_elem_next(elem)) { if (!snd_mixer_selem_is_active(elem)) continue; snd_mixer_selem_get_id(elem, sid); // Find PCM playback volume control element. const char *elementName = snd_mixer_selem_id_get_name(sid); if (info->elem == NULL && strcmp(elementName, info->name) == 0 && hasVolume[i] (elem)) { info->elem = elem; getVolumeRange[i] (elem, &info->min, &info->max); //info->volume = info->max; //setVol[i] (elem, info->volume); //if (i == SND_PCM_STREAM_PLAYBACK && // snd_mixer_selem_has_playback_switch (elem)) // snd_mixer_selem_set_playback_switch_all (elem, 1); break; } } ALOGV("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found"); } } ALOGV("mixer initialized."); }
static void alsaOpenDevice(void) { int err; snd_mixer_elem_t *current; alsa_mixers_n=0; if (alsa_pcm) { #ifdef ALSA_DEBUG fprintf(stderr, "ALSA snd_pcm_drain(alsa_pcm) = "); #endif err=snd_pcm_drain(alsa_pcm); #ifdef ALSA_DEBUG if (err) fprintf(stderr, "failed: %s\n", snd_strerror(-err)); else fprintf(stderr, "ok\n"); fprintf(stderr, "ALSA snd_pcm_close(alsa_pcm) = "); #endif err=snd_pcm_close(alsa_pcm); #ifdef ALSA_DEBUG if (err) fprintf(stderr, "failed: %s\n", snd_strerror(-err)); else fprintf(stderr, "ok\n"); #endif alsa_pcm=NULL; } if (mixer) { #ifdef ALSA_DEBUG fprintf(stderr, "ALSA snd_mixer_close(mixer) = "); #endif err=snd_mixer_close(mixer); #ifdef ALSA_DEBUG if (err) fprintf(stderr, "failed: %s\n", snd_strerror(-err)); else fprintf(stderr, "ok\n"); #endif mixer=NULL; } #ifdef ALSA_DEBUG fprintf(stderr, "ALSA snd_pcm_open(&alsa_pcm, device = \"%s\", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK) = ", alsaCardName); #endif if ((err=snd_pcm_open(&alsa_pcm, alsaCardName, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK))<0) { #ifdef ALSA_DEBUG fprintf(stderr, "failed: %s\n", snd_strerror(-err)); #endif fprintf(stderr, "ALSA: failed to open pcm device (%s): %s\n", alsaCardName, snd_strerror(-err)); alsa_pcm=NULL; return; } #ifdef ALSA_DEBUG fprintf(stderr, "ok\n"); #endif if (!strlen(alsaMixerName)) return; #ifdef ALSA_DEBUG fprintf(stderr, "ALSA snd_mixer_open(&mixer, 0) = "); #endif if ((err=snd_mixer_open(&mixer, 0))<0) { #ifdef ALSA_DEBUG fprintf(stderr, "failed: %s\n", snd_strerror(-err)); #endif fprintf(stderr, "ALSA: snd_mixer_open() failed: %s\n", snd_strerror(-err)); return; } #ifdef ALSA_DEBUG fprintf(stderr, "ok\n"); fprintf(stderr, "ALSA snd_mixer_attach(mixer, device = \"%s\") = ", alsaMixerName); #endif if ((err=snd_mixer_attach(mixer, alsaMixerName))<0) { #ifdef ALSA_DEBUG fprintf(stderr, "failed: %s\n", snd_strerror(-err)); #endif fprintf(stderr, "ALSA: snd_mixer_attach() failed: %s\n", snd_strerror(-err)); #ifdef ALSA_DEBUG fprintf(stderr, "ALSA ans_mixer_close(mixer) = "); #endif err=snd_mixer_close(mixer); #ifdef ALSA_DEBUG if (err) fprintf(stderr, "failed: %s\n", snd_strerror(-err)); else fprintf(stderr, "ok\n"); #endif mixer=NULL; return; } #ifdef ALSA_DEBUG fprintf(stderr, "ok\n"); fprintf(stderr, "ALSA snd_mixer_selem_register(mixer, NULL, NULL) = "); #endif if ((err=snd_mixer_selem_register(mixer, NULL, NULL))<0) { #ifdef ALSA_DEBUG fprintf(stderr, "failed: %s\n", snd_strerror(-err)); #endif fprintf(stderr, "ALSA: snd_mixer_selem_register() failed: %s\n", snd_strerror(-err)); #ifdef ALSA_DEBUG fprintf(stderr, "ALSA snd_mixer_close(mixer) = "); #endif err=snd_mixer_close(mixer); #ifdef ALSA_DEBUG if (err) fprintf(stderr, "failed: %s\n", snd_strerror(-err)); else fprintf(stderr, "ok\n"); #endif mixer=NULL; return; } #ifdef ALSA_DEBUG fprintf(stderr, "ok\n"); fprintf(stderr, "ALSA snd_mixer_load(mixer) = "); #endif if ((err=snd_mixer_load(mixer))<0) { #ifdef ALSA_DEBUG fprintf(stderr, "failed: %s\n", snd_strerror(-err)); #endif fprintf(stderr, "ALSA: snd_mixer_load() failed: %s\n", snd_strerror(-err)); #ifdef ALSA_DEBUG fprintf(stderr, "ALSA snd_mixer_close(mixer) = "); #endif err=snd_mixer_close(mixer); #ifdef ALSA_DEBUG if (err) fprintf(stderr, "failed: %s\n", snd_strerror(-err)); else fprintf(stderr, "ok\n"); #endif mixer=NULL; return; } #ifdef ALSA_DEBUG fprintf(stderr, "ok\n"); #endif current = snd_mixer_first_elem(mixer); while (current) { if (snd_mixer_selem_is_active(current) && snd_mixer_selem_has_playback_volume(current) && (alsa_mixers_n<MAX_ALSA_MIXER)) { long int a, b; long min, max; snd_mixer_selem_get_playback_volume(current, SND_MIXER_SCHN_FRONT_LEFT, &a); snd_mixer_selem_get_playback_volume(current, SND_MIXER_SCHN_FRONT_RIGHT, &b); mixer_entries[alsa_mixers_n].val=(a+b)>>1; snd_mixer_selem_get_playback_volume_range(current, &min, &max); mixer_entries[alsa_mixers_n].min=min; mixer_entries[alsa_mixers_n].max=max; mixer_entries[alsa_mixers_n].step=1; mixer_entries[alsa_mixers_n].log=0; mixer_entries[alsa_mixers_n].name=snd_mixer_selem_get_name(current); alsa_mixers_n++; } current = snd_mixer_elem_next(current); }