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/AudioStreamInALSA.cpp

896 lines
32 KiB
Raw Blame History

/* AudioStreamInALSA.cpp
**
** Copyright 2008-2009 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>
#define LOG_TAG "AudioStreamInALSA"
//#define LOG_NDEBUG 0
#define LOG_NDDEBUG 0
#include <utils/Log.h>
#include <utils/String8.h>
#include <cutils/properties.h>
#include <media/AudioRecord.h>
#include <hardware_legacy/power.h>
#include "AudioHardwareALSA.h"
extern "C" {
#ifdef QCOM_CSDCLIENT_ENABLED
static int (*csd_start_record)(int);
static int (*csd_stop_record)(void);
#endif
#ifdef QCOM_SSR_ENABLED
#include "surround_filters_interface.h"
#endif
}
namespace android_audio_legacy
{
#ifdef QCOM_SSR_ENABLED
#define SURROUND_FILE_1R "/system/etc/surround_sound/filter1r.pcm"
#define SURROUND_FILE_2R "/system/etc/surround_sound/filter2r.pcm"
#define SURROUND_FILE_3R "/system/etc/surround_sound/filter3r.pcm"
#define SURROUND_FILE_4R "/system/etc/surround_sound/filter4r.pcm"
#define SURROUND_FILE_1I "/system/etc/surround_sound/filter1i.pcm"
#define SURROUND_FILE_2I "/system/etc/surround_sound/filter2i.pcm"
#define SURROUND_FILE_3I "/system/etc/surround_sound/filter3i.pcm"
#define SURROUND_FILE_4I "/system/etc/surround_sound/filter4i.pcm"
// Use AAC/DTS channel mapping as default channel mapping: C,FL,FR,Ls,Rs,LFE
const int chanMap[] = { 1, 2, 4, 3, 0, 5 };
#endif
AudioStreamInALSA::AudioStreamInALSA(AudioHardwareALSA *parent,
alsa_handle_t *handle,
AudioSystem::audio_in_acoustics audio_acoustics) :
ALSAStreamOps(parent, handle),
mFramesLost(0),
mAcoustics(audio_acoustics),
mParent(parent)
#ifdef QCOM_SSR_ENABLED
, mFp_4ch(NULL),
mFp_6ch(NULL),
mRealCoeffs(NULL),
mImagCoeffs(NULL),
mSurroundObj(NULL),
mSurroundOutputBuffer(NULL),
mSurroundInputBuffer(NULL),
mSurroundOutputBufferIdx(0),
mSurroundInputBufferIdx(0)
#endif
{
#ifdef QCOM_SSR_ENABLED
char c_multi_ch_dump[128] = {0};
status_t err = NO_ERROR;
// Call surround sound library init if device is Surround Sound
if ( handle->channels == 6) {
if (!strncmp(handle->useCase, SND_USE_CASE_VERB_HIFI_REC, strlen(SND_USE_CASE_VERB_HIFI_REC))
|| !strncmp(handle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, strlen(SND_USE_CASE_MOD_CAPTURE_MUSIC))) {
err = initSurroundSoundLibrary(handle->bufferSize);
if ( NO_ERROR != err) {
ALOGE("initSurroundSoundLibrary failed: %d handle->bufferSize:%d", err,handle->bufferSize);
}
property_get("ssr.pcmdump",c_multi_ch_dump,"0");
if (0 == strncmp("true",c_multi_ch_dump, sizeof("ssr.dump-pcm"))) {
//Remember to change file system permission of data(e.g. chmod 777 data/),
//otherwise, fopen may fail.
if ( !mFp_4ch)
mFp_4ch = fopen("/data/4ch_ssr.pcm", "wb");
if ( !mFp_6ch)
mFp_6ch = fopen("/data/6ch_ssr.pcm", "wb");
if ((!mFp_4ch) || (!mFp_6ch))
ALOGE("mfp_4ch or mfp_6ch open failed: mfp_4ch:%p mfp_6ch:%p",mFp_4ch,mFp_6ch);
}
}
}
#endif
}
AudioStreamInALSA::~AudioStreamInALSA()
{
close();
}
status_t AudioStreamInALSA::setGain(float gain)
{
return 0; //mixer() ? mixer()->setMasterGain(gain) : (status_t)NO_INIT;
}
ssize_t AudioStreamInALSA::read(void *buffer, ssize_t bytes)
{
int period_size;
ALOGV("read:: buffer %p, bytes %d", buffer, bytes);
int n;
status_t err;
ssize_t read = 0;
char *use_case;
int newMode = mParent->mode();
if((mHandle->handle == NULL) && (mHandle->rxHandle == NULL) &&
(strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) &&
(strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
mParent->mLock.lock();
snd_use_case_get(mHandle->ucMgr, "_verb", (const char **)&use_case);
if ((use_case != NULL) && (strcmp(use_case, SND_USE_CASE_VERB_INACTIVE))) {
if ((mHandle->devices == AudioSystem::DEVICE_IN_VOICE_CALL) &&
(newMode == AudioSystem::MODE_IN_CALL)) {
ALOGD("read:: mParent->mIncallMode=%d", mParent->mIncallMode);
if ((mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_UPLINK) &&
(mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) {
#ifdef QCOM_CSDCLIENT_ENABLED
if (mParent->mFusion3Platform) {
mParent->mALSADevice->setVocRecMode(INCALL_REC_STEREO);
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
sizeof(mHandle->useCase));
start_csd_record(INCALL_REC_STEREO);
} else
#endif
{
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_UL_DL,
sizeof(mHandle->useCase));
}
} else if (mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK) {
#ifdef QCOM_CSDCLIENT_ENABLED
if (mParent->mFusion3Platform) {
mParent->mALSADevice->setVocRecMode(INCALL_REC_MONO);
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE,
sizeof(mHandle->useCase));
start_csd_record(INCALL_REC_MONO);
} else
#endif
{
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE_DL,
sizeof(mHandle->useCase));
}
}
#ifdef QCOM_FM_ENABLED
} else if(mHandle->devices == AudioSystem::DEVICE_IN_FM_RX) {
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_FM, sizeof(mHandle->useCase));
} else if (mHandle->devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) {
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_A2DP_FM, sizeof(mHandle->useCase));
#endif
} else if(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP)) {
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, sizeof(mHandle->useCase));
} else {
char value[128];
property_get("persist.audio.lowlatency.rec",value,"0");
if (!strcmp("true", value)) {
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_LOWLATENCY_MUSIC, sizeof(mHandle->useCase));
} else {
strlcpy(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_MUSIC, sizeof(mHandle->useCase));
}
}
} else {
if ((mHandle->devices == AudioSystem::DEVICE_IN_VOICE_CALL) &&
(newMode == AudioSystem::MODE_IN_CALL)) {
ALOGD("read:: ---- mParent->mIncallMode=%d", mParent->mIncallMode);
if ((mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_UPLINK) &&
(mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK)) {
#ifdef QCOM_CSDCLIENT_ENABLED
if (mParent->mFusion3Platform) {
mParent->mALSADevice->setVocRecMode(INCALL_REC_STEREO);
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC,
sizeof(mHandle->useCase));
start_csd_record(INCALL_REC_STEREO);
} else
#endif
{
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_UL_DL_REC,
sizeof(mHandle->useCase));
}
} else if (mParent->mIncallMode & AudioSystem::CHANNEL_IN_VOICE_DNLINK) {
#ifdef QCOM_CSDCLIENT_ENABLED
if (mParent->mFusion3Platform) {
mParent->mALSADevice->setVocRecMode(INCALL_REC_MONO);
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC,
sizeof(mHandle->useCase));
start_csd_record(INCALL_REC_MONO);
} else
#endif
{
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_DL_REC,
sizeof(mHandle->useCase));
}
}
#ifdef QCOM_FM_ENABLED
} else if(mHandle->devices == AudioSystem::DEVICE_IN_FM_RX) {
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_FM_REC, sizeof(mHandle->useCase));
} else if (mHandle->devices == AudioSystem::DEVICE_IN_FM_RX_A2DP) {
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_FM_A2DP_REC, sizeof(mHandle->useCase));
#endif
} else if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)){
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, sizeof(mHandle->useCase));
} else {
char value[128];
property_get("persist.audio.lowlatency.rec",value,"0");
if (!strcmp("true", value)) {
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC, sizeof(mHandle->useCase));
} else {
strlcpy(mHandle->useCase, SND_USE_CASE_VERB_HIFI_REC, sizeof(mHandle->useCase));
}
}
}
if (mHandle->channelMask == AUDIO_CHANNEL_IN_FRONT_BACK) {
mHandle->module->setFlags(mParent->mDevSettingsFlag | DMIC_FLAG);
}
free(use_case);
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
#ifdef QCOM_USBAUDIO_ENABLED
if((mDevices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) ||
(mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)) {
mHandle->module->route(mHandle, (mDevices | AudioSystem::DEVICE_IN_PROXY) , AudioSystem::MODE_IN_COMMUNICATION);
}else
#endif
{
mHandle->module->route(mHandle, mDevices , AudioSystem::MODE_IN_COMMUNICATION);
}
} else {
#ifdef QCOM_USBAUDIO_ENABLED
if((mHandle->devices == AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET)||
(mHandle->devices == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)){
mHandle->module->route(mHandle, AudioSystem::DEVICE_IN_PROXY , mParent->mode());
} else
#endif
{
mHandle->module->route(mHandle, mDevices , mParent->mode());
}
}
if (!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_REC) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_HIFI_LOWLATENCY_REC) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_FM_REC) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_FM_A2DP_REC) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_UL_DL_REC) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_DL_REC) ||
!strcmp(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC)) {
snd_use_case_set(mHandle->ucMgr, "_verb", mHandle->useCase);
} else {
snd_use_case_set(mHandle->ucMgr, "_enamod", mHandle->useCase);
}
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
err = mHandle->module->startVoipCall(mHandle);
}
else
mHandle->module->open(mHandle);
if(mHandle->handle == NULL) {
ALOGE("read:: PCM device open failed");
mParent->mLock.unlock();
return 0;
}
#ifdef QCOM_USBAUDIO_ENABLED
if((mHandle->devices == AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET)||
(mHandle->devices == AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)){
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
mParent->musbRecordingState |= USBRECBIT_VOIPCALL;
} else {
mParent->startUsbRecordingIfNotStarted();
mParent->musbRecordingState |= USBRECBIT_REC;
}
}
#endif
mParent->mLock.unlock();
}
#ifdef QCOM_USBAUDIO_ENABLED
if(((mDevices & AudioSystem::DEVICE_IN_ANLG_DOCK_HEADSET) ||
(mDevices & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)) &&
(!mParent->musbRecordingState)) {
mParent->mLock.lock();
ALOGD("Starting UsbRecording thread");
mParent->startUsbRecordingIfNotStarted();
if(!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL) ||
!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP)) {
ALOGD("Enabling voip recording bit");
mParent->musbRecordingState |= USBRECBIT_VOIPCALL;
}else{
ALOGD("Enabling HiFi Recording bit");
mParent->musbRecordingState |= USBRECBIT_REC;
}
mParent->mLock.unlock();
}
#endif
period_size = mHandle->periodSize;
int read_pending = bytes;
#ifdef QCOM_SSR_ENABLED
if (mSurroundObj) {
int processed = 0;
int processed_pending;
int samples = bytes >> 1;
void *buffer_start = buffer;
int period_bytes = mHandle->handle->period_size;
int period_samples = period_bytes >> 1;
do {
if (mSurroundOutputBufferIdx > 0) {
ALOGV("AudioStreamInALSA::read() - copy processed output "
"to buffer, mSurroundOutputBufferIdx = %d",
mSurroundOutputBufferIdx);
// Copy processed output to buffer
processed_pending = mSurroundOutputBufferIdx;
if (processed_pending > (samples - processed)) {
processed_pending = (samples - processed);
}
memcpy(buffer, mSurroundOutputBuffer, processed_pending * sizeof(Word16));
buffer += processed_pending * sizeof(Word16);
processed += processed_pending;
if (mSurroundOutputBufferIdx > processed_pending) {
// Shift leftover samples to beginning of the buffer
memcpy(&mSurroundOutputBuffer[0],
&mSurroundOutputBuffer[processed_pending],
(mSurroundOutputBufferIdx - processed_pending) * sizeof(Word16));
}
mSurroundOutputBufferIdx -= processed_pending;
}
if (processed >= samples) {
ALOGV("AudioStreamInALSA::read() - done processing buffer, "
"processed = %d", processed);
// Done processing this buffer
break;
}
// Fill input buffer until there is enough to process
read_pending = SSR_INPUT_FRAME_SIZE - mSurroundInputBufferIdx;
read = mSurroundInputBufferIdx;
while (mHandle->handle && read_pending > 0) {
n = pcm_read(mHandle->handle, &mSurroundInputBuffer[read],
period_bytes);
ALOGV("pcm_read() returned n = %d buffer:%p size:%d", n, &mSurroundInputBuffer[read], period_bytes);
if (n && n != -EAGAIN) {
//Recovery part of pcm_read. TODO:split recovery.
return static_cast<ssize_t>(n);
}
else if (n < 0) {
// Recovery is part of pcm_write. TODO split is later.
return static_cast<ssize_t>(n);
}
else {
read_pending -= period_samples;
read += period_samples;
}
}
if (mFp_4ch) {
fwrite( mSurroundInputBuffer, 1,
SSR_INPUT_FRAME_SIZE * sizeof(Word16), mFp_4ch);
}
//apply ssr libs to conver 4ch to 6ch
surround_filters_intl_process(mSurroundObj,
&mSurroundOutputBuffer[mSurroundOutputBufferIdx],
(Word16 *)mSurroundInputBuffer);
// Shift leftover samples to beginning of input buffer
if (read_pending < 0) {
memcpy(&mSurroundInputBuffer[0],
&mSurroundInputBuffer[SSR_INPUT_FRAME_SIZE],
(-read_pending) * sizeof(Word16));
}
mSurroundInputBufferIdx = -read_pending;
if (mFp_6ch) {
fwrite( &mSurroundOutputBuffer[mSurroundOutputBufferIdx],
1, SSR_OUTPUT_FRAME_SIZE * sizeof(Word16), mFp_6ch);
}
mSurroundOutputBufferIdx += SSR_OUTPUT_FRAME_SIZE;
ALOGV("do_while loop: processed=%d, samples=%d\n", processed, samples);
} while (mHandle->handle && processed < samples);
read = processed * sizeof(Word16);
buffer = buffer_start;
} else
#endif
{
do {
if (read_pending < period_size) {
read_pending = period_size;
}
n = pcm_read(mHandle->handle, buffer,
period_size);
ALOGV("pcm_read() returned n = %d", n);
if (n && (n == -EIO || n == -EAGAIN || n == -EPIPE || n == -EBADFD)) {
mParent->mLock.lock();
ALOGW("pcm_read() returned error n %d, Recovering from error\n", n);
pcm_close(mHandle->handle);
mHandle->handle = NULL;
if((!strncmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL, strlen(SND_USE_CASE_VERB_IP_VOICECALL))) ||
(!strncmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP, strlen(SND_USE_CASE_MOD_PLAY_VOIP)))) {
pcm_close(mHandle->rxHandle);
mHandle->rxHandle = NULL;
mHandle->module->startVoipCall(mHandle);
}
else
mHandle->module->open(mHandle);
if(mHandle->handle == NULL) {
ALOGE("read:: PCM device re-open failed");
mParent->mLock.unlock();
return 0;
}
mParent->mLock.unlock();
continue;
}
else if (n < 0) {
ALOGD("pcm_read() returned n < 0");
return static_cast<ssize_t>(n);
}
else {
read += static_cast<ssize_t>((period_size));
read_pending -= period_size;
//Set mute by cleanning buffers read
if (mParent->mMicMute) {
memset(buffer, 0, period_size);
}
buffer = ((uint8_t *)buffer) + period_size;
}
} while (mHandle->handle && read < bytes);
}
return read;
}
status_t AudioStreamInALSA::dump(int fd, const Vector<String16>& args)
{
return NO_ERROR;
}
status_t AudioStreamInALSA::open(int mode)
{
Mutex::Autolock autoLock(mParent->mLock);
status_t status = ALSAStreamOps::open(mode);
return status;
}
status_t AudioStreamInALSA::close()
{
Mutex::Autolock autoLock(mParent->mLock);
ALOGD("close");
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
if((mParent->mVoipStreamCount)) {
#ifdef QCOM_USBAUDIO_ENABLED
ALOGD("musbRecordingState: %d, mVoipStreamCount:%d",mParent->musbRecordingState,
mParent->mVoipStreamCount );
if(mParent->mVoipStreamCount == 1) {
ALOGD("Deregistering VOIP Call bit, musbPlaybackState:%d,"
"musbRecordingState:%d", mParent->musbPlaybackState, mParent->musbRecordingState);
mParent->musbPlaybackState &= ~USBPLAYBACKBIT_VOIPCALL;
mParent->musbRecordingState &= ~USBRECBIT_VOIPCALL;
mParent->closeUsbRecordingIfNothingActive();
mParent->closeUsbPlaybackIfNothingActive();
}
#endif
return NO_ERROR;
}
mParent->mVoipStreamCount = 0;
#ifdef QCOM_USBAUDIO_ENABLED
} else {
ALOGD("Deregistering REC bit, musbRecordingState:%d", mParent->musbRecordingState);
mParent->musbRecordingState &= ~USBRECBIT_REC;
#endif
}
#ifdef QCOM_CSDCLIENT_ENABLED
if (mParent->mFusion3Platform) {
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE))) {
stop_csd_record();
}
}
#endif
ALOGD("close");
#ifdef QCOM_USBAUDIO_ENABLED
mParent->closeUsbRecordingIfNothingActive();
#endif
ALSAStreamOps::close();
#ifdef QCOM_SSR_ENABLED
if (mSurroundObj) {
surround_filters_release(mSurroundObj);
if (mSurroundObj)
free(mSurroundObj);
mSurroundObj = NULL;
if (mRealCoeffs){
for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
if (mRealCoeffs[i]) {
free(mRealCoeffs[i]);
mRealCoeffs[i] = NULL;
}
}
free(mRealCoeffs);
mRealCoeffs = NULL;
}
if (mImagCoeffs){
for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
if (mImagCoeffs[i]) {
free(mImagCoeffs[i]);
mImagCoeffs[i] = NULL;
}
}
free(mImagCoeffs);
mImagCoeffs = NULL;
}
if (mSurroundOutputBuffer){
free(mSurroundOutputBuffer);
mSurroundOutputBuffer = NULL;
}
if (mSurroundInputBuffer) {
free(mSurroundInputBuffer);
mSurroundInputBuffer = NULL;
}
if ( mFp_4ch ) fclose(mFp_4ch);
if ( mFp_6ch ) fclose(mFp_6ch);
}
#endif
return NO_ERROR;
}
status_t AudioStreamInALSA::standby()
{
Mutex::Autolock autoLock(mParent->mLock);
ALOGD("standby");
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
return NO_ERROR;
}
#ifdef QCOM_CSDCLIENT_ENABLED
ALOGD("standby");
if (mParent->mFusion3Platform) {
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_INCALL_REC)) ||
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_CAPTURE_VOICE))) {
ALOGD(" into standby, stop record");
stop_csd_record();
}
}
#endif
mHandle->module->standby(mHandle);
#ifdef QCOM_USBAUDIO_ENABLED
ALOGD("Checking for musbRecordingState %d", mParent->musbRecordingState);
mParent->musbRecordingState &= ~USBRECBIT_REC;
mParent->closeUsbRecordingIfNothingActive();
#endif
if (mHandle->channelMask == AUDIO_CHANNEL_IN_FRONT_BACK) {
mHandle->module->setFlags(mParent->mDevSettingsFlag);
}
return NO_ERROR;
}
void AudioStreamInALSA::resetFramesLost()
{
mFramesLost = 0;
}
unsigned int AudioStreamInALSA::getInputFramesLost() const
{
unsigned int count = mFramesLost;
// Stupid interface wants us to have a side effect of clearing the count
// but is defined as a const to prevent such a thing.
((AudioStreamInALSA *)this)->resetFramesLost();
return count;
}
status_t AudioStreamInALSA::setAcousticParams(void *params)
{
Mutex::Autolock autoLock(mParent->mLock);
return (status_t)NO_ERROR;
}
#ifdef QCOM_SSR_ENABLED
status_t AudioStreamInALSA::initSurroundSoundLibrary(unsigned long buffersize)
{
int subwoofer = 0; // subwoofer channel assignment: default as first microphone input channel
int low_freq = 4; // frequency upper bound for subwoofer: frequency=(low_freq-1)/FFT_SIZE*samplingRate, default as 4
int high_freq = 100; // frequency upper bound for spatial processing: frequency=(high_freq-1)/FFT_SIZE*samplingRate, default as 100
int ret = 0;
mSurroundInputBufferIdx = 0;
mSurroundOutputBufferIdx = 0;
if ( mSurroundObj ) {
ALOGE("ola filter library is already initialized");
return ALREADY_EXISTS;
}
// Allocate memory for input buffer
mSurroundInputBuffer = (Word16 *) calloc(2 * SSR_INPUT_FRAME_SIZE,
sizeof(Word16));
if ( !mSurroundInputBuffer ) {
ALOGE("Memory allocation failure. Not able to allocate memory for surroundInputBuffer");
goto init_fail;
}
// Allocate memory for output buffer
mSurroundOutputBuffer = (Word16 *) calloc(2 * SSR_OUTPUT_FRAME_SIZE,
sizeof(Word16));
if ( !mSurroundOutputBuffer ) {
ALOGE("Memory allocation failure. Not able to allocate memory for surroundOutputBuffer");
goto init_fail;
}
// Allocate memory for real and imag coeffs array
mRealCoeffs = (Word16 **) calloc(COEFF_ARRAY_SIZE, sizeof(Word16 *));
if ( !mRealCoeffs ) {
ALOGE("Memory allocation failure during real Coefficient array");
goto init_fail;
}
mImagCoeffs = (Word16 **) calloc(COEFF_ARRAY_SIZE, sizeof(Word16 *));
if ( !mImagCoeffs ) {
ALOGE("Memory allocation failure during imaginary Coefficient array");
goto init_fail;
}
if( readCoeffsFromFile() != NO_ERROR) {
ALOGE("Error while loading coeffs from file");
goto init_fail;
}
//calculate the size of data to allocate for mSurroundObj
ret = surround_filters_init(NULL,
6, // Num output channel
4, // Num input channel
mRealCoeffs, // Coeffs hardcoded in header
mImagCoeffs, // Coeffs hardcoded in header
subwoofer,
low_freq,
high_freq,
NULL);
if ( ret > 0 ) {
ALOGV("Allocating surroundObj size is %d", ret);
mSurroundObj = (void *)malloc(ret);
memset(mSurroundObj,0,ret);
if (NULL != mSurroundObj) {
//initialize after allocating the memory for mSurroundObj
ret = surround_filters_init(mSurroundObj,
6,
4,
mRealCoeffs,
mImagCoeffs,
subwoofer,
low_freq,
high_freq,
NULL);
if (0 != ret) {
ALOGE("surround_filters_init failed with ret:%d",ret);
surround_filters_release(mSurroundObj);
goto init_fail;
}
} else {
ALOGE("Allocationg mSurroundObj failed");
goto init_fail;
}
} else {
ALOGE("surround_filters_init(mSurroundObj=Null) failed with ret: %d",ret);
goto init_fail;
}
(void) surround_filters_set_channel_map(mSurroundObj, chanMap);
return NO_ERROR;
init_fail:
if (mSurroundObj) {
free(mSurroundObj);
mSurroundObj = NULL;
}
if (mSurroundOutputBuffer) {
free(mSurroundOutputBuffer);
mSurroundOutputBuffer = NULL;
}
if (mSurroundInputBuffer) {
free(mSurroundInputBuffer);
mSurroundInputBuffer = NULL;
}
if (mRealCoeffs){
for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
if (mRealCoeffs[i]) {
free(mRealCoeffs[i]);
mRealCoeffs[i] = NULL;
}
}
free(mRealCoeffs);
mRealCoeffs = NULL;
}
if (mImagCoeffs){
for (int i =0; i<COEFF_ARRAY_SIZE; i++ ) {
if (mImagCoeffs[i]) {
free(mImagCoeffs[i]);
mImagCoeffs[i] = NULL;
}
}
free(mImagCoeffs);
mImagCoeffs = NULL;
}
return NO_MEMORY;
}
// Helper function to read coeffs from File and updates real and imaginary
// coeff array member variable
status_t AudioStreamInALSA::readCoeffsFromFile()
{
FILE *flt1r;
FILE *flt2r;
FILE *flt3r;
FILE *flt4r;
FILE *flt1i;
FILE *flt2i;
FILE *flt3i;
FILE *flt4i;
if ( (flt1r = fopen(SURROUND_FILE_1R, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_1R);
return NAME_NOT_FOUND;
}
if ( (flt2r = fopen(SURROUND_FILE_2R, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_2R);
return NAME_NOT_FOUND;
}
if ( (flt3r = fopen(SURROUND_FILE_3R, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_3R);
return NAME_NOT_FOUND;
}
if ( (flt4r = fopen(SURROUND_FILE_4R, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_4R);
return NAME_NOT_FOUND;
}
if ( (flt1i = fopen(SURROUND_FILE_1I, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_1I);
return NAME_NOT_FOUND;
}
if ( (flt2i = fopen(SURROUND_FILE_2I, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_2I);
return NAME_NOT_FOUND;
}
if ( (flt3i = fopen(SURROUND_FILE_3I, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_3I);
return NAME_NOT_FOUND;
}
if ( (flt4i = fopen(SURROUND_FILE_4I, "rb")) == NULL ) {
ALOGE("Cannot open filter co-efficient file %s", SURROUND_FILE_4I);
return NAME_NOT_FOUND;
}
ALOGV("readCoeffsFromFile all filter files opened");
for (int i=0; i<COEFF_ARRAY_SIZE; i++) {
mRealCoeffs[i] = (Word16 *)calloc(FILT_SIZE, sizeof(Word16));
}
for (int i=0; i<COEFF_ARRAY_SIZE; i++) {
mImagCoeffs[i] = (Word16 *)calloc(FILT_SIZE, sizeof(Word16));
}
// Read real co-efficients
if (NULL != mRealCoeffs[0]) {
fread(mRealCoeffs[0], sizeof(int16), FILT_SIZE, flt1r);
}
if (NULL != mRealCoeffs[0]) {
fread(mRealCoeffs[1], sizeof(int16), FILT_SIZE, flt2r);
}
if (NULL != mRealCoeffs[0]) {
fread(mRealCoeffs[2], sizeof(int16), FILT_SIZE, flt3r);
}
if (NULL != mRealCoeffs[0]) {
fread(mRealCoeffs[3], sizeof(int16), FILT_SIZE, flt4r);
}
// read imaginary co-efficients
if (NULL != mImagCoeffs[0]) {
fread(mImagCoeffs[0], sizeof(int16), FILT_SIZE, flt1i);
}
if (NULL != mImagCoeffs[0]) {
fread(mImagCoeffs[1], sizeof(int16), FILT_SIZE, flt2i);
}
if (NULL != mImagCoeffs[0]) {
fread(mImagCoeffs[2], sizeof(int16), FILT_SIZE, flt3i);
}
if (NULL != mImagCoeffs[0]) {
fread(mImagCoeffs[3], sizeof(int16), FILT_SIZE, flt4i);
}
fclose(flt1r);
fclose(flt2r);
fclose(flt3r);
fclose(flt4r);
fclose(flt1i);
fclose(flt2i);
fclose(flt3i);
fclose(flt4i);
return NO_ERROR;
}
#endif
#ifdef QCOM_CSDCLIENT_ENABLED
int AudioStreamInALSA::start_csd_record(int param)
{
int err = NO_ERROR;
if (mParent->mCsdHandle != NULL) {
csd_start_record = (int (*)(int))::dlsym(mParent->mCsdHandle,"csd_client_start_record");
if (csd_start_record == NULL) {
ALOGE("dlsym:Error:%s Loading csd_client_start_record", dlerror());
} else {
err = csd_start_record(param);
}
}
return err;
}
int AudioStreamInALSA::stop_csd_record()
{
int err = NO_ERROR;
if (mParent->mCsdHandle != NULL) {
csd_stop_record = (int (*)())::dlsym(mParent->mCsdHandle,"csd_client_stop_record");
if (csd_start_record == NULL) {
ALOGE("dlsym:Error:%s Loading csd_client_start_record", dlerror());
} else {
csd_stop_record();
}
}
return err;
}
#endif
} // namespace android_audio_legacy