sandy
/
PL286
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
18 GiB
Tree: 99da0f2c72
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '99da0f2c72'
${ noResults }
PL286/hardware/qcom/audio/legacy/alsa_sound/AudioHardwareALSA.cpp

1707 lines
64 KiB
Raw Blame History

/* 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