| /* AudioHardwareALSA.cpp |
| ** |
| ** Copyright 2008-2010 Wind River Systems |
| ** Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved. |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #include <errno.h> |
| #include <stdarg.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <dlfcn.h> |
| #include <math.h> |
| |
| #define LOG_TAG "AudioHardwareALSA" |
| //#define LOG_NDEBUG 0 |
| #define LOG_NDDEBUG 0 |
| #include <utils/Log.h> |
| #include <utils/String8.h> |
| #include <sys/prctl.h> |
| #include <sys/resource.h> |
| #include <sys/poll.h> |
| #include <sys/ioctl.h> |
| #include <cutils/properties.h> |
| #include <media/AudioRecord.h> |
| #include <hardware_legacy/power.h> |
| |
| #include "AudioHardwareALSA.h" |
| #ifdef QCOM_USBAUDIO_ENABLED |
| #include "AudioUsbALSA.h" |
| #endif |
| #include "AudioUtil.h" |
| |
| extern "C" |
| { |
| // |
| // Function for dlsym() to look up for creating a new AudioHardwareInterface. |
| // |
| android_audio_legacy::AudioHardwareInterface *createAudioHardware(void) { |
| return android_audio_legacy::AudioHardwareALSA::create(); |
| } |
| #ifdef QCOM_ACDB_ENABLED |
| static int (*acdb_init)(); |
| static void (*acdb_deallocate)(); |
| #endif |
| #ifdef QCOM_CSDCLIENT_ENABLED |
| static int (*csd_client_init)(); |
| static int (*csd_client_deinit)(); |
| static int (*csd_start_playback)(); |
| static int (*csd_stop_playback)(); |
| #endif |
| } // extern "C" |
| |
| namespace android_audio_legacy |
| { |
| |
| // ---------------------------------------------------------------------------- |
| |
| AudioHardwareInterface *AudioHardwareALSA::create() { |
| return new AudioHardwareALSA(); |
| } |
| |
| AudioHardwareALSA::AudioHardwareALSA() : |
| mALSADevice(0),mVoipStreamCount(0),mVoipBitRate(0) |
| ,mCallState(0),mAcdbHandle(NULL),mCsdHandle(NULL),mMicMute(0) |
| { |
| FILE *fp; |
| char soundCardInfo[200]; |
| hw_module_t *module; |
| char platform[128], baseband[128]; |
| int err = hw_get_module(ALSA_HARDWARE_MODULE_ID, |
| (hw_module_t const**)&module); |
| int codec_rev = 2; |
| ALOGD("hw_get_module(ALSA_HARDWARE_MODULE_ID) returned err %d", err); |
| if (err == 0) { |
| hw_device_t* device; |
| err = module->methods->open(module, ALSA_HARDWARE_NAME, &device); |
| if (err == 0) { |
| mALSADevice = (alsa_device_t *)device; |
| mALSADevice->init(mALSADevice, mDeviceList); |
| mCSCallActive = 0; |
| mVolteCallActive = 0; |
| mIsFmActive = 0; |
| mDevSettingsFlag = 0; |
| #ifdef QCOM_USBAUDIO_ENABLED |
| mAudioUsbALSA = new AudioUsbALSA(); |
| musbPlaybackState = 0; |
| musbRecordingState = 0; |
| #endif |
| #ifdef USES_FLUENCE_INCALL |
| mDevSettingsFlag |= TTY_OFF | DMIC_FLAG; |
| #else |
| mDevSettingsFlag |= TTY_OFF; |
| #endif |
| mBluetoothVGS = false; |
| mFusion3Platform = false; |
| |
| #ifdef QCOM_ACDB_ENABLED |
| mAcdbHandle = ::dlopen("/system/lib/libacdbloader.so", RTLD_NOW); |
| if (mAcdbHandle == NULL) { |
| ALOGE("AudioHardware: DLOPEN not successful for ACDBLOADER"); |
| } else { |
| ALOGD("AudioHardware: DLOPEN successful for ACDBLOADER"); |
| acdb_init = (int (*)())::dlsym(mAcdbHandle,"acdb_loader_init_ACDB"); |
| if (acdb_init == NULL) { |
| ALOGE("dlsym:Error:%s Loading acdb_loader_init_ACDB", dlerror()); |
| }else { |
| acdb_init(); |
| acdb_deallocate = (void (*)())::dlsym(mAcdbHandle,"acdb_loader_deallocate_ACDB"); |
| } |
| } |
| #endif |
| |
| #ifdef QCOM_CSDCLIENT_ENABLED |
| mCsdHandle = ::dlopen("/system/lib/libcsd-client.so", RTLD_NOW); |
| if (mCsdHandle == NULL) { |
| ALOGE("AudioHardware: DLOPEN not successful for CSD CLIENT"); |
| } else { |
| ALOGD("AudioHardware: DLOPEN successful for CSD CLIENT"); |
| csd_client_init = (int (*)())::dlsym(mCsdHandle,"csd_client_init"); |
| csd_client_deinit = (int (*)())::dlsym(mCsdHandle,"csd_client_deinit"); |
| csd_start_playback = (int (*)())::dlsym(mCsdHandle,"csd_client_start_playback"); |
| csd_stop_playback = (int (*)())::dlsym(mCsdHandle,"csd_client_stop_playback"); |
| |
| if (csd_client_init == NULL) { |
| ALOGE("dlsym: Error:%s Loading csd_client_init", dlerror()); |
| } else { |
| csd_client_init(); |
| } |
| } |
| mALSADevice->setCsdHandle(mCsdHandle); |
| #endif |
| if((fp = fopen("/proc/asound/cards","r")) == NULL) { |
| ALOGE("Cannot open /proc/asound/cards file to get sound card info"); |
| } else { |
| while((fgets(soundCardInfo, sizeof(soundCardInfo), fp) != NULL)) { |
| ALOGV("SoundCardInfo %s", soundCardInfo); |
| if (strstr(soundCardInfo, "msm8960-tabla1x-snd-card")) { |
| codec_rev = 1; |
| break; |
| } else if (strstr(soundCardInfo, "msm-snd-card")) { |
| codec_rev = 2; |
| break; |
| } else if (strstr(soundCardInfo, "msm8930-sitar-snd-card")) { |
| codec_rev = 3; |
| break; |
| } |
| } |
| fclose(fp); |
| } |
| |
| if (codec_rev == 1) { |
| ALOGV("Detected tabla 1.x sound card"); |
| snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm"); |
| } else if (codec_rev == 3) { |
| ALOGV("Detected sitar 1.x sound card"); |
| snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm_Sitar"); |
| } else { |
| property_get("ro.board.platform", platform, ""); |
| property_get("ro.baseband", baseband, ""); |
| if (!strcmp("msm8960", platform) && !strcmp("mdm", baseband)) { |
| ALOGV("Detected Fusion tabla 2.x"); |
| mFusion3Platform = true; |
| snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm_2x_Fusion3"); |
| } else { |
| ALOGV("Detected tabla 2.x sound card"); |
| snd_use_case_mgr_open(&mUcMgr, "snd_soc_msm_2x"); |
| } |
| } |
| |
| if (mUcMgr < 0) { |
| ALOGE("Failed to open ucm instance: %d", errno); |
| } else { |
| ALOGI("ucm instance opened: %u", (unsigned)mUcMgr); |
| mUcMgr->acdb_handle = NULL; |
| #ifdef QCOM_ACDB_ENABLED |
| if (mAcdbHandle) { |
| mUcMgr->acdb_handle = static_cast<void*> (mAcdbHandle); |
| if (mFusion3Platform) |
| mUcMgr->isFusion3Platform = true; |
| else |
| mUcMgr->isFusion3Platform = false; |
| } |
| #endif |
| } |
| } else { |
| ALOGE("ALSA Module could not be opened!!!"); |
| } |
| } else { |
| ALOGE("ALSA Module not found!!!"); |
| } |
| } |
| |
| AudioHardwareALSA::~AudioHardwareALSA() |
| { |
| if (mUcMgr != NULL) { |
| ALOGV("closing ucm instance: %u", (unsigned)mUcMgr); |
| snd_use_case_mgr_close(mUcMgr); |
| } |
| if (mALSADevice) { |
| mALSADevice->common.close(&mALSADevice->common); |
| } |
| for(ALSAHandleList::iterator it = mDeviceList.begin(); |
| it != mDeviceList.end(); ++it) { |
| it->useCase[0] = 0; |
| mDeviceList.erase(it); |
| } |
| #ifdef QCOM_ACDB_ENABLED |
| if (acdb_deallocate == NULL) { |
| ALOGE("dlsym: Error:%s Loading acdb_deallocate_ACDB", dlerror()); |
| } else { |
| acdb_deallocate(); |
| } |
| if (mAcdbHandle) { |
| ::dlclose(mAcdbHandle); |
| mAcdbHandle = NULL; |
| } |
| #endif |
| #ifdef QCOM_USBAUDIO_ENABLED |
| delete mAudioUsbALSA; |
| #endif |
| |
| #ifdef QCOM_CSDCLEINT_ENABLED |
| if (mCsdHandle) { |
| if (csd_client_deinit == NULL) { |
| ALOGE("dlsym: Error:%s Loading csd_client_deinit", dlerror()); |
| } else { |
| csd_client_deinit(); |
| } |
| ::dlclose(mCsdHandle); |
| mCsdHandle = NULL; |
| } |
| #endif |
| } |
| |
| status_t AudioHardwareALSA::initCheck() |
| { |
| if (!mALSADevice) |
| return NO_INIT; |
| |
| return NO_ERROR; |
| } |
| |
| status_t AudioHardwareALSA::setVoiceVolume(float v) |
| { |
| ALOGV("setVoiceVolume(%f)\n", v); |
| if (v < 0.0) { |
| ALOGW("setVoiceVolume(%f) under 0.0, assuming 0.0\n", v); |
| v = 0.0; |
| } else if (v > 1.0) { |
| ALOGW("setVoiceVolume(%f) over 1.0, assuming 1.0\n", v); |
| v = 1.0; |
| } |
| |
| int newMode = mode(); |
| ALOGV("setVoiceVolume newMode %d",newMode); |
| int vol = lrint(v * 100.0); |
| |
| // Voice volume levels from android are mapped to driver volume levels as follows. |
| // 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0 |
| // So adjust the volume to get the correct volume index in driver |
| vol = 100 - vol; |
| |
| if (mALSADevice) { |
| if(newMode == AudioSystem::MODE_IN_COMMUNICATION) { |
| mALSADevice->setVoipVolume(vol); |
| } else if (newMode == AudioSystem::MODE_IN_CALL){ |
| if (mCSCallActive == CS_ACTIVE) |
| mALSADevice->setVoiceVolume(vol); |
| if (mVolteCallActive == IMS_ACTIVE) |
| mALSADevice->setVoLTEVolume(vol); |
| } |
| } |
| |
| return NO_ERROR; |
| } |
| |
| #ifdef QCOM_FM_ENABLED |
| status_t AudioHardwareALSA::setFmVolume(float value) |
| { |
| status_t status = NO_ERROR; |
| |
| int vol; |
| |
| if (value < 0.0) { |
| ALOGW("setFmVolume(%f) under 0.0, assuming 0.0\n", value); |
| value = 0.0; |
| } else if (value > 1.0) { |
| ALOGW("setFmVolume(%f) over 1.0, assuming 1.0\n", value); |
| value = 1.0; |
| } |
| vol = lrint((value * 0x2000) + 0.5); |
| |
| ALOGV("setFmVolume(%f)\n", value); |
| ALOGV("Setting FM volume to %d (available range is 0 to 0x2000)\n", vol); |
| |
| mALSADevice->setFmVolume(vol); |
| |
| return status; |
| } |
| #endif |
| |
| status_t AudioHardwareALSA::setMasterVolume(float volume) |
| { |
| return NO_ERROR; |
| } |
| |
| status_t AudioHardwareALSA::setMode(int mode) |
| { |
| status_t status = NO_ERROR; |
| |
| if (mode != mMode) { |
| status = AudioHardwareBase::setMode(mode); |
| } |
| |
| if (mode == AudioSystem::MODE_IN_CALL) { |
| mCallState = CS_ACTIVE; |
| }else if (mode == AudioSystem::MODE_NORMAL) { |
| mCallState = 0; |
| } |
| |
| return status; |
| } |
| |
| status_t AudioHardwareALSA::setParameters(const String8& keyValuePairs) |
| { |
| AudioParameter param = AudioParameter(keyValuePairs); |
| String8 key; |
| String8 value; |
| status_t status = NO_ERROR; |
| int device; |
| int btRate; |
| int state; |
| ALOGV("setParameters() %s", keyValuePairs.string()); |
| |
| key = String8(TTY_MODE_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| mDevSettingsFlag &= TTY_CLEAR; |
| if (value == "tty_full") { |
| mDevSettingsFlag |= TTY_FULL; |
| } else if (value == "tty_hco") { |
| mDevSettingsFlag |= TTY_HCO; |
| } else if (value == "tty_vco") { |
| mDevSettingsFlag |= TTY_VCO; |
| } else { |
| mDevSettingsFlag |= TTY_OFF; |
| } |
| ALOGI("Changed TTY Mode=%s", value.string()); |
| mALSADevice->setFlags(mDevSettingsFlag); |
| if(mMode != AudioSystem::MODE_IN_CALL){ |
| return NO_ERROR; |
| } |
| doRouting(0); |
| } |
| |
| key = String8(FLUENCE_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| if (value == "quadmic") { |
| mDevSettingsFlag |= QMIC_FLAG; |
| mDevSettingsFlag &= (~DMIC_FLAG); |
| ALOGV("Fluence quadMic feature Enabled"); |
| } else if (value == "dualmic") { |
| mDevSettingsFlag |= DMIC_FLAG; |
| mDevSettingsFlag &= (~QMIC_FLAG); |
| ALOGV("Fluence dualmic feature Enabled"); |
| } else if (value == "none") { |
| mDevSettingsFlag &= (~DMIC_FLAG); |
| mDevSettingsFlag &= (~QMIC_FLAG); |
| ALOGV("Fluence feature Disabled"); |
| } |
| mALSADevice->setFlags(mDevSettingsFlag); |
| doRouting(0); |
| } |
| |
| #ifdef QCOM_CSDCLIENT_ENABLED |
| if (mFusion3Platform) { |
| key = String8(INCALLMUSIC_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| if (value == "true") { |
| ALOGV("Enabling Incall Music setting in the setparameter\n"); |
| if (csd_start_playback == NULL) { |
| ALOGE("dlsym: Error:%s Loading csd_client_start_playback", dlerror()); |
| } else { |
| csd_start_playback(); |
| } |
| } else { |
| ALOGV("Disabling Incall Music setting in the setparameter\n"); |
| if (csd_stop_playback == NULL) { |
| ALOGE("dlsym: Error:%s Loading csd_client_stop_playback", dlerror()); |
| } else { |
| csd_stop_playback(); |
| } |
| } |
| } |
| } |
| #endif |
| |
| key = String8(ANC_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| if (value == "true") { |
| ALOGV("Enabling ANC setting in the setparameter\n"); |
| mDevSettingsFlag |= ANC_FLAG; |
| } else { |
| ALOGV("Disabling ANC setting in the setparameter\n"); |
| mDevSettingsFlag &= (~ANC_FLAG); |
| } |
| mALSADevice->setFlags(mDevSettingsFlag); |
| doRouting(0); |
| } |
| |
| key = String8(AudioParameter::keyRouting); |
| if (param.getInt(key, device) == NO_ERROR) { |
| // Ignore routing if device is 0. |
| if(device) { |
| doRouting(device); |
| } |
| param.remove(key); |
| } |
| |
| key = String8(BT_SAMPLERATE_KEY); |
| if (param.getInt(key, btRate) == NO_ERROR) { |
| mALSADevice->setBtscoRate(btRate); |
| param.remove(key); |
| } |
| |
| key = String8(BTHEADSET_VGS); |
| if (param.get(key, value) == NO_ERROR) { |
| if (value == "on") { |
| mBluetoothVGS = true; |
| } else { |
| mBluetoothVGS = false; |
| } |
| } |
| |
| key = String8(WIDEVOICE_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| bool flag = false; |
| if (value == "true") { |
| flag = true; |
| } |
| if(mALSADevice) { |
| mALSADevice->enableWideVoice(flag); |
| } |
| param.remove(key); |
| } |
| |
| key = String8(VOIPRATE_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| mVoipBitRate = atoi(value); |
| param.remove(key); |
| } |
| |
| key = String8(FENS_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| bool flag = false; |
| if (value == "true") { |
| flag = true; |
| } |
| if(mALSADevice) { |
| mALSADevice->enableFENS(flag); |
| } |
| param.remove(key); |
| } |
| |
| #ifdef QCOM_FM_ENABLED |
| key = String8(AudioParameter::keyHandleFm); |
| if (param.getInt(key, device) == NO_ERROR) { |
| // Ignore if device is 0 |
| if(device) { |
| handleFm(device); |
| } |
| param.remove(key); |
| } |
| #endif |
| |
| key = String8(ST_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| bool flag = false; |
| if (value == "true") { |
| flag = true; |
| } |
| if(mALSADevice) { |
| mALSADevice->enableSlowTalk(flag); |
| } |
| param.remove(key); |
| } |
| key = String8(MODE_CALL_KEY); |
| if (param.getInt(key,state) == NO_ERROR) { |
| if (mCallState != state) { |
| mCallState = state; |
| doRouting(0); |
| } |
| mCallState = state; |
| } |
| if (param.size()) { |
| status = BAD_VALUE; |
| } |
| return status; |
| } |
| |
| String8 AudioHardwareALSA::getParameters(const String8& keys) |
| { |
| AudioParameter param = AudioParameter(keys); |
| String8 value; |
| |
| String8 key = String8(DUALMIC_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| value = String8("false"); |
| param.add(key, value); |
| } |
| |
| key = String8(FLUENCE_KEY); |
| if (param.get(key, value) == NO_ERROR) { |
| if ((mDevSettingsFlag & QMIC_FLAG) && |
| (mDevSettingsFlag & ~DMIC_FLAG)) |
| value = String8("quadmic"); |
| else if ((mDevSettingsFlag & DMIC_FLAG) && |
| (mDevSettingsFlag & ~QMIC_FLAG)) |
| value = String8("dualmic"); |
| else if ((mDevSettingsFlag & ~DMIC_FLAG) && |
| (mDevSettingsFlag & ~QMIC_FLAG)) |
| value = String8("none"); |
| param.add(key, value); |
| } |
| |
| #ifdef QCOM_FM_ENABLED |
| key = String8("Fm-radio"); |
| if ( param.get(key,value) == NO_ERROR ) { |
| if ( mIsFmActive ) { |
| param.addInt(String8("isFMON"), true ); |
| } |
| } |
| #endif |
| |
| key = String8(BTHEADSET_VGS); |
| if (param.get(key, value) == NO_ERROR) { |
| if(mBluetoothVGS) |
| param.addInt(String8("isVGS"), true); |
| } |
| |
| ALOGV("AudioHardwareALSA::getParameters() %s", param.toString().string()); |
| return param.toString(); |
| } |
| |
| #ifdef QCOM_USBAUDIO_ENABLED |
| void AudioHardwareALSA::closeUSBPlayback() |
| { |
| ALOGV("closeUSBPlayback, musbPlaybackState: %d", musbPlaybackState); |
| musbPlaybackState = 0; |
| mAudioUsbALSA->exitPlaybackThread(SIGNAL_EVENT_KILLTHREAD); |
| } |
| |
| void AudioHardwareALSA::closeUSBRecording() |
| { |
| ALOGV("closeUSBRecording"); |
| musbRecordingState = 0; |
| mAudioUsbALSA->exitRecordingThread(SIGNAL_EVENT_KILLTHREAD); |
| } |
| |
| void AudioHardwareALSA::closeUsbPlaybackIfNothingActive(){ |
| ALOGV("closeUsbPlaybackIfNothingActive, musbPlaybackState: %d", musbPlaybackState); |
| if(!musbPlaybackState && mAudioUsbALSA != NULL) { |
| mAudioUsbALSA->exitPlaybackThread(SIGNAL_EVENT_TIMEOUT); |
| } |
| } |
| |
| void AudioHardwareALSA::closeUsbRecordingIfNothingActive(){ |
| ALOGV("closeUsbRecordingIfNothingActive, musbRecordingState: %d", musbRecordingState); |
| if(!musbRecordingState && mAudioUsbALSA != NULL) { |
| ALOGD("Closing USB Recording Session as no stream is active"); |
| mAudioUsbALSA->setkillUsbRecordingThread(true); |
| } |
| } |
| |
| void AudioHardwareALSA::startUsbPlaybackIfNotStarted(){ |
| ALOGV("Starting the USB playback %d kill %d", musbPlaybackState, |
| mAudioUsbALSA->getkillUsbPlaybackThread()); |
| if((!musbPlaybackState) || (mAudioUsbALSA->getkillUsbPlaybackThread() == true)) { |
| mAudioUsbALSA->startPlayback(); |
| } |
| } |
| |
| void AudioHardwareALSA::startUsbRecordingIfNotStarted(){ |
| ALOGV("Starting the recording musbRecordingState: %d killUsbRecordingThread %d", |
| musbRecordingState, mAudioUsbALSA->getkillUsbRecordingThread()); |
| if((!musbRecordingState) || (mAudioUsbALSA->getkillUsbRecordingThread() == true)) { |
| mAudioUsbALSA->startRecording(); |
| } |
| } |
| #endif |
| |
| void AudioHardwareALSA::doRouting(int device) |
| { |
| Mutex::Autolock autoLock(mLock); |
| int newMode = mode(); |
| bool isRouted = false; |
| |
| if ((device == AudioSystem::DEVICE_IN_VOICE_CALL) |
| #ifdef QCOM_FM_ENABLED |
| || (device == AudioSystem::DEVICE_IN_FM_RX) |
| || (device == AudioSystem::DEVICE_OUT_DIRECTOUTPUT) |
| || (device == AudioSystem::DEVICE_IN_FM_RX_A2DP) |
| #endif |
| || (device == AudioSystem::DEVICE_IN_COMMUNICATION) |
| ) { |
| ALOGV("Ignoring routing for FM/INCALL/VOIP recording"); |
| return; |
| } |
| if (device == 0) |
| device = mCurDevice; |
| ALOGV("doRouting: device %d newMode %d mCSCallActive %d mVolteCallActive %d" |
| "mIsFmActive %d", device, newMode, mCSCallActive, mVolteCallActive, |
| mIsFmActive); |
| |
| isRouted = routeVoLTECall(device, newMode); |
| isRouted |= routeVoiceCall(device, newMode); |
| |
| if(!isRouted) { |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if(!(device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET) && |
| !(device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET) && |
| !(device & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) && |
| (musbPlaybackState)){ |
| //USB unplugged |
| device &= ~ AudioSystem::DEVICE_OUT_PROXY; |
| device &= ~ AudioSystem::DEVICE_IN_PROXY; |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| mALSADevice->route(&(*it), (uint32_t)device, newMode); |
| ALOGD("USB UNPLUGGED, setting musbPlaybackState to 0"); |
| musbPlaybackState = 0; |
| musbRecordingState = 0; |
| closeUSBRecording(); |
| closeUSBPlayback(); |
| } else if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| ALOGD("Routing everything to prox now"); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| mALSADevice->route(&(*it), AudioSystem::DEVICE_OUT_PROXY, |
| newMode); |
| for(it = mDeviceList.begin(); it != mDeviceList.end(); ++it) { |
| if((!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) || |
| (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_LPA))) { |
| ALOGV("doRouting: LPA device switch to proxy"); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_LPA; |
| break; |
| } else if((!strcmp(it->useCase, SND_USE_CASE_VERB_VOICECALL)) || |
| (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_VOICE))) { |
| ALOGV("doRouting: VOICE device switch to proxy"); |
| startUsbRecordingIfNotStarted(); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_VOICECALL; |
| musbRecordingState |= USBPLAYBACKBIT_VOICECALL; |
| break; |
| }else if((!strcmp(it->useCase, SND_USE_CASE_VERB_DIGITAL_RADIO)) || |
| (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_FM))) { |
| ALOGV("doRouting: FM device switch to proxy"); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_FM; |
| break; |
| } |
| } |
| } else |
| #endif |
| { |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| mALSADevice->route(&(*it), (uint32_t)device, newMode); |
| } |
| } |
| mCurDevice = device; |
| } |
| |
| uint32_t AudioHardwareALSA::getVoipMode(int format) |
| { |
| switch(format) { |
| case AudioSystem::PCM_16_BIT: |
| return MODE_PCM; |
| break; |
| case AudioSystem::AMR_NB: |
| return MODE_AMR; |
| break; |
| case AudioSystem::AMR_WB: |
| return MODE_AMR_WB; |
| break; |
| |
| #ifdef QCOM_QCHAT_ENABLED |
| case AudioSystem::EVRC: |
| return MODE_IS127; |
| break; |
| |
| case AudioSystem::EVRCB: |
| return MODE_4GV_NB; |
| break; |
| case AudioSystem::EVRCWB: |
| return MODE_4GV_WB; |
| break; |
| #endif |
| |
| default: |
| return MODE_PCM; |
| } |
| } |
| |
| AudioStreamOut * |
| AudioHardwareALSA::openOutputStream(uint32_t devices, |
| int *format, |
| uint32_t *channels, |
| uint32_t *sampleRate, |
| status_t *status) |
| { |
| Mutex::Autolock autoLock(mLock); |
| ALOGV("openOutputStream: devices 0x%x channels %d sampleRate %d", |
| devices, *channels, *sampleRate); |
| |
| audio_output_flags_t flag = static_cast<audio_output_flags_t> (*status); |
| |
| status_t err = BAD_VALUE; |
| *status = NO_ERROR; |
| AudioStreamOutALSA *out = 0; |
| ALSAHandleList::iterator it; |
| |
| if (devices & (devices - 1)) { |
| if (status) *status = err; |
| ALOGE("openOutputStream called with bad devices"); |
| return out; |
| } |
| |
| |
| # if 0 |
| if((devices == AudioSystem::DEVICE_OUT_DIRECTOUTPUT) && |
| ((*sampleRate == VOIP_SAMPLING_RATE_8K) || (*sampleRate == VOIP_SAMPLING_RATE_16K))) { |
| bool voipstream_active = false; |
| for(it = mDeviceList.begin(); |
| it != mDeviceList.end(); ++it) { |
| if((!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) || |
| (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) { |
| ALOGD("openOutput: it->rxHandle %d it->handle %d",it->rxHandle,it->handle); |
| voipstream_active = true; |
| break; |
| } |
| } |
| if(voipstream_active == false) { |
| mVoipStreamCount = 0; |
| alsa_handle_t alsa_handle; |
| unsigned long bufferSize; |
| if(*sampleRate == VOIP_SAMPLING_RATE_8K) { |
| bufferSize = VOIP_BUFFER_SIZE_8K; |
| } |
| else if(*sampleRate == VOIP_SAMPLING_RATE_16K) { |
| bufferSize = VOIP_BUFFER_SIZE_16K; |
| } |
| else { |
| ALOGE("unsupported samplerate %d for voip",*sampleRate); |
| if (status) *status = err; |
| return out; |
| } |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = devices; |
| alsa_handle.handle = 0; |
| if(*format == AudioSystem::PCM_16_BIT) |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| else |
| alsa_handle.format = *format; |
| alsa_handle.channels = VOIP_DEFAULT_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO; |
| alsa_handle.sampleRate = *sampleRate; |
| alsa_handle.latency = VOIP_PLAYBACK_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| mALSADevice->setVoipConfig(getVoipMode(*format), mVoipBitRate); |
| char *use_case; |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_IP_VOICECALL, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_VOIP, sizeof(alsa_handle.useCase)); |
| } |
| free(use_case); |
| mDeviceList.push_back(alsa_handle); |
| it = mDeviceList.end(); |
| it--; |
| ALOGV("openoutput: mALSADevice->route useCase %s mCurDevice %d mVoipStreamCount %d mode %d", it->useCase,mCurDevice,mVoipStreamCount, mode()); |
| if((mCurDevice & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (mCurDevice & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)|| |
| (mCurDevice & AudioSystem::DEVICE_OUT_PROXY)){ |
| ALOGD("Routing to proxy for normal voip call in openOutputStream"); |
| mCurDevice |= AudioSystem::DEVICE_OUT_PROXY; |
| alsa_handle.devices = AudioSystem::DEVICE_OUT_PROXY; |
| mALSADevice->route(&(*it), mCurDevice, AudioSystem::MODE_IN_COMMUNICATION); |
| ALOGD("enabling VOIP in openoutputstream, musbPlaybackState: %d", musbPlaybackState); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_VOIPCALL; |
| ALOGD("Starting recording in openoutputstream, musbRecordingState: %d", musbRecordingState); |
| startUsbRecordingIfNotStarted(); |
| musbRecordingState |= USBRECBIT_VOIPCALL; |
| } else{ |
| mALSADevice->route(&(*it), mCurDevice, AudioSystem::MODE_IN_COMMUNICATION); |
| } |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_IP_VOICECALL); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_VOIP); |
| } |
| err = mALSADevice->startVoipCall(&(*it)); |
| if (err) { |
| ALOGE("Device open failed"); |
| return NULL; |
| } |
| } |
| out = new AudioStreamOutALSA(this, &(*it)); |
| err = out->set(format, channels, sampleRate, devices); |
| if(err == NO_ERROR) { |
| mVoipStreamCount++; //increment VoipstreamCount only if success |
| ALOGD("openoutput mVoipStreamCount %d",mVoipStreamCount); |
| } |
| if (status) *status = err; |
| return out; |
| } else |
| #endif |
| if ((flag & AUDIO_OUTPUT_FLAG_DIRECT) && |
| (devices == AudioSystem::DEVICE_OUT_AUX_DIGITAL)) { |
| ALOGD("Multi channel PCM"); |
| alsa_handle_t alsa_handle; |
| EDID_AUDIO_INFO info = { 0 }; |
| |
| alsa_handle.module = mALSADevice; |
| alsa_handle.devices = devices; |
| alsa_handle.handle = 0; |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| |
| if (!AudioUtil::getHDMIAudioSinkCaps(&info)) { |
| ALOGE("openOutputStream: Failed to get HDMI sink capabilities"); |
| return NULL; |
| } |
| if (0 == *channels) { |
| alsa_handle.channels = info.AudioBlocksArray[info.nAudioBlocks-1].nChannels; |
| if (alsa_handle.channels > 6) { |
| alsa_handle.channels = 6; |
| } |
| *channels = audio_channel_out_mask_from_count(alsa_handle.channels); |
| } else { |
| alsa_handle.channels = AudioSystem::popCount(*channels); |
| } |
| alsa_handle.channelMask = *channels; |
| |
| if (6 == alsa_handle.channels) { |
| alsa_handle.bufferSize = DEFAULT_MULTI_CHANNEL_BUF_SIZE; |
| } else { |
| alsa_handle.bufferSize = DEFAULT_BUFFER_SIZE; |
| } |
| if (0 == *sampleRate) { |
| alsa_handle.sampleRate = info.AudioBlocksArray[info.nAudioBlocks-1].nSamplingFreq; |
| *sampleRate = alsa_handle.sampleRate; |
| } else { |
| alsa_handle.sampleRate = *sampleRate; |
| } |
| alsa_handle.latency = PLAYBACK_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| ALOGD("alsa_handle.channels %d alsa_handle.sampleRate %d",alsa_handle.channels,alsa_handle.sampleRate); |
| |
| char *use_case; |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI2 , sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_MUSIC2, sizeof(alsa_handle.useCase)); |
| } |
| free(use_case); |
| mDeviceList.push_back(alsa_handle); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| ALOGD("it->useCase %s", it->useCase); |
| mALSADevice->route(&(*it), devices, mode()); |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI2)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI2 ); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_MUSIC2); |
| } |
| ALOGD("channels: %d", AudioSystem::popCount(*channels)); |
| err = mALSADevice->open(&(*it)); |
| |
| if (err) { |
| ALOGE("Device open failed err:%d",err); |
| } else { |
| out = new AudioStreamOutALSA(this, &(*it)); |
| err = out->set(format, channels, sampleRate, devices); |
| } |
| if (status) *status = err; |
| return out; |
| } else { |
| |
| alsa_handle_t alsa_handle; |
| unsigned long bufferSize = DEFAULT_BUFFER_SIZE; |
| |
| for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1) |
| bufferSize &= ~b; |
| |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = devices; |
| alsa_handle.handle = 0; |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| alsa_handle.channels = DEFAULT_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_OUT_STEREO; |
| alsa_handle.sampleRate = DEFAULT_SAMPLING_RATE; |
| alsa_handle.latency = PLAYBACK_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| alsa_handle.isDeepbufferOutput = false; |
| |
| char *use_case; |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| |
| if (flag & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) { |
| ALOGD("openOutputStream: DeepBuffer Output"); |
| alsa_handle.isDeepbufferOutput = true; |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_MUSIC, sizeof(alsa_handle.useCase)); |
| } |
| } else { |
| ALOGD("openOutputStream: Lowlatency Output"); |
| alsa_handle.bufferSize = PLAYBACK_LOW_LATENCY_BUFFER_SIZE; |
| alsa_handle.latency = PLAYBACK_LOW_LATENCY_MEASURED; |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC, sizeof(alsa_handle.useCase)); |
| } |
| } |
| free(use_case); |
| mDeviceList.push_back(alsa_handle); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| ALOGV("useCase %s", it->useCase); |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if((devices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (devices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| ALOGD("Routing to proxy for normal playback in openOutputStream"); |
| devices |= AudioSystem::DEVICE_OUT_PROXY; |
| } |
| #endif |
| mALSADevice->route(&(*it), devices, mode()); |
| if (flag & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) { |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_MUSIC); |
| } |
| } else { |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI_LOWLATENCY_MUSIC); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_LOWLATENCY_MUSIC); |
| } |
| } |
| err = mALSADevice->open(&(*it)); |
| if (err) { |
| ALOGE("Device open failed"); |
| } else { |
| out = new AudioStreamOutALSA(this, &(*it)); |
| err = out->set(format, channels, sampleRate, devices); |
| } |
| |
| if (status) *status = err; |
| return out; |
| } |
| } |
| |
| void |
| AudioHardwareALSA::closeOutputStream(AudioStreamOut* out) |
| { |
| delete out; |
| } |
| |
| #ifdef QCOM_TUNNEL_LPA_ENABLED |
| AudioStreamOut * |
| AudioHardwareALSA::openOutputSession(uint32_t devices, |
| int *format, |
| status_t *status, |
| int sessionId, |
| uint32_t samplingRate, |
| uint32_t channels) |
| { |
| Mutex::Autolock autoLock(mLock); |
| ALOGD("openOutputSession = %d" ,sessionId); |
| AudioStreamOutALSA *out = 0; |
| status_t err = BAD_VALUE; |
| |
| alsa_handle_t alsa_handle; |
| unsigned long bufferSize = DEFAULT_BUFFER_SIZE; |
| |
| for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1) |
| bufferSize &= ~b; |
| |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = devices; |
| alsa_handle.handle = 0; |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| alsa_handle.channels = DEFAULT_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_OUT_STEREO; |
| alsa_handle.sampleRate = DEFAULT_SAMPLING_RATE; |
| alsa_handle.latency = VOICE_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| |
| char *use_case; |
| if(sessionId == TUNNEL_SESSION_ID) { |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_TUNNEL, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_TUNNEL, sizeof(alsa_handle.useCase)); |
| } |
| } else { |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_LPA, sizeof(alsa_handle.useCase)); |
| } |
| } |
| free(use_case); |
| mDeviceList.push_back(alsa_handle); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| ALOGD("useCase %s", it->useCase); |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if((devices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (devices & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| ALOGD("Routing to proxy for LPA in openOutputSession"); |
| devices |= AudioSystem::DEVICE_OUT_PROXY; |
| mALSADevice->route(&(*it), devices, mode()); |
| devices = AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET; |
| ALOGD("Starting USBPlayback for LPA"); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_LPA; |
| } else |
| #endif |
| { |
| mALSADevice->route(&(*it), devices, mode()); |
| } |
| if(sessionId == TUNNEL_SESSION_ID) { |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_TUNNEL)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI_TUNNEL); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_TUNNEL); |
| } |
| } |
| else { |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOW_POWER)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_HIFI_LOW_POWER); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_LPA); |
| } |
| } |
| err = mALSADevice->open(&(*it)); |
| out = new AudioStreamOutALSA(this, &(*it)); |
| |
| if (status) *status = err; |
| return out; |
| } |
| |
| void |
| AudioHardwareALSA::closeOutputSession(AudioStreamOut* out) |
| { |
| delete out; |
| } |
| #endif |
| |
| AudioStreamIn * |
| AudioHardwareALSA::openInputStream(uint32_t devices, |
| int *format, |
| uint32_t *channels, |
| uint32_t *sampleRate, |
| status_t *status, |
| AudioSystem::audio_in_acoustics acoustics) |
| { |
| Mutex::Autolock autoLock(mLock); |
| char *use_case; |
| int newMode = mode(); |
| uint32_t route_devices; |
| |
| status_t err = BAD_VALUE; |
| AudioStreamInALSA *in = 0; |
| ALSAHandleList::iterator it; |
| |
| ALOGD("openInputStream: devices 0x%x channels %d sampleRate %d", devices, *channels, *sampleRate); |
| if (devices & (devices - 1)) { |
| if (status) *status = err; |
| return in; |
| } |
| |
| if((devices == AudioSystem::DEVICE_IN_COMMUNICATION) && |
| ((*sampleRate == VOIP_SAMPLING_RATE_8K) || (*sampleRate == VOIP_SAMPLING_RATE_16K))) { |
| bool voipstream_active = false; |
| for(it = mDeviceList.begin(); |
| it != mDeviceList.end(); ++it) { |
| if((!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) || |
| (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) { |
| ALOGD("openInput: it->rxHandle %p it->handle %p",it->rxHandle,it->handle); |
| voipstream_active = true; |
| break; |
| } |
| } |
| if(voipstream_active == false) { |
| mVoipStreamCount = 0; |
| alsa_handle_t alsa_handle; |
| unsigned long bufferSize; |
| if(*sampleRate == VOIP_SAMPLING_RATE_8K) { |
| bufferSize = VOIP_BUFFER_SIZE_8K; |
| } |
| else if(*sampleRate == VOIP_SAMPLING_RATE_16K) { |
| bufferSize = VOIP_BUFFER_SIZE_16K; |
| } |
| else { |
| ALOGE("unsupported samplerate %d for voip",*sampleRate); |
| if (status) *status = err; |
| return in; |
| } |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = devices; |
| alsa_handle.handle = 0; |
| if(*format == AudioSystem::PCM_16_BIT) |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| else |
| alsa_handle.format = *format; |
| alsa_handle.channels = VOIP_DEFAULT_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO; |
| alsa_handle.sampleRate = *sampleRate; |
| alsa_handle.latency = VOIP_RECORD_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| mALSADevice->setVoipConfig(getVoipMode(*format), mVoipBitRate); |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case != NULL) && (strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_VOIP, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_IP_VOICECALL, sizeof(alsa_handle.useCase)); |
| } |
| free(use_case); |
| mDeviceList.push_back(alsa_handle); |
| it = mDeviceList.end(); |
| it--; |
| ALOGD("mCurrDevice: %d", mCurDevice); |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if((mCurDevice == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (mCurDevice == AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| ALOGD("Routing everything from proxy for voipcall"); |
| mALSADevice->route(&(*it), AudioSystem::DEVICE_IN_PROXY, AudioSystem::MODE_IN_COMMUNICATION); |
| ALOGD("enabling VOIP in openInputstream, musbPlaybackState: %d", musbPlaybackState); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_VOIPCALL; |
| ALOGD("Starting recording in openoutputstream, musbRecordingState: %d", musbRecordingState); |
| startUsbRecordingIfNotStarted(); |
| musbRecordingState |= USBRECBIT_VOIPCALL; |
| } else |
| #endif |
| { |
| mALSADevice->route(&(*it),mCurDevice, AudioSystem::MODE_IN_COMMUNICATION); |
| } |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_IP_VOICECALL); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_VOIP); |
| } |
| if(sampleRate) { |
| it->sampleRate = *sampleRate; |
| } |
| if(channels) |
| it->channels = AudioSystem::popCount(*channels); |
| err = mALSADevice->startVoipCall(&(*it)); |
| if (err) { |
| ALOGE("Error opening pcm input device"); |
| return NULL; |
| } |
| } |
| in = new AudioStreamInALSA(this, &(*it), acoustics); |
| err = in->set(format, channels, sampleRate, devices); |
| if(err == NO_ERROR) { |
| mVoipStreamCount++; //increment VoipstreamCount only if success |
| ALOGD("OpenInput mVoipStreamCount %d",mVoipStreamCount); |
| } |
| ALOGD("openInput: After Get alsahandle"); |
| if (status) *status = err; |
| return in; |
| } else { |
| alsa_handle_t alsa_handle; |
| unsigned long bufferSize = MIN_CAPTURE_BUFFER_SIZE_PER_CH; |
| |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = devices; |
| alsa_handle.handle = 0; |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| alsa_handle.channels = VOICE_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO; |
| alsa_handle.sampleRate = android::AudioRecord::DEFAULT_SAMPLE_RATE; |
| alsa_handle.latency = RECORD_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case != NULL) && (strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| if ((devices == AudioSystem::DEVICE_IN_VOICE_CALL) && |
| (newMode == AudioSystem::MODE_IN_CALL)) { |
| ALOGD("openInputStream: into incall recording, channels %d", *channels); |
| mIncallMode = *channels; |
| if ((*channels & AudioSystem::CHANNEL_IN_VOICE_UPLINK) && |
| (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) { |
| if (mFusion3Platform) { |
| mALSADevice->setVocRecMode(INCALL_REC_STEREO); |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE, |
| sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL, |
| sizeof(alsa_handle.useCase)); |
| } |
| } else if (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK) { |
| if (mFusion3Platform) { |
| mALSADevice->setVocRecMode(INCALL_REC_MONO); |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE, |
| sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL, |
| sizeof(alsa_handle.useCase)); |
| } |
| } |
| #ifdef QCOM_FM_ENABLED |
| } else if((devices == AudioSystem::DEVICE_IN_FM_RX)) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_FM, sizeof(alsa_handle.useCase)); |
| } else if(devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM, sizeof(alsa_handle.useCase)); |
| #endif |
| } else { |
| char value[128]; |
| property_get("persist.audio.lowlatency.rec",value,"0"); |
| if (!strcmp("true", value)) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, sizeof(alsa_handle.useCase)); |
| } |
| } |
| } else { |
| if ((devices == AudioSystem::DEVICE_IN_VOICE_CALL) && |
| (newMode == AudioSystem::MODE_IN_CALL)) { |
| ALOGD("openInputStream: incall recording, channels %d", *channels); |
| mIncallMode = *channels; |
| if ((*channels & AudioSystem::CHANNEL_IN_VOICE_UPLINK) && |
| (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) { |
| if (mFusion3Platform) { |
| mALSADevice->setVocRecMode(INCALL_REC_STEREO); |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_INCALL_REC, |
| sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_UL_DL_REC, |
| sizeof(alsa_handle.useCase)); |
| } |
| } else if (*channels & AudioSystem::CHANNEL_IN_VOICE_DNLINK) { |
| if (mFusion3Platform) { |
| mALSADevice->setVocRecMode(INCALL_REC_MONO); |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_INCALL_REC, |
| sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_DL_REC, |
| sizeof(alsa_handle.useCase)); |
| } |
| } |
| #ifdef QCOM_FM_ENABLED |
| } else if(devices == AudioSystem::DEVICE_IN_FM_RX) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_FM_REC, sizeof(alsa_handle.useCase)); |
| } else if (devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_FM_A2DP_REC, sizeof(alsa_handle.useCase)); |
| #endif |
| } else { |
| char value[128]; |
| property_get("persist.audio.lowlatency.rec",value,"0"); |
| if (!strcmp("true", value)) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_HIFI_REC, sizeof(alsa_handle.useCase)); |
| } |
| } |
| } |
| free(use_case); |
| mDeviceList.push_back(alsa_handle); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| //update channel info before do routing |
| if(channels) { |
| it->channels = AudioSystem::popCount((*channels) & |
| (AudioSystem::CHANNEL_IN_STEREO |
| | AudioSystem::CHANNEL_IN_MONO |
| #ifdef QCOM_SSR_ENABLED |
| | AudioSystem::CHANNEL_IN_5POINT1 |
| #endif |
| | AUDIO_CHANNEL_IN_FRONT_BACK)); |
| it->channelMask = *channels; |
| ALOGV("updated channel info: channels=%d channelMask %08x", |
| it->channels, it->channelMask); |
| } |
| if (devices == AudioSystem::DEVICE_IN_VOICE_CALL){ |
| /* Add current devices info to devices to do route */ |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if(mCurDevice == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET || |
| mCurDevice == AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET){ |
| ALOGD("Routing everything from proxy for VOIP call"); |
| route_devices = devices | AudioSystem::DEVICE_IN_PROXY; |
| } else |
| #endif |
| { |
| route_devices = devices | mCurDevice; |
| } |
| mALSADevice->route(&(*it), route_devices, mode()); |
| } else { |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if(devices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET || |
| devices & AudioSystem::DEVICE_IN_PROXY) { |
| devices |= AudioSystem::DEVICE_IN_PROXY; |
| ALOGD("routing everything from proxy"); |
| mALSADevice->route(&(*it), devices, mode()); |
| } else |
| #endif |
| { |
| mALSADevice->route(&(*it), devices, mode()); |
| } |
| } |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_REC) || |
| !strcmp(it->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC) || |
| #ifdef QCOM_FM_ENABLED |
| !strcmp(it->useCase, SND_USE_CASE_VERB_FM_REC) || |
| !strcmp(it->useCase, SND_USE_CASE_VERB_FM_A2DP_REC) || |
| #endif |
| !strcmp(it->useCase, SND_USE_CASE_VERB_DL_REC) || |
| !strcmp(it->useCase, SND_USE_CASE_VERB_UL_DL_REC) || |
| !strcmp(it->useCase, SND_USE_CASE_VERB_INCALL_REC)) { |
| snd_use_case_set(mUcMgr, "_verb", it->useCase); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", it->useCase); |
| } |
| if(sampleRate) { |
| it->sampleRate = *sampleRate; |
| } |
| if (!strncmp(it->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC)) |
| || !strncmp(it->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) { |
| ALOGV("OpenInoutStream: Use larger buffer size for 5.1(%s) recording ", it->useCase); |
| it->bufferSize = getInputBufferSize(it->sampleRate,*format,it->channels); |
| } |
| err = mALSADevice->open(&(*it)); |
| if (err) { |
| ALOGE("Error opening pcm input device"); |
| } else { |
| in = new AudioStreamInALSA(this, &(*it), acoustics); |
| err = in->set(format, channels, sampleRate, devices); |
| } |
| if (status) *status = err; |
| return in; |
| } |
| } |
| |
| void |
| AudioHardwareALSA::closeInputStream(AudioStreamIn* in) |
| { |
| delete in; |
| } |
| |
| status_t AudioHardwareALSA::setMicMute(bool state) |
| { |
| if (mMicMute != state) { |
| mMicMute = state; |
| ALOGD("setMicMute: mMicMute %d", mMicMute); |
| if(mALSADevice) { |
| mALSADevice->setMicMute(state); |
| } |
| } |
| return NO_ERROR; |
| } |
| |
| status_t AudioHardwareALSA::getMicMute(bool *state) |
| { |
| *state = mMicMute; |
| return NO_ERROR; |
| } |
| |
| status_t AudioHardwareALSA::dump(int fd, const Vector<String16>& args) |
| { |
| return NO_ERROR; |
| } |
| |
| size_t AudioHardwareALSA::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) |
| { |
| size_t bufferSize = 0; |
| if (format == AudioSystem::PCM_16_BIT) { |
| if(sampleRate == 8000 || sampleRate == 16000 || sampleRate == 32000) { |
| bufferSize = (sampleRate * channelCount * 20 * sizeof(int16_t)) / 1000; |
| } else if (sampleRate == 11025 || sampleRate == 12000) { |
| bufferSize = 256 * sizeof(int16_t) * channelCount; |
| } else if (sampleRate == 22050 || sampleRate == 24000) { |
| bufferSize = 512 * sizeof(int16_t) * channelCount; |
| } else if (sampleRate == 44100 || sampleRate == 48000) { |
| bufferSize = 1024 * sizeof(int16_t) * channelCount; |
| } |
| } else { |
| ALOGE("getInputBufferSize bad format: %d", format); |
| } |
| return bufferSize; |
| } |
| |
| #ifdef QCOM_FM_ENABLED |
| void AudioHardwareALSA::handleFm(int device) |
| { |
| int newMode = mode(); |
| if(device & AudioSystem::DEVICE_OUT_FM && mIsFmActive == 0) { |
| // Start FM Radio on current active device |
| unsigned long bufferSize = FM_BUFFER_SIZE; |
| alsa_handle_t alsa_handle; |
| char *use_case; |
| ALOGV("Start FM"); |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_VERB_DIGITAL_RADIO, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, SND_USE_CASE_MOD_PLAY_FM, sizeof(alsa_handle.useCase)); |
| } |
| free(use_case); |
| |
| for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1) |
| bufferSize &= ~b; |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = device; |
| alsa_handle.handle = 0; |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| alsa_handle.channels = DEFAULT_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_OUT_STEREO; |
| alsa_handle.sampleRate = DEFAULT_SAMPLING_RATE; |
| alsa_handle.latency = VOICE_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| mIsFmActive = 1; |
| mDeviceList.push_back(alsa_handle); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| device |= AudioSystem::DEVICE_OUT_PROXY; |
| alsa_handle.devices = AudioSystem::DEVICE_OUT_PROXY; |
| ALOGD("Routing to proxy for FM case"); |
| } |
| mALSADevice->route(&(*it), (uint32_t)device, newMode); |
| if(!strcmp(it->useCase, SND_USE_CASE_VERB_DIGITAL_RADIO)) { |
| snd_use_case_set(mUcMgr, "_verb", SND_USE_CASE_VERB_DIGITAL_RADIO); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", SND_USE_CASE_MOD_PLAY_FM); |
| } |
| mALSADevice->startFm(&(*it)); |
| if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| ALOGD("Starting FM, musbPlaybackState %d", musbPlaybackState); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_FM; |
| } |
| } else if (!(device & AudioSystem::DEVICE_OUT_FM) && mIsFmActive == 1) { |
| //i Stop FM Radio |
| ALOGV("Stop FM"); |
| for(ALSAHandleList::iterator it = mDeviceList.begin(); |
| it != mDeviceList.end(); ++it) { |
| if((!strcmp(it->useCase, SND_USE_CASE_VERB_DIGITAL_RADIO)) || |
| (!strcmp(it->useCase, SND_USE_CASE_MOD_PLAY_FM))) { |
| mALSADevice->close(&(*it)); |
| //mALSADevice->route(&(*it), (uint32_t)device, newMode); |
| mDeviceList.erase(it); |
| break; |
| } |
| } |
| mIsFmActive = 0; |
| musbPlaybackState &= ~USBPLAYBACKBIT_FM; |
| if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| closeUsbPlaybackIfNothingActive(); |
| } |
| } |
| } |
| #endif |
| |
| void AudioHardwareALSA::disableVoiceCall(char* verb, char* modifier, int mode, int device) |
| { |
| for(ALSAHandleList::iterator it = mDeviceList.begin(); |
| it != mDeviceList.end(); ++it) { |
| if((!strcmp(it->useCase, verb)) || |
| (!strcmp(it->useCase, modifier))) { |
| ALOGV("Disabling voice call"); |
| mALSADevice->close(&(*it)); |
| mALSADevice->route(&(*it), (uint32_t)device, mode); |
| mDeviceList.erase(it); |
| break; |
| } |
| } |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if(musbPlaybackState & USBPLAYBACKBIT_VOICECALL) { |
| ALOGD("Voice call ended on USB"); |
| musbPlaybackState &= ~USBPLAYBACKBIT_VOICECALL; |
| musbRecordingState &= ~USBRECBIT_VOICECALL; |
| closeUsbRecordingIfNothingActive(); |
| closeUsbPlaybackIfNothingActive(); |
| } |
| #endif |
| } |
| void AudioHardwareALSA::enableVoiceCall(char* verb, char* modifier, int mode, int device) |
| { |
| // Start voice call |
| unsigned long bufferSize = DEFAULT_VOICE_BUFFER_SIZE; |
| alsa_handle_t alsa_handle; |
| char *use_case; |
| snd_use_case_get(mUcMgr, "_verb", (const char **)&use_case); |
| if ((use_case == NULL) || (!strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) { |
| strlcpy(alsa_handle.useCase, verb, sizeof(alsa_handle.useCase)); |
| } else { |
| strlcpy(alsa_handle.useCase, modifier, sizeof(alsa_handle.useCase)); |
| } |
| free(use_case); |
| |
| for (size_t b = 1; (bufferSize & ~b) != 0; b <<= 1) |
| bufferSize &= ~b; |
| alsa_handle.module = mALSADevice; |
| alsa_handle.bufferSize = bufferSize; |
| alsa_handle.devices = device; |
| alsa_handle.handle = 0; |
| alsa_handle.format = SNDRV_PCM_FORMAT_S16_LE; |
| alsa_handle.channels = VOICE_CHANNEL_MODE; |
| alsa_handle.channelMask = AUDIO_CHANNEL_IN_MONO; |
| alsa_handle.sampleRate = VOICE_SAMPLING_RATE; |
| alsa_handle.latency = VOICE_LATENCY; |
| alsa_handle.rxHandle = 0; |
| alsa_handle.ucMgr = mUcMgr; |
| mDeviceList.push_back(alsa_handle); |
| ALSAHandleList::iterator it = mDeviceList.end(); |
| it--; |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| device |= AudioSystem::DEVICE_OUT_PROXY; |
| alsa_handle.devices = device; |
| } |
| #endif |
| mALSADevice->route(&(*it), (uint32_t)device, mode); |
| if (!strcmp(it->useCase, verb)) { |
| snd_use_case_set(mUcMgr, "_verb", verb); |
| } else { |
| snd_use_case_set(mUcMgr, "_enamod", modifier); |
| } |
| mALSADevice->startVoiceCall(&(*it)); |
| #ifdef QCOM_USBAUDIO_ENABLED |
| if((device & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)|| |
| (device & AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET)){ |
| startUsbRecordingIfNotStarted(); |
| startUsbPlaybackIfNotStarted(); |
| musbPlaybackState |= USBPLAYBACKBIT_VOICECALL; |
| musbRecordingState |= USBRECBIT_VOICECALL; |
| } |
| #endif |
| } |
| |
| bool AudioHardwareALSA::routeVoiceCall(int device, int newMode) |
| { |
| int csCallState = mCallState&0xF; |
| bool isRouted = false; |
| switch (csCallState) { |
| case CS_INACTIVE: |
| if (mCSCallActive != CS_INACTIVE) { |
| ALOGD("doRouting: Disabling voice call"); |
| disableVoiceCall((char *)SND_USE_CASE_VERB_VOICECALL, |
| (char *)SND_USE_CASE_MOD_PLAY_VOICE, newMode, device); |
| isRouted = true; |
| mCSCallActive = CS_INACTIVE; |
| } |
| break; |
| case CS_ACTIVE: |
| if (mCSCallActive == CS_INACTIVE) { |
| ALOGD("doRouting: Enabling CS voice call "); |
| enableVoiceCall((char *)SND_USE_CASE_VERB_VOICECALL, |
| (char *)SND_USE_CASE_MOD_PLAY_VOICE, newMode, device); |
| isRouted = true; |
| mCSCallActive = CS_ACTIVE; |
| } else if (mCSCallActive == CS_HOLD) { |
| ALOGD("doRouting: Resume voice call from hold state"); |
| ALSAHandleList::iterator vt_it; |
| for(vt_it = mDeviceList.begin(); |
| vt_it != mDeviceList.end(); ++vt_it) { |
| if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOICECALL, |
| strlen(SND_USE_CASE_VERB_VOICECALL))) || |
| (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOICE, |
| strlen(SND_USE_CASE_MOD_PLAY_VOICE)))) { |
| alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it)); |
| mCSCallActive = CS_ACTIVE; |
| if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,0)<0) |
| ALOGE("VoLTE resume failed"); |
| break; |
| } |
| } |
| } |
| break; |
| case CS_HOLD: |
| if (mCSCallActive == CS_ACTIVE) { |
| ALOGD("doRouting: Voice call going to Hold"); |
| ALSAHandleList::iterator vt_it; |
| for(vt_it = mDeviceList.begin(); |
| vt_it != mDeviceList.end(); ++vt_it) { |
| if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOICECALL, |
| strlen(SND_USE_CASE_VERB_VOICECALL))) || |
| (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOICE, |
| strlen(SND_USE_CASE_MOD_PLAY_VOICE)))) { |
| mCSCallActive = CS_HOLD; |
| alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it)); |
| if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,1)<0) |
| ALOGE("Voice pause failed"); |
| break; |
| } |
| } |
| } |
| break; |
| } |
| return isRouted; |
| } |
| bool AudioHardwareALSA::routeVoLTECall(int device, int newMode) |
| { |
| int volteCallState = mCallState&0xF0; |
| bool isRouted = false; |
| switch (volteCallState) { |
| case IMS_INACTIVE: |
| if (mVolteCallActive != IMS_INACTIVE) { |
| ALOGD("doRouting: Disabling IMS call"); |
| disableVoiceCall((char *)SND_USE_CASE_VERB_VOLTE, |
| (char *)SND_USE_CASE_MOD_PLAY_VOLTE, newMode, device); |
| isRouted = true; |
| mVolteCallActive = IMS_INACTIVE; |
| } |
| break; |
| case IMS_ACTIVE: |
| if (mVolteCallActive == IMS_INACTIVE) { |
| ALOGD("doRouting: Enabling IMS voice call "); |
| enableVoiceCall((char *)SND_USE_CASE_VERB_VOLTE, |
| (char *)SND_USE_CASE_MOD_PLAY_VOLTE, newMode, device); |
| isRouted = true; |
| mVolteCallActive = IMS_ACTIVE; |
| } else if (mVolteCallActive == IMS_HOLD) { |
| ALOGD("doRouting: Resume IMS call from hold state"); |
| ALSAHandleList::iterator vt_it; |
| for(vt_it = mDeviceList.begin(); |
| vt_it != mDeviceList.end(); ++vt_it) { |
| if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOLTE, |
| strlen(SND_USE_CASE_VERB_VOLTE))) || |
| (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOLTE, |
| strlen(SND_USE_CASE_MOD_PLAY_VOLTE)))) { |
| alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it)); |
| mVolteCallActive = IMS_ACTIVE; |
| if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,0)<0) |
| ALOGE("VoLTE resume failed"); |
| break; |
| } |
| } |
| } |
| break; |
| case IMS_HOLD: |
| if (mVolteCallActive == IMS_ACTIVE) { |
| ALOGD("doRouting: IMS ACTIVE going to HOLD"); |
| ALSAHandleList::iterator vt_it; |
| for(vt_it = mDeviceList.begin(); |
| vt_it != mDeviceList.end(); ++vt_it) { |
| if((!strncmp(vt_it->useCase, SND_USE_CASE_VERB_VOLTE, |
| strlen(SND_USE_CASE_VERB_VOLTE))) || |
| (!strncmp(vt_it->useCase, SND_USE_CASE_MOD_PLAY_VOLTE, |
| strlen(SND_USE_CASE_MOD_PLAY_VOLTE)))) { |
| mVolteCallActive = IMS_HOLD; |
| alsa_handle_t *handle = (alsa_handle_t *)(&(*vt_it)); |
| if(ioctl((int)handle->handle->fd,SNDRV_PCM_IOCTL_PAUSE,1)<0) |
| ALOGE("VoLTE Pause failed"); |
| break; |
| } |
| } |
| } |
| break; |
| } |
| return isRouted; |
| } |
| |
| } // namespace android_audio_legacy |
