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