Google Git
Sign in
android / device / samsung / crespo / refs/tags/android-2.3_r1 / . / libaudio / AudioHardwareALSA.cpp
blob: 45223f3a5ecae39f6479558fc1425e4992480773 [file] [log] [blame]
/* AudioHardwareALSA.cpp
**
** Copyright 2008-2009 Wind River Systems
**
** 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 <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
//#define LOG_NDEBUG 0
#define LOG_TAG "AudioHardwareALSA"
#include <utils/Log.h>
#include <utils/String8.h>
#include <cutils/properties.h>
#include <media/AudioRecord.h>
#include <hardware_legacy/power.h>
#include <alsa/asoundlib.h>
#include "AudioHardwareALSA.h"
// #define READ_FRAME_SIZE 2080
// #define READ_FRAME_SIZE_STANDARD 4160
#include <dlfcn.h>
#define SND_MIXER_VOL_RANGE_MIN (0)
#define SND_MIXER_VOL_RANGE_MAX (100)
#define ALSA_NAME_MAX 128
#define ALSA_STRCAT(x,y) \
if (strlen(x) + strlen(y) < ALSA_NAME_MAX) \
strcat(x, y);
extern "C"
{
extern int ffs(int i);
//
// Make sure this prototype is consistent with what's in
// external/libasound/alsa-lib-1.0.16/src/pcm/pcm_null.c!
//
extern int snd_pcm_null_open(snd_pcm_t **pcmp,
const char *name,
snd_pcm_stream_t stream,
int mode);
//
// Function for dlsym() to look up for creating a new AudioHardwareInterface.
//
android::AudioHardwareInterface *createAudioHardware(void) {
return new android::AudioHardwareALSA();
}
} // extern "C"
namespace android
{
typedef AudioSystem::audio_devices audio_routes;
#define ROUTE_ALL AudioSystem::DEVICE_OUT_ALL
#define ROUTE_EARPIECE AudioSystem::DEVICE_OUT_EARPIECE
#define ROUTE_HEADSET AudioSystem::DEVICE_OUT_WIRED_HEADSET
#define ROUTE_HEADPHONE AudioSystem::DEVICE_OUT_WIRED_HEADPHONE
#define ROUTE_SPEAKER AudioSystem::DEVICE_OUT_SPEAKER
#define ROUTE_BLUETOOTH_SCO AudioSystem::DEVICE_OUT_BLUETOOTH_SCO
#define ROUTE_BLUETOOTH_SCO_HEADSET AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET
#define ROUTE_BLUETOOTH_SCO_CARKIT AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT
#define ROUTE_BLUETOOTH_A2DP AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP
#define ROUTE_BLUETOOTH_A2DP_HEADPHONES AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES
#define ROUTE_BLUETOOTH_A2DP_SPEAKER AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER
// ----------------------------------------------------------------------------
static const char _nullALSADeviceName[] = "NULL_Device";
static void ALSAErrorHandler(const char *file,
int line,
const char *function,
int err,
const char *fmt,
...)
{
char buf[BUFSIZ];
va_list arg;
int l;
va_start(arg, fmt);
l = snprintf(buf, BUFSIZ, "%s:%i:(%s) ", file, line, function);
vsnprintf(buf + l, BUFSIZ - l, fmt, arg);
buf[BUFSIZ-1] = '\0';
LOGE("ALSALib %s.", buf);
va_end(arg);
}
// ----------------------------------------------------------------------------
/* The following table(s) need to match in order of the route bits
*/
static const char *deviceSuffix[] = {
// output devices
/* ROUTE_EARPIECE */ "_Earpiece",
/* ROUTE_SPEAKER */ "_Speaker",
/* ROUTE_HEADSET */ "_Headset",
/* ROUTE_HEADPHONE */ "_Headphone",
/* ROUTE_BLUETOOTH_SCO */ "_Bluetooth",
/* ROUTE_BLUETOOTH_SCO_HEADSET */ "_Bluetooth",
/* ROUTE_BLUETOOTH_SCO_CARKIT */ "_Bluetooth", //"_Bluetooth_Carkit"
/* ROUTE_BLUETOOTH_A2DP */ "_Bluetooth", //"_Bluetooth-A2DP"
/* ROUTE_BLUETOOTH_A2DP_HEADPHONES */ "_Bluetooth", //"_Bluetooth-A2DP_HeadPhone"
/* ROUTE_BLUETOOTH_A2DP_SPEAKER */ "_Bluetooth", // "_Bluetooth-A2DP_Speaker"
/* ROUTE_AUX_DIGITAL */ "_AuxDigital",
/* ROUTE_TV_OUT */ "_TvOut",
/* ROUTE_AUX_DIGITAL */ "_ExtraDockSpeaker",
/* ROUTE_NULL */ "_Null",
/* ROUTE_NULL */ "_Null",
/* ROUTE_DEFAULT */ "_OutDefault",
// input devices
/* ROUTE_COMMUNICATION */ "_Communication",
/* ROUTE_AMBIENT */ "_Ambient",
/* ROUTE_BUILTIN_MIC */ "_Speaker",
/* ROUTE_BLUETOOTH_SCO_HEADSET */ "_Bluetooth",
/* ROUTE_WIRED_HEADSET */ "_Headset",
/* ROUTE_AUX_DIGITAL */ "_AuxDigital",
/* ROUTE_VOICE_CALL */ "_VoiceCall",
/* ROUTE_BACK_MIC */ "_BackMic",
/* ROUTE_IN_DEFAULT */ "_InDefault",
};
static const int deviceSuffixLen = (sizeof(deviceSuffix) / sizeof(char *));
struct mixer_info_t;
struct alsa_properties_t
{
const audio_routes routes;
const char *propName;
const char *propDefault;
mixer_info_t *mInfo;
};
static alsa_properties_t masterPlaybackProp = {
ROUTE_ALL, "alsa.mixer.playback.master", "PCM", NULL
};
static alsa_properties_t masterCaptureProp = {
ROUTE_ALL, "alsa.mixer.capture.master", "Capture", NULL
};
static alsa_properties_t
mixerMasterProp[SND_PCM_STREAM_LAST+1] = {
{ ROUTE_ALL, "alsa.mixer.playback.master", "PCM", NULL},
{ ROUTE_ALL, "alsa.mixer.capture.master", "Capture", NULL}
};
static alsa_properties_t
mixerProp[][SND_PCM_STREAM_LAST+1] = {
{
{ROUTE_EARPIECE, "alsa.mixer.playback.earpiece", "Earpiece", NULL},
{ROUTE_EARPIECE, "alsa.mixer.capture.earpiece", "Capture", NULL}
},
{
{ROUTE_SPEAKER, "alsa.mixer.playback.speaker", "Speaker", NULL},
{ROUTE_SPEAKER, "alsa.mixer.capture.speaker", "", NULL}
},
{
{ROUTE_BLUETOOTH_SCO, "alsa.mixer.playback.bluetooth.sco", "Bluetooth", NULL},
{ROUTE_BLUETOOTH_SCO, "alsa.mixer.capture.bluetooth.sco", "Bluetooth Capture", NULL}
},
{
{ROUTE_HEADSET, "alsa.mixer.playback.headset", "Headphone", NULL},
{ROUTE_HEADSET, "alsa.mixer.capture.headset", "Capture", NULL}
},
{
{ROUTE_BLUETOOTH_A2DP, "alsa.mixer.playback.bluetooth.a2dp", "Bluetooth A2DP", NULL},
{ROUTE_BLUETOOTH_A2DP, "alsa.mixer.capture.bluetooth.a2dp", "Bluetooth A2DP Capture", NULL}
},
{
{static_cast<audio_routes>(0), NULL, NULL, NULL},
{static_cast<audio_routes>(0), NULL, NULL, NULL}
}
};
const uint32_t AudioHardwareALSA::inputSamplingRates[] = {
8000, 11025, 16000, 22050, 44100
};
// ----------------------------------------------------------------------------
AudioHardwareALSA::AudioHardwareALSA() :
mOutput(0),
mInput(0),
mSecRilLibHandle(NULL),
mRilClient(0),
mVrModeEnabled(false),
mActivatedCP(false),
mBluetoothECOff(false)
{
snd_lib_error_set_handler(&ALSAErrorHandler);
mMixer = new ALSAMixer;
loadRILD();
}
AudioHardwareALSA::~AudioHardwareALSA()
{
if (mOutput) delete mOutput;
if (mInput) delete mInput;
if (mMixer) delete mMixer;
if (mSecRilLibHandle) {
if (disconnectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS)
LOGE("Disconnect_RILD() error");
if (closeClientRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS)
LOGE("CloseClient_RILD() error");
mRilClient = 0;
dlclose(mSecRilLibHandle);
mSecRilLibHandle = NULL;
}
}
void AudioHardwareALSA::loadRILD(void)
{
mSecRilLibHandle = dlopen("libsecril-client.so", RTLD_NOW);
if (mSecRilLibHandle) {
LOGV("libsecril-client.so is loaded");
openClientRILD = (HRilClient (*)(void))
dlsym(mSecRilLibHandle, "OpenClient_RILD");
disconnectRILD = (int (*)(HRilClient))
dlsym(mSecRilLibHandle, "Disconnect_RILD");
closeClientRILD = (int (*)(HRilClient))
dlsym(mSecRilLibHandle, "CloseClient_RILD");
isConnectedRILD = (int (*)(HRilClient))
dlsym(mSecRilLibHandle, "isConnected_RILD");
connectRILD = (int (*)(HRilClient))
dlsym(mSecRilLibHandle, "Connect_RILD");
setCallVolume = (int (*)(HRilClient, SoundType, int))
dlsym(mSecRilLibHandle, "SetCallVolume");
setCallAudioPath = (int (*)(HRilClient, AudioPath))
dlsym(mSecRilLibHandle, "SetCallAudioPath");
setCallClockSync = (int (*)(HRilClient, SoundClockCondition))
dlsym(mSecRilLibHandle, "SetCallClockSync");
if (!openClientRILD || !disconnectRILD || !closeClientRILD ||
!isConnectedRILD || !connectRILD ||
!setCallVolume || !setCallAudioPath || !setCallClockSync) {
LOGE("Can't load all functions from libsecril-client.so");
dlclose(mSecRilLibHandle);
mSecRilLibHandle = NULL;
} else {
mRilClient = openClientRILD();
if (!mRilClient) {
LOGE("OpenClient_RILD() error");
dlclose(mSecRilLibHandle);
mSecRilLibHandle = NULL;
}
}
} else {
LOGE("Can't load libsecril-client.so");
}
}
status_t AudioHardwareALSA::initCheck()
{
if (mMixer && mMixer->isValid())
return NO_ERROR;
else
return NO_INIT;
}
status_t AudioHardwareALSA::connectRILDIfRequired(void)
{
if (!mSecRilLibHandle) {
LOGE("connectIfRequired() lib is not loaded");
return INVALID_OPERATION;
}
if (isConnectedRILD(mRilClient)) {
return OK;
}
if (connectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) {
LOGE("Connect_RILD() error");
return INVALID_OPERATION;
}
return OK;
}
status_t AudioHardwareALSA::setVoiceVolume(float volume)
{
LOGI("### setVoiceVolume");
AutoMutex lock(mLock);
// sangsu fix : transmic volume level IPC to modem
if ( (AudioSystem::MODE_IN_CALL == mMode) && (mSecRilLibHandle) &&
(connectRILDIfRequired() == OK) ) {
uint32_t routes = AudioSystem::ROUTE_EARPIECE;
if (mOutput != NULL) {
routes = mOutput->device();
}
int int_volume = (int)(volume * 5);
LOGI("### route(%d) call volume(%f)", routes, volume);
switch (routes) {
case AudioSystem::ROUTE_EARPIECE:
LOGI("### earpiece call volume");
setCallVolume(mRilClient, SOUND_TYPE_VOICE, int_volume);
break;
case AudioSystem::ROUTE_SPEAKER:
LOGI("### speaker call volume");
setCallVolume(mRilClient, SOUND_TYPE_SPEAKER, int_volume);
break;
case AudioSystem::ROUTE_BLUETOOTH_SCO:
case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
case AudioSystem::ROUTE_BLUETOOTH_A2DP:
LOGI("### bluetooth call volume");
setCallVolume(mRilClient, SOUND_TYPE_BTVOICE, int_volume);
break;
case AudioSystem::ROUTE_HEADSET:
case AudioSystem::ROUTE_HEADPHONE: // Use receive path with 3 pole headset.
LOGI("### headset call volume");
setCallVolume(mRilClient, SOUND_TYPE_HEADSET, int_volume);
break;
default:
LOGE("### Call volume setting error!!!0x%08x \n", routes);
break;
}
}
// sangsu fix end
// The voice volume is used by the VOICE_CALL audio stream.
if (mMixer)
return mMixer->setVolume(ROUTE_EARPIECE, volume);
else
return INVALID_OPERATION;
}
status_t AudioHardwareALSA::setMasterVolume(float volume)
{
if (mMixer)
return mMixer->setMasterVolume(volume);
else
return INVALID_OPERATION;
}
AudioStreamOut *
AudioHardwareALSA::openOutputStream(
uint32_t devices,
int *format,
uint32_t *channels,
uint32_t *sampleRate,
status_t *status)
{
AudioStreamOutALSA *out = NULL;
status_t ret = NO_ERROR;
{
AutoMutex lock(mLock);
// only one output stream allowed
if (mOutput) {
ret = ALREADY_EXISTS;
goto exit;
}
LOGV("[[[[[[[[\n%s - format = %d, channels = %d, sampleRate = %d, devices = %d]]]]]]]]\n", __func__, *format, *channels, *sampleRate,devices);
out = new AudioStreamOutALSA(this);
ret = out->set(format, channels, sampleRate);
if (ret == NO_ERROR) {
mOutput = out;
}
}
exit:
if (ret == NO_ERROR) {
// Some information is expected to be available immediately after
// the device is open.
/* Tushar - Sets the current device output here - we may set device here */
LOGI("%s] Setting ALSA device.", __func__);
mOutput->setDevice(mMode, devices, PLAYBACK); /* tushar - Enable all devices as of now */
} else if (out) {
delete out;
}
if (status) {
*status = ret;
}
return mOutput;
}
void
AudioHardwareALSA::closeOutputStream(AudioStreamOut* out)
{
/* TODO:Tushar: May lead to segmentation fault - check*/
//delete out;
{
AutoMutex lock(mLock);
if (mOutput == 0 || mOutput != out) {
LOGW("Attempt to close invalid output stream");
return;
}
mOutput = 0;
}
delete out;
}
AudioStreamIn*
AudioHardwareALSA::openInputStream(
uint32_t devices,
int *format,
uint32_t *channels,
uint32_t *sampleRate,
status_t *status,
AudioSystem::audio_in_acoustics acoustics)
{
AudioStreamInALSA *in = NULL;
status_t ret = NO_ERROR;
{
AutoMutex lock(mLock);
// only one input stream allowed
if (mInput) {
ret = ALREADY_EXISTS;
goto exit;
}
in = new AudioStreamInALSA(this);
ret = in->set(format, channels, sampleRate);
if (ret == NO_ERROR) {
mInput = in;
}
}
exit:
if (ret == NO_ERROR) {
// Some information is expected to be available immediately after
// the device is open.
mInput->setDevice(mMode, devices, CAPTURE); /* Tushar - as per modified arch */
} else if (in != NULL) {
delete in;
}
if (status) {
*status = ret;
}
return mInput;
}
void
AudioHardwareALSA::closeInputStream(AudioStreamIn* in)
{
/* TODO:Tushar: May lead to segmentation fault - check*/
//delete in;
{
AutoMutex lock(mLock);
if (mInput == 0 || mInput != in) {
LOGW("Attempt to close invalid input stream");
return;
} else {
mInput = 0;
}
}
delete in;
}
status_t AudioHardwareALSA::doRouting(uint32_t device, bool force)
{
AutoMutex lock(mLock);
return doRouting_l(device, force);
}
status_t AudioHardwareALSA::doRouting_l(uint32_t device, bool force)
{
status_t ret;
int mode = mMode; // Prevent to changing mode on setup sequence.
LOGV("doRouting: device %x, force %d", device, force);
if (mOutput) {
//device = 0; /* Tushar - temp implementation */
if (device == AudioSystem::DEVICE_OUT_DEFAULT) {
device = mOutput->device();
}
// Setup sound path for CP clocking
if ( (AudioSystem::MODE_IN_CALL == mode) && (mSecRilLibHandle) &&
(connectRILDIfRequired() == OK) ) {
LOGI("### incall mode route (%d)", device);
switch(device){
case AudioSystem::ROUTE_EARPIECE:
LOGI("### incall mode earpiece route");
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_HANDSET);
break;
case AudioSystem::ROUTE_SPEAKER:
LOGI("### incall mode speaker route");
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_SPEAKER);
break;
case AudioSystem::ROUTE_BLUETOOTH_SCO:
case AudioSystem::ROUTE_BLUETOOTH_SCO_HEADSET:
case AudioSystem::ROUTE_BLUETOOTH_SCO_CARKIT:
LOGI("### incall mode bluetooth route %s NR", mBluetoothECOff ? "NO" : "");
if (mBluetoothECOff)
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_BLUETOOTH_NO_NR);
else
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_BLUETOOTH);
break;
case AudioSystem::ROUTE_HEADSET :
case AudioSystem::ROUTE_HEADPHONE :
LOGI("### incall mode headset route");
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_HEADSET);
break;
case AudioSystem::ROUTE_BLUETOOTH_A2DP:
LOGI("### incall mode bluetooth route");
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_BLUETOOTH);
break;
default:
LOGE("### incall mode Error!! route = [%d]", device);
break;
}
}
ret = mOutput->setDevice(mode, device, PLAYBACK, force);
return ret;
}
return NO_INIT;
}
status_t AudioHardwareALSA::setMicMute(bool state)
{
if (mMixer)
return mMixer->setCaptureMuteState(ROUTE_EARPIECE, state);
return NO_INIT;
}
status_t AudioHardwareALSA::getMicMute(bool *state)
{
if (mMixer)
return mMixer->getCaptureMuteState(ROUTE_EARPIECE, state);
return NO_ERROR;
}
status_t AudioHardwareALSA::dump(int fd, const Vector<String16>& args)
{
return NO_ERROR;
}
uint32_t AudioHardwareALSA::bufferRatio(uint32_t samplingRate) {
switch (samplingRate) {
case 8000:
case 11025:
return 4;
case 16000:
case 22050:
return 2;
case 44100:
default:
break;
}
return 1;
}
size_t AudioHardwareALSA::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
{
if (sampleRate != 8000 && sampleRate != 11025 && sampleRate != 16000 &&
sampleRate != 22050 && sampleRate != 44100) {
LOGW("getInputBufferSize bad sampling rate: %d", sampleRate);
return 0;
}
if (format != AudioSystem::PCM_16_BIT) {
LOGW("getInputBufferSize bad format: %d", format);
return 0;
}
if (channelCount != 1) {
LOGW("getInputBufferSize bad channel count: %d", channelCount);
return 0;
}
size_t size = (PERIOD_SZ_CAPTURE / bufferRatio(sampleRate)) * sizeof(int16_t);
LOGV("getInputBufferSize() rate %d, ratio %d", sampleRate, size);
return size;
}
uint32_t AudioHardwareALSA::checkInputSampleRate(uint32_t sampleRate)
{
uint32_t i;
uint32_t prevDelta;
uint32_t delta;
for (i = 0, prevDelta = 0xFFFFFFFF; i < sizeof(inputSamplingRates)/sizeof(uint32_t); i++, prevDelta = delta) {
delta = abs(sampleRate - inputSamplingRates[i]);
if (delta > prevDelta) break;
}
// i is always > 0 here
return inputSamplingRates[i-1];
}
status_t AudioHardwareALSA::setMode(int mode)
{
AutoMutex lock(mLock);
int prevMode = mMode;
status_t status = AudioHardwareBase::setMode(mode);
LOGV("setMode() : new %d, old %d", mMode, prevMode);
if (status == NO_ERROR) {
if ( (mMode == AudioSystem::MODE_RINGTONE) || (mMode == AudioSystem::MODE_IN_CALL) )
{
if ( (!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK) ) {
setCallClockSync(mRilClient, SOUND_CLOCK_START);
mActivatedCP = true;
}
}
// make sure that doAudioRouteOrMute() is called by doRouting()
// when entering or exiting in call mode even if the new device
// selected is the same as current one.
if ((prevMode != AudioSystem::MODE_IN_CALL) && (mMode == AudioSystem::MODE_IN_CALL)) {
LOGV("setMode() entering call");
doRouting_l(AudioSystem::DEVICE_OUT_DEFAULT, true);
setVoiceRecordGain_l(false);
}
if ((prevMode == AudioSystem::MODE_IN_CALL) && (mMode != AudioSystem::MODE_IN_CALL)) {
LOGV("setMode() exiting call");
doRouting_l(AudioSystem::DEVICE_OUT_DEFAULT, true);
if (mOutput != NULL && !mOutput->isActive()) {
mOutput->close();
}
}
if (mMode == AudioSystem::MODE_NORMAL) {
if(mActivatedCP)
mActivatedCP = false;
}
}
return status;
}
int AudioHardwareALSA::setVoiceRecordGain(bool enable)
{
AutoMutex lock(mLock);
return setVoiceRecordGain_l(enable);
}
int AudioHardwareALSA::setVoiceRecordGain_l(bool enable)
{
LOGI("[%s], enable=%d", __func__, enable);
if (enable != mVrModeEnabled &&
!(enable && (mMode == AudioSystem::MODE_IN_CALL))) {
ALSAControl *alsaControl = new ALSAControl();
status_t ret = alsaControl->set("Recognition Control", enable ? RECOGNITION_ON : RECOGNITION_OFF);
delete alsaControl;
mVrModeEnabled = enable;
}
return NO_ERROR;
}
status_t AudioHardwareALSA::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 bt_nrec_key = String8("bt_headset_nrec");
String8 value;
LOGV("setParameters(%s)", keyValuePairs.string());
if (param.get(bt_nrec_key, value) == NO_ERROR) {
setBluetoothNrEcOnOff((value == "on") ? false : true);
}
return NO_ERROR;
}
void AudioHardwareALSA::setBluetoothNrEcOnOff(bool disable)
{
LOGV("setBluetoothNrEcOnOff(%s)", disable ? "true" : "false");
if (disable != mBluetoothECOff)
{
mBluetoothECOff = disable;
if ( (mOutput) && (AudioSystem::MODE_IN_CALL == mMode) &&
(mSecRilLibHandle) && (connectRILDIfRequired() == OK)) {
uint32_t device = mOutput->device();
switch (device) {
case AudioSystem::ROUTE_BLUETOOTH_SCO:
case AudioSystem::ROUTE_BLUETOOTH_SCO_HEADSET:
case AudioSystem::ROUTE_BLUETOOTH_SCO_CARKIT:
LOGV("### incall mode bluetooth EC %s route", mBluetoothECOff ? "OFF" : "ON");
if (mBluetoothECOff)
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_BLUETOOTH_NO_NR);
else
setCallAudioPath(mRilClient, SOUND_AUDIO_PATH_BLUETOOTH);
break;
default :
LOGE("Bluetooth path is not activated!!");
break;
}
}
}
}
// ----------------------------------------------------------------------------
ALSAStreamOps::ALSAStreamOps() :
mHandle(0),
mHardwareParams(0),
mSoftwareParams(0),
mDevice(0)
{
if (snd_pcm_hw_params_malloc(&mHardwareParams) < 0) {
LOG_ALWAYS_FATAL("Failed to allocate ALSA hardware parameters!");
}
if (snd_pcm_sw_params_malloc(&mSoftwareParams) < 0) {
LOG_ALWAYS_FATAL("Failed to allocate ALSA software parameters!");
}
}
ALSAStreamOps::~ALSAStreamOps()
{
AutoMutex lock(mLock);
close();
if (mHardwareParams)
snd_pcm_hw_params_free(mHardwareParams);
if (mSoftwareParams)
snd_pcm_sw_params_free(mSoftwareParams);
}
status_t ALSAStreamOps::set(int *pformat,
uint32_t *pchannels,
uint32_t *prate)
{
int lformat = pformat ? *pformat : 0;
unsigned int lchannels = pchannels ? *pchannels : 0;
unsigned int lrate = prate ? *prate : 0;
LOGD("ALSAStreamOps - input - format = %d, channels = %d, rate = %d\n", lformat, lchannels, lrate);
LOGD("ALSAStreamOps - default - format = %d, channelCount = %d, rate = %d\n", mDefaults->format, mDefaults->channelCount, mDefaults->sampleRate);
if (lformat == 0) lformat = getAndroidFormat(mDefaults->format);//format();
if (lchannels == 0) lchannels = getAndroidChannels(mDefaults->channelCount);// channelCount();
if (lrate == 0) lrate = mDefaults->sampleRate;
if ( (lformat != getAndroidFormat(mDefaults->format)) ||
(lchannels != getAndroidChannels(mDefaults->channelCount)) ) {
if (pformat) *pformat = getAndroidFormat(mDefaults->format);
if (pchannels) *pchannels = getAndroidChannels(mDefaults->channelCount);
return BAD_VALUE;
}
if (mDefaults->direction == SND_PCM_STREAM_PLAYBACK) {
if (lrate != mDefaults->sampleRate) {
if (prate) *prate = mDefaults->sampleRate;
return BAD_VALUE;
}
} else {
uint32_t rate = AudioHardwareALSA::checkInputSampleRate(lrate);
if (rate != lrate) {
if (prate) *prate = rate;
return BAD_VALUE;
}
lrate = rate;
}
mDefaults->bufferRatio = AudioHardwareALSA::bufferRatio(lrate);
mDefaults->sampleRate = lrate;
if(pformat) *pformat = getAndroidFormat(mDefaults->format);
if(pchannels) *pchannels = getAndroidChannels(mDefaults->channelCount);
if(prate) *prate = mDefaults->sampleRate;
return NO_ERROR;
}
uint32_t ALSAStreamOps::sampleRate() const
{
return mDefaults->sampleRate;
}
status_t ALSAStreamOps::sampleRate(uint32_t rate)
{
const char *stream;
unsigned int requestedRate;
int err;
if (!mHandle)
return NO_INIT;
stream = streamName();
requestedRate = rate;
err = snd_pcm_hw_params_set_rate_near(mHandle,
mHardwareParams,
&requestedRate,
0);
if (err < 0) {
LOGE("Unable to set %s sample rate to %u: %s",
stream, rate, snd_strerror(err));
return BAD_VALUE;
}
if (requestedRate != rate) {
// Some devices have a fixed sample rate, and can not be changed.
// This may cause resampling problems; i.e. PCM playback will be too
// slow or fast.
LOGW("Requested rate (%u HZ) does not match actual rate (%u HZ)",
rate, requestedRate);
}
else {
LOGD("Set %s sample rate to %u HZ", stream, requestedRate);
}
return NO_ERROR;
}
//
// Return the number of bytes (not frames)
//
size_t ALSAStreamOps::bufferSize() const
{
int err;
size_t size = ((mDefaults->periodSize / mDefaults->bufferRatio) * mDefaults->channelCount *
snd_pcm_format_physical_width(mDefaults->format)) / 8;
LOGV("bufferSize() channelCount %d, bufferRatio %d, size %d",
mDefaults->channelCount, mDefaults->bufferRatio, size);
return size;
}
int ALSAStreamOps::getAndroidFormat(snd_pcm_format_t format)
{
int pcmFormatBitWidth;
int audioSystemFormat;
pcmFormatBitWidth = snd_pcm_format_physical_width(format);
audioSystemFormat = AudioSystem::DEFAULT;
switch(pcmFormatBitWidth) {
case 8:
audioSystemFormat = AudioSystem::PCM_8_BIT;
break;
case 16:
audioSystemFormat = AudioSystem::PCM_16_BIT;
break;
default:
LOG_FATAL("Unknown AudioSystem bit width %i!", pcmFormatBitWidth);
}
return audioSystemFormat;
}
int ALSAStreamOps::format() const
{
snd_pcm_format_t ALSAFormat;
int pcmFormatBitWidth;
int audioSystemFormat;
if (snd_pcm_hw_params_get_format(mHardwareParams, &ALSAFormat) < 0) {
return -1;
}
pcmFormatBitWidth = snd_pcm_format_physical_width(ALSAFormat);
audioSystemFormat = AudioSystem::DEFAULT;
switch(pcmFormatBitWidth) {
case 8:
audioSystemFormat = AudioSystem::PCM_8_BIT;
break;
case 16:
audioSystemFormat = AudioSystem::PCM_16_BIT;
break;
default:
LOG_FATAL("Unknown AudioSystem bit width %i!", pcmFormatBitWidth);
}
return audioSystemFormat;
}
uint32_t ALSAStreamOps::getAndroidChannels(int channelCount) const
{
int AudioSystemChannels = AudioSystem::DEFAULT;
if (mDefaults->direction == SND_PCM_STREAM_PLAYBACK) {
switch(channelCount){
case 1:
AudioSystemChannels = AudioSystem::CHANNEL_OUT_MONO;
break;
case 2:
AudioSystemChannels = AudioSystem::CHANNEL_OUT_STEREO;
break;
case 4:
AudioSystemChannels = AudioSystem::CHANNEL_OUT_QUAD;
break;
case 6:
AudioSystemChannels = AudioSystem::CHANNEL_OUT_5POINT1;
break;
default:
LOGE("FATAL: AudioSystem does not support %d output channels.", channelCount);
}
} else {
switch(channelCount){
case 1:
AudioSystemChannels = AudioSystem::CHANNEL_IN_MONO;
break;
case 2:
AudioSystemChannels = AudioSystem::CHANNEL_IN_STEREO;
break;
default:
LOGE("FATAL: AudioSystem does not support %d input channels.", channelCount);
}
}
return AudioSystemChannels;
}
uint32_t ALSAStreamOps::channels() const
{
return getAndroidChannels(mDefaults->channelCount);
}
int ALSAStreamOps::channelCount() const
{
return mDefaults->channelCount;
}
status_t ALSAStreamOps::channelCount(int channelCount) {
int err;
if (!mHandle)
return NO_INIT;
err = snd_pcm_hw_params_set_channels(mHandle, mHardwareParams, channelCount);
if (err < 0) {
LOGE("Unable to set channel count to %i: %s",
channelCount, snd_strerror(err));
return BAD_VALUE;
}
LOGD("Using %i %s for %s.",
channelCount, channelCount == 1 ? "channel" : "channels", streamName());
return NO_ERROR;
}
status_t ALSAStreamOps::open(int mode, uint32_t device)
{
const char *stream = streamName();
const char *devName = deviceName(mode, device);
int err;
LOGI("Try to open ALSA %s device %s", stream, devName);
for(;;) {
// The PCM stream is opened in blocking mode, per ALSA defaults. The
// AudioFlinger seems to assume blocking mode too, so asynchronous mode
// should not be used.
err = snd_pcm_open(&mHandle, devName, mDefaults->direction, 0);
if (err == 0) break;
// See if there is a less specific name we can try.
// Note: We are changing the contents of a const char * here.
char *tail = strrchr(devName, '_');
if (! tail) break;
*tail = 0;
}
if (err < 0) {
// None of the Android defined audio devices exist. Open a generic one.
devName = "hw:00,1"; // 090507 SMDKC110 Froyo
err = snd_pcm_open(&mHandle, devName, mDefaults->direction, 0);
if (err < 0) {
// Last resort is the NULL device (i.e. the bit bucket).
devName = _nullALSADeviceName;
err = snd_pcm_open(&mHandle, devName, mDefaults->direction, 0);
}
}
mDevice = device;
LOGI("Initialized ALSA %s device %s", stream, devName);
return err;
}
void ALSAStreamOps::close()
{
snd_pcm_t *handle = mHandle;
mHandle = NULL;
if (handle) {
LOGV("ALSAStreamOps::close()");
snd_pcm_drain(handle);
snd_pcm_close(handle);
}
}
status_t ALSAStreamOps::setSoftwareParams()
{
if (!mHandle)
return NO_INIT;
int err;
// Get the current software parameters
err = snd_pcm_sw_params_current(mHandle, mSoftwareParams);
if (err < 0) {
LOGE("Unable to get software parameters: %s", snd_strerror(err));
return NO_INIT;
}
snd_pcm_uframes_t bufferSize = 0;
snd_pcm_uframes_t periodSize = 0;
snd_pcm_uframes_t startThreshold;
// Configure ALSA to start the transfer when the buffer is almost full.
snd_pcm_get_params(mHandle, &bufferSize, &periodSize);
LOGE("bufferSize %d, periodSize %d\n", (int)bufferSize, (int)periodSize);
if (mDefaults->direction == SND_PCM_STREAM_PLAYBACK) {
// For playback, configure ALSA to start the transfer when the
// buffer is almost full.
startThreshold = (bufferSize / periodSize) * periodSize;
//startThreshold = 1;
}
else {
// For recording, configure ALSA to start the transfer on the
// first frame.
startThreshold = 1;
}
err = snd_pcm_sw_params_set_start_threshold(mHandle,
mSoftwareParams,
startThreshold);
if (err < 0) {
LOGE("Unable to set start threshold to %lu frames: %s",
startThreshold, snd_strerror(err));
return NO_INIT;
}
// Stop the transfer when the buffer is full.
err = snd_pcm_sw_params_set_stop_threshold(mHandle,
mSoftwareParams,
bufferSize);
if (err < 0) {
LOGE("Unable to set stop threshold to %lu frames: %s",
bufferSize, snd_strerror(err));
return NO_INIT;
}
// Allow the transfer to start when at least periodSize samples can be
// processed.
err = snd_pcm_sw_params_set_avail_min(mHandle,
mSoftwareParams,
periodSize);
if (err < 0) {
LOGE("Unable to configure available minimum to %lu: %s",
periodSize, snd_strerror(err));
return NO_INIT;
}
// Commit the software parameters back to the device.
err = snd_pcm_sw_params(mHandle, mSoftwareParams);
if (err < 0) {
LOGE("Unable to configure software parameters: %s",
snd_strerror(err));
return NO_INIT;
}
return NO_ERROR;
}
status_t ALSAStreamOps::setPCMFormat(snd_pcm_format_t format)
{
const char *formatDesc;
const char *formatName;
bool validFormat;
int err;
// snd_pcm_format_description() and snd_pcm_format_name() do not perform
// proper bounds checking.
validFormat = (static_cast<int>(format) > SND_PCM_FORMAT_UNKNOWN) &&
(static_cast<int>(format) <= SND_PCM_FORMAT_LAST);
formatDesc = validFormat ?
snd_pcm_format_description(format) : "Invalid Format";
formatName = validFormat ?
snd_pcm_format_name(format) : "UNKNOWN";
err = snd_pcm_hw_params_set_format(mHandle, mHardwareParams, format);
if (err < 0) {
LOGE("Unable to configure PCM format %s (%s): %s",
formatName, formatDesc, snd_strerror(err));
return NO_INIT;
}
LOGD("Set %s PCM format to %s (%s)", streamName(), formatName, formatDesc);
return NO_ERROR;
}
status_t ALSAStreamOps::setHardwareResample(bool resample)
{
int err;
err = snd_pcm_hw_params_set_rate_resample(mHandle,
mHardwareParams,
static_cast<int>(resample));
if (err < 0) {
LOGE("Unable to %s hardware resampling: %s",
resample ? "enable" : "disable",
snd_strerror(err));
return NO_INIT;
}
return NO_ERROR;
}
const char *ALSAStreamOps::streamName()
{
// Don't use snd_pcm_stream(mHandle), as the PCM stream may not be
// opened yet. In such case, snd_pcm_stream() will abort().
return snd_pcm_stream_name(mDefaults->direction);
}
//
// Set playback or capture PCM device. It's possible to support audio output
// or input from multiple devices by using the ALSA plugins, but this is
// not supported for simplicity.
//
// The AudioHardwareALSA API does not allow one to set the input routing.
//
// If the "routes" value does not map to a valid device, the default playback
// device is used.
//
status_t ALSAStreamOps::setDevice(int mode, uint32_t device, uint audio_mode)
{
// Close off previously opened device.
// It would be nice to determine if the underlying device actually
// changes, but we might be manipulating mixer settings (see asound.conf).
//
close();
const char *stream = streamName();
LOGD("\n------------------------>>>>>> ALSA OPEN mode %d,device %d \n",mode,device);
status_t status = open (mode, device);
int err;
unsigned int period_val;
if (status != NO_ERROR)
return status;
err = snd_pcm_hw_params_any(mHandle, mHardwareParams);
if (err < 0) {
LOGE("Unable to configure hardware: %s", snd_strerror(err));
return NO_INIT;
}
status = setPCMFormat(mDefaults->format);
// Set the interleaved read and write format.
err = snd_pcm_hw_params_set_access(mHandle, mHardwareParams,
SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
LOGE("Unable to configure PCM read/write format: %s",
snd_strerror(err));
return NO_INIT;
}
//
// Some devices do not have the default two channels. Force an error to
// prevent AudioMixer from crashing and taking the whole system down.
//
// Note that some devices will return an -EINVAL if the channel count
// is queried before it has been set. i.e. calling channelCount()
// before channelCount(channels) may return -EINVAL.
//
status = channelCount(mDefaults->channelCount);
if (status != NO_ERROR)
return status;
// Don't check for failure; some devices do not support the default
// sample rate.
// FIXME:: always use default sampling rate
sampleRate(DEFAULT_SAMPLE_RATE);
snd_pcm_uframes_t bufferSize = mDefaults->bufferSize;
snd_pcm_uframes_t periodSize = mDefaults->periodSize;
period_val = bufferSize/periodSize;
unsigned int latency = mDefaults->latency;
// Make sure we have at least the size we originally wanted
err = snd_pcm_hw_params_set_buffer_size(mHandle, mHardwareParams, bufferSize);
if (err < 0) {
LOGE("Unable to set buffer size to %d: %s",
(int)bufferSize, snd_strerror(err));
return NO_INIT;
}
err = snd_pcm_hw_params_set_period_size (mHandle, mHardwareParams, periodSize, NULL);
if (err < 0) {
LOGE("Unable to set the period size for latency: %s", snd_strerror(err));
return NO_INIT;
}
err = snd_pcm_hw_params_get_period_size (mHardwareParams, &periodSize, NULL);
if (err < 0) {
LOGE("Unable to get the period size for latency: %s", snd_strerror(err));
return NO_INIT;
}
// err = snd_pcm_hw_params_get_period_size (mHardwareParams, &periodSize, NULL);
// if (err < 0) {
// LOGE("Unable to get the period size for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// // Setup buffers for latency
// err = snd_pcm_hw_params_set_buffer_time_near (mHandle, mHardwareParams,
// &latency, NULL);
// if(audio_mode == PLAYBACK) {
// period_val = PERIODS_PLAYBACK;
// if(snd_pcm_hw_params_set_periods(mHandle, mHardwareParams, period_val, 0) < 0)
// LOGE("Fail to set period size %d for playback", period_val);
// }
// else
// period_val = PERIODS_CAPTURE;
//
// if (err < 0) {
// LOGD("snd_pcm_hw_params_set_buffer_time_near() failed: %s", snd_strerror(err));
// /* That didn't work, set the period instead */
// unsigned int periodTime = latency / period_val;
// err = snd_pcm_hw_params_set_period_time_near (mHandle, mHardwareParams,
// &periodTime, NULL);
// if (err < 0) {
// LOGE("Unable to set the period time for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// err = snd_pcm_hw_params_get_period_size (mHardwareParams, &periodSize, NULL);
// if (err < 0) {
// LOGE("Unable to get the period size for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// bufferSize = periodSize * period_val;
// if (bufferSize < mDefaults->bufferSize)
// bufferSize = mDefaults->bufferSize;
// err = snd_pcm_hw_params_set_buffer_size_near (mHandle, mHardwareParams, &bufferSize);
// if (err < 0) {
// LOGE("Unable to set the buffer size for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// } else {
// LOGD("snd_pcm_hw_params_set_buffer_time_near() OK");
// // OK, we got buffer time near what we expect. See what that did for bufferSize.
// err = snd_pcm_hw_params_get_buffer_size (mHardwareParams, &bufferSize);
// if (err < 0) {
// LOGE("Unable to get the buffer size for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// // Does set_buffer_time_near change the passed value? It should.
// err = snd_pcm_hw_params_get_buffer_time (mHardwareParams, &latency, NULL);
// if (err < 0) {
// LOGE("Unable to get the buffer time for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// LOGD("got latency %d for bufferSize %d", latency, bufferSize);
// unsigned int periodTime = latency / period_val;
// LOGD("got latency %d for bufferSize %d => periodTime %d", latency, bufferSize, periodTime);
// err = snd_pcm_hw_params_set_period_time_near (mHandle, mHardwareParams,
// &periodTime, NULL);
// if (err < 0) {
// LOGE("Unable to set the period time for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// err = snd_pcm_hw_params_get_period_size (mHardwareParams, &periodSize, NULL);
// if (err < 0) {
// LOGE("Unable to get the period size for latency: %s", snd_strerror(err));
// return NO_INIT;
// }
// }
LOGD("Buffer size: %d", (int)bufferSize);
LOGD("Period size: %d", (int)periodSize);
LOGD("Latency: %d", (int)latency);
mDefaults->bufferSize = bufferSize;
mDefaults->latency = latency;
mDefaults->periodSize = periodSize;
// Commit the hardware parameters back to the device.
err = snd_pcm_hw_params(mHandle, mHardwareParams);
if (err < 0) {
LOGE("Unable to set hardware parameters: %s", snd_strerror(err));
return NO_INIT;
}
status = setSoftwareParams();
return status;
}
const char *ALSAStreamOps::deviceName(int mode, uint32_t device)
{
static char devString[ALSA_NAME_MAX];
int dev;
int hasDevExt = 0;
strcpy (devString, mDefaults->devicePrefix);
for (dev=0; device; dev++)
if (device & (1 << dev)) {
/* Don't go past the end of our list */
if (dev >= deviceSuffixLen)
break;
ALSA_STRCAT (devString, deviceSuffix[dev]);
device &= ~(1 << dev);
hasDevExt = 1;
}
if (hasDevExt)
switch (mode) {
case AudioSystem::MODE_NORMAL:
ALSA_STRCAT (devString, "_normal");
break;
case AudioSystem::MODE_RINGTONE:
ALSA_STRCAT (devString, "_ringtone");
break;
case AudioSystem::MODE_IN_CALL:
ALSA_STRCAT (devString, "_incall");
break;
};
return devString;
}
// ----------------------------------------------------------------------------
AudioStreamOutALSA::AudioStreamOutALSA(AudioHardwareALSA *parent) :
mParent(parent),
mPowerLock(false)
{
static StreamDefaults _defaults = {
devicePrefix : "AndroidPlayback",
direction : SND_PCM_STREAM_PLAYBACK,
format : SND_PCM_FORMAT_S16_LE, // AudioSystem::PCM_16_BIT
channelCount : 2,
sampleRate : DEFAULT_SAMPLE_RATE,
bufferRatio : 1,
latency : LATENCY_PLAYBACK_MS, // Desired Delay in usec
bufferSize : BUFFER_SZ_PLAYBACK, // Desired Number of samples
periodSize : PERIOD_SZ_PLAYBACK
};
setStreamDefaults(&_defaults);
}
AudioStreamOutALSA::~AudioStreamOutALSA()
{
standby();
}
/* New arch */
status_t AudioStreamOutALSA::setVolume(float left, float right)
{
if (! mParent->mMixer || ! mDevice)
return NO_INIT;
/** Tushar - Need to decide on the volume value
* that we pass onto the mixer. */
return mParent->mMixer->setVolume (mDevice, (left + right)/2);
}
status_t AudioStreamOutALSA::setVolume(float volume)
{
if (! mParent->mMixer || ! mDevice)
return NO_INIT;
return mParent->mMixer->setVolume (mDevice, volume);
}
/* New Arch */
status_t AudioStreamOutALSA::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
status_t status = NO_ERROR;
int device;
int value;
LOGD("AudioStreamOutALSA::setParameters() %s", keyValuePairs.string());
if (param.getInt(String8(AudioParameter::keyRouting), device) == NO_ERROR)
{
mParent->doRouting(device);
param.remove(String8(AudioParameter::keyRouting));
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
String8 AudioStreamOutALSA::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
param.addInt(key, (int)mDevice);
}
LOGD("AudioStreamOutALSA::getParameters() %s", param.toString().string());
return param.toString();
}
status_t AudioStreamOutALSA::getRenderPosition(uint32_t *dspFrames)
{
//TODO: enable when supported by driver
return INVALID_OPERATION;
}
ssize_t AudioStreamOutALSA::write(const void *buffer, size_t bytes)
{
snd_pcm_sframes_t n;
size_t sent = 0;
status_t err;
mParent->lock().lock();
AutoMutex lock(mLock);
if (!mPowerLock) {
LOGD("Calling setDevice from write @..%d.\n",__LINE__);
ALSAStreamOps::setDevice(mParent->mode(), mDevice, PLAYBACK);
acquire_wake_lock (PARTIAL_WAKE_LOCK, "AudioOutLock");
mPowerLock = true;
}
mParent->lock().unlock();
do {
// write correct number of bytes per attempt
n = snd_pcm_writei(mHandle, (char *) buffer + sent, snd_pcm_bytes_to_frames(mHandle, bytes
- sent));
if (n == -EBADFD) {
LOGD("Calling setDevice.. pcm_write returned error @..%d.\n",__LINE__);
// Somehow the stream is in a bad state. The driver probably
// has a bug and snd_pcm_recover() doesn't seem to handle this.
ALSAStreamOps::setDevice(mParent->mode(), mDevice, PLAYBACK);
} else if (n < 0) {
if (mHandle) {
// snd_pcm_recover() will return 0 if successful in recovering from
// // an error, or -errno if the error was unrecoverable.
// We can make silent bit on as we are now handling the under-run and there will not be any data loss due to under-run
n = snd_pcm_recover(mHandle, n, 1);
if (n)
return static_cast<ssize_t> (n);
}
} else
sent += static_cast<ssize_t> (snd_pcm_frames_to_bytes(mHandle, n));
} while (mHandle && sent < bytes);
//LOGI("Request Bytes=%d, Actual Written=%d",bytes,sent);
return snd_pcm_frames_to_bytes(mHandle, sent);
}
status_t AudioStreamOutALSA::dump(int fd, const Vector<String16>& args)
{
return NO_ERROR;
}
status_t AudioStreamOutALSA::setDevice(int mode,
uint32_t newDevice,
uint32_t audio_mode,
bool force)
{
AutoMutex lock(mLock);
LOGV("AudioStreamOutALSA::setDevice(mode %d, newDevice %x, audio_mode %d), mDevice %x",
mode, newDevice, audio_mode, mDevice);
if (newDevice != mDevice || force) {
return ALSAStreamOps::setDevice(mode, newDevice, audio_mode);
}
return NO_ERROR;
}
status_t AudioStreamOutALSA::standby() {
AutoMutex _l(mParent->lock());
AutoMutex lock(mLock);
LOGD("Inside AudioStreamOutALSA::standby\n");
if (mParent->mode() != AudioSystem::MODE_IN_CALL) {
ALSAStreamOps::close();
}
if (mPowerLock) {
release_wake_lock("AudioOutLock");
mPowerLock = false;
}
return NO_ERROR;
}
#define USEC_TO_MSEC(x) ((x + 999) / 1000)
uint32_t AudioStreamOutALSA::latency() const
{
// Android wants latency in milliseconds.
return USEC_TO_MSEC (mDefaults->latency);
}
// ----------------------------------------------------------------------------
AudioStreamInALSA::AudioStreamInALSA(AudioHardwareALSA *parent) :
mParent(parent), mPowerLock(false),
mDownSampler(NULL), mPcmIn(NULL)
{
static StreamDefaults _defaults = {
devicePrefix : "AndroidRecord",
direction : SND_PCM_STREAM_CAPTURE,
format : SND_PCM_FORMAT_S16_LE, // AudioSystem::PCM_16_BIT
channelCount : 1,
sampleRate : DEFAULT_SAMPLE_RATE,
bufferRatio : 1,
latency : LATENCY_CAPTURE_MS,// Desired Delay in usec
bufferSize : BUFFER_SZ_CAPTURE, // Desired Number of samples
periodSize : PERIOD_SZ_CAPTURE
};
setStreamDefaults(&_defaults);
}
status_t AudioStreamInALSA::set(int *pformat,
uint32_t *pchannels,
uint32_t *prate)
{
status_t status = ALSAStreamOps::set(pformat, pchannels, prate);
if (status == NO_ERROR && prate && *prate != DEFAULT_SAMPLE_RATE) {
mDownSampler = new ALSADownsampler(*prate,
mDefaults->channelCount,
PERIOD_SZ_CAPTURE,
this);
status = mDownSampler->initCheck();
if (status != NO_ERROR) {
return status;
}
mPcmIn = new int16_t[PERIOD_SZ_CAPTURE * mDefaults->channelCount];
}
return status;
}
AudioStreamInALSA::~AudioStreamInALSA()
{
standby();
if (mDownSampler != NULL) {
delete mDownSampler;
}
if (mPcmIn != NULL) {
delete[] mPcmIn;
}
}
status_t AudioStreamInALSA::setGain(float gain)
{
if (mParent->mMixer)
return mParent->mMixer->setMasterGain (gain);
else
return NO_INIT;
}
ssize_t AudioStreamInALSA::read(void *buffer, ssize_t bytes)
{
snd_pcm_sframes_t n;
mParent->lock().lock();
AutoMutex lock(mLock);
if (!mPowerLock) {
acquire_wake_lock (PARTIAL_WAKE_LOCK, "AudioInLock");
LOGD("Calling setDevice from read@..%d.\n",__LINE__);
ALSAStreamOps::setDevice(mParent->mode(), mDevice, CAPTURE);
if (mDownSampler != NULL) {
mDownSampler->reset();
mReadStatus = 0;
mInPcmInBuf = 0;
}
mPowerLock = true;
}
mParent->lock().unlock();
if (!mHandle) {
return -1;
}
// FIXME: only support reads of exactly bufferSize() for now
if (bytes != (ssize_t)bufferSize()) {
LOGW("AudioStreamInALSA::read bad read size %d expected %d", (int)bytes, bufferSize());
return -1;
}
size_t frames = snd_pcm_bytes_to_frames(mHandle, bytes);
do {
if (mDownSampler) {
status_t status = mDownSampler->resample((int16_t *)buffer, &frames);
if (status != NO_ERROR) {
if (mReadStatus != 0) {
n = mReadStatus;
} else {
n = status;
}
frames = snd_pcm_bytes_to_frames(mHandle, bytes);
} else {
n = frames;
}
} else {
n = snd_pcm_readi(mHandle,
(uint8_t *)buffer,
frames);
}
if (n < 0) {
LOGD("AudioStreamInALSA::read error %d", (int)n);
n = snd_pcm_recover(mHandle, n, 0);
LOGD("AudioStreamInALSA::snd_pcm_recover error %d", (int)n);
if (n)
return static_cast<ssize_t> (n);
}
} while (n == 0);
return snd_pcm_frames_to_bytes(mHandle, n);
}
status_t AudioStreamInALSA::dump(int fd, const Vector<String16>& args)
{
return NO_ERROR;
}
status_t AudioStreamInALSA::setDevice(int mode,
uint32_t newDevice,
uint32_t audio_mode,
bool force)
{
AutoMutex lock(mLock);
return ALSAStreamOps::setDevice(mode, newDevice, audio_mode);
}
status_t AudioStreamInALSA::standby()
{
AutoMutex _l(mParent->lock());
AutoMutex lock(mLock);
LOGD("Entering AudioStreamInALSA::standby\n");
ALSAStreamOps::close();
if (mPowerLock) {
release_wake_lock ("AudioInLock");
mPowerLock = false;
}
return NO_ERROR;
}
/* New Arch */
status_t AudioStreamInALSA::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 key = String8("vr_mode");
status_t status = NO_ERROR;
int value;
LOGD("AudioStreamInALSA::setParameters() %s", keyValuePairs.string());
if (param.getInt(key, value) == NO_ERROR) {
mParent->setVoiceRecordGain((value != 0));
param.remove(key);
}
key = String8(AudioParameter::keyRouting);
if (param.getInt(key, value) == NO_ERROR) {
if(mHandle != NULL && value != 0)
setDevice(mParent->mode(), value, CAPTURE);
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
String8 AudioStreamInALSA::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
param.addInt(key, (int)mDevice);
}
LOGD("AudioStreamInALSA::getParameters() %s", param.toString().string());
return param.toString();
}
status_t AudioStreamInALSA::getNextBuffer(ALSABufferProvider::Buffer* buffer)
{
if (mHandle == NULL) {
buffer->raw = NULL;
buffer->frameCount = 0;
return NO_INIT;
}
if (mInPcmInBuf == 0) {
while (mInPcmInBuf < PERIOD_SZ_CAPTURE) {
mReadStatus = snd_pcm_readi(mHandle,
(uint8_t *)mPcmIn +
(mInPcmInBuf * mDefaults->channelCount * sizeof(int16_t)),
PERIOD_SZ_CAPTURE - mInPcmInBuf);
if (mReadStatus < 0) {
buffer->raw = NULL;
buffer->frameCount = 0;
LOGV("resampler read error %d", mReadStatus);
return mReadStatus;
}
mInPcmInBuf += mReadStatus;
}
}
buffer->frameCount = (buffer->frameCount > mInPcmInBuf) ? mInPcmInBuf : buffer->frameCount;
buffer->i16 = mPcmIn + (PERIOD_SZ_CAPTURE - mInPcmInBuf) * mDefaults->channelCount;
return NO_ERROR;
}
void AudioStreamInALSA::releaseBuffer(ALSABufferProvider::Buffer* buffer)
{
mInPcmInBuf -= buffer->frameCount;
}
// ----------------------------------------------------------------------------
struct mixer_info_t
{
mixer_info_t() :
elem(0),
min(SND_MIXER_VOL_RANGE_MIN),
max(SND_MIXER_VOL_RANGE_MAX),
mute(false)
{
}
snd_mixer_elem_t *elem;
long min;
long max;
long volume;
bool mute;
char name[ALSA_NAME_MAX];
};
static int initMixer (snd_mixer_t **mixer, const char *name)
{
int err;
if ((err = snd_mixer_open(mixer, 0)) < 0) {
LOGE("Unable to open mixer: %s", snd_strerror(err));
return err;
}
if ((err = snd_mixer_attach(*mixer, name)) < 0) {
LOGE("Unable to attach mixer to device %s: %s",
name, snd_strerror(err));
if ((err = snd_mixer_attach(*mixer, "hw:00")) < 0) {
LOGE("Unable to attach mixer to device default: %s",
snd_strerror(err));
snd_mixer_close (*mixer);
*mixer = NULL;
return err;
}
}
if ((err = snd_mixer_selem_register(*mixer, NULL, NULL)) < 0) {
LOGE("Unable to register mixer elements: %s", snd_strerror(err));
snd_mixer_close (*mixer);
*mixer = NULL;
return err;
}
// Get the mixer controls from the kernel
if ((err = snd_mixer_load(*mixer)) < 0) {
LOGE("Unable to load mixer elements: %s", snd_strerror(err));
snd_mixer_close (*mixer);
*mixer = NULL;
return err;
}
return 0;
}
typedef int (*hasVolume_t)(snd_mixer_elem_t*);
static const hasVolume_t hasVolume[] = {
snd_mixer_selem_has_playback_volume,
snd_mixer_selem_has_capture_volume
};
typedef int (*getVolumeRange_t)(snd_mixer_elem_t*, long int*, long int*);
static const getVolumeRange_t getVolumeRange[] = {
snd_mixer_selem_get_playback_volume_range,
snd_mixer_selem_get_capture_volume_range
};
typedef int (*setVolume_t)(snd_mixer_elem_t*, long int);
static const setVolume_t setVol[] = {
snd_mixer_selem_set_playback_volume_all,
snd_mixer_selem_set_capture_volume_all
};
ALSAMixer::ALSAMixer()
{
int err;
initMixer (&mMixer[SND_PCM_STREAM_PLAYBACK], "AndroidPlayback");
initMixer (&mMixer[SND_PCM_STREAM_CAPTURE], "AndroidRecord");
snd_mixer_selem_id_t *sid;
snd_mixer_selem_id_alloca(&sid);
for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
mixer_info_t *info = mixerMasterProp[i].mInfo = new mixer_info_t;
property_get (mixerMasterProp[i].propName,
info->name,
mixerMasterProp[i].propDefault);
for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
elem;
elem = snd_mixer_elem_next(elem)) {
if (!snd_mixer_selem_is_active(elem))
continue;
snd_mixer_selem_get_id(elem, sid);
// Find PCM playback volume control element.
const char *elementName = snd_mixer_selem_id_get_name(sid);
if (hasVolume[i] (elem))
LOGD ("Mixer: element name: '%s'", elementName);
if (info->elem == NULL &&
strcmp(elementName, info->name) == 0 &&
hasVolume[i] (elem)) {
info->elem = elem;
getVolumeRange[i] (elem, &info->min, &info->max);
info->volume = info->max;
setVol[i] (elem, info->volume);
if (i == SND_PCM_STREAM_PLAYBACK &&
snd_mixer_selem_has_playback_switch (elem))
snd_mixer_selem_set_playback_switch_all (elem, 1);
break;
}
}
LOGD ("Mixer: master '%s' %s.", info->name, info->elem ? "found" : "not found");
for (int j = 0; mixerProp[j][i].routes; j++) {
mixer_info_t *info = mixerProp[j][i].mInfo = new mixer_info_t;
property_get (mixerProp[j][i].propName,
info->name,
mixerProp[j][i].propDefault);
for (snd_mixer_elem_t *elem = snd_mixer_first_elem(mMixer[i]);
elem;
elem = snd_mixer_elem_next(elem)) {
if (!snd_mixer_selem_is_active(elem))
continue;
snd_mixer_selem_get_id(elem, sid);
// Find PCM playback volume control element.
const char *elementName = snd_mixer_selem_id_get_name(sid);
if (info->elem == NULL &&
strcmp(elementName, info->name) == 0 &&
hasVolume[i] (elem)) {
info->elem = elem;
getVolumeRange[i] (elem, &info->min, &info->max);
info->volume = info->max;
setVol[i] (elem, info->volume);
if (i == SND_PCM_STREAM_PLAYBACK &&
snd_mixer_selem_has_playback_switch (elem))
snd_mixer_selem_set_playback_switch_all (elem, 1);
break;
}
}
LOGD ("Mixer: route '%s' %s.", info->name, info->elem ? "found" : "not found");
}
}
LOGD("mixer initialized.");
}
ALSAMixer::~ALSAMixer()
{
for (int i = 0; i <= SND_PCM_STREAM_LAST; i++) {
if (mMixer[i]) snd_mixer_close (mMixer[i]);
if (mixerMasterProp[i].mInfo) {
delete mixerMasterProp[i].mInfo;
mixerMasterProp[i].mInfo = NULL;
}
for (int j = 0; mixerProp[j][i].routes; j++) {
if (mixerProp[j][i].mInfo) {
delete mixerProp[j][i].mInfo;
mixerProp[j][i].mInfo = NULL;
}
}
}
LOGD("mixer destroyed.");
}
status_t ALSAMixer::setMasterVolume(float volume)
{
mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_PLAYBACK].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
long minVol = info->min;
long maxVol = info->max;
// Make sure volume is between bounds.
long vol = minVol + volume * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_playback_volume_all (info->elem, vol);
return NO_ERROR;
}
status_t ALSAMixer::setMasterGain(float gain)
{
mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_CAPTURE].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
long minVol = info->min;
long maxVol = info->max;
// Make sure volume is between bounds.
long vol = minVol + gain * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_capture_volume_all (info->elem, vol);
return NO_ERROR;
}
status_t ALSAMixer::setVolume(uint32_t device, float volume)
{
for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes; j++)
if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
long minVol = info->min;
long maxVol = info->max;
// Make sure volume is between bounds.
long vol = minVol + volume * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_playback_volume_all (info->elem, vol);
}
return NO_ERROR;
}
status_t ALSAMixer::setGain(uint32_t device, float gain)
{
for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].routes; j++)
if (mixerProp[j][SND_PCM_STREAM_CAPTURE].routes & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
long minVol = info->min;
long maxVol = info->max;
// Make sure volume is between bounds.
long vol = minVol + gain * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_capture_volume_all (info->elem, vol);
}
return NO_ERROR;
}
status_t ALSAMixer::setCaptureMuteState(uint32_t device, bool state)
{
for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].routes; j++)
if (mixerProp[j][SND_PCM_STREAM_CAPTURE].routes & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
if (snd_mixer_selem_has_capture_switch (info->elem)) {
int err = snd_mixer_selem_set_capture_switch_all (info->elem, static_cast<int>(!state));
if (err < 0) {
LOGE("Unable to %s capture mixer switch %s",
state ? "enable" : "disable", info->name);
return INVALID_OPERATION;
}
}
info->mute = state;
}
return NO_ERROR;
}
status_t ALSAMixer::getCaptureMuteState(uint32_t device, bool *state)
{
if (! state) return BAD_VALUE;
for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].routes; j++)
if (mixerProp[j][SND_PCM_STREAM_CAPTURE].routes & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
*state = info->mute;
return NO_ERROR;
}
return BAD_VALUE;
}
status_t ALSAMixer::setPlaybackMuteState(uint32_t device, bool state)
{
LOGE("\n set playback mute device %d, state %d \n", device,state);
for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes; j++)
if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
if (snd_mixer_selem_has_playback_switch (info->elem)) {
int err = snd_mixer_selem_set_playback_switch_all (info->elem, static_cast<int>(!state));
if (err < 0) {
LOGE("Unable to %s playback mixer switch %s",
state ? "enable" : "disable", info->name);
return INVALID_OPERATION;
}
}
info->mute = state;
}
return NO_ERROR;
}
status_t ALSAMixer::getPlaybackMuteState(uint32_t device, bool *state)
{
if (! state) return BAD_VALUE;
for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes; j++)
if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].routes & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
*state = info->mute;
return NO_ERROR;
}
return BAD_VALUE;
}
// ----------------------------------------------------------------------------
ALSAControl::ALSAControl(const char *device)
{
snd_ctl_open(&mHandle, device, 0);
}
ALSAControl::~ALSAControl()
{
if (mHandle) snd_ctl_close(mHandle);
}
status_t ALSAControl::get(const char *name, unsigned int &value, int index)
{
if (!mHandle) return NO_INIT;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_value_t *control;
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, name);
snd_ctl_elem_info_set_id(info, id);
int ret = snd_ctl_elem_info(mHandle, info);
if (ret < 0) return BAD_VALUE;
snd_ctl_elem_info_get_id(info, id);
snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(info);
unsigned int count = snd_ctl_elem_info_get_count(info);
if ((unsigned int)index >= count) return BAD_VALUE;
snd_ctl_elem_value_set_id(control, id);
ret = snd_ctl_elem_read(mHandle, control);
if (ret < 0) return BAD_VALUE;
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
value = snd_ctl_elem_value_get_boolean(control, index);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
value = snd_ctl_elem_value_get_integer(control, index);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
value = snd_ctl_elem_value_get_integer64(control, index);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
value = snd_ctl_elem_value_get_enumerated(control, index);
break;
case SND_CTL_ELEM_TYPE_BYTES:
value = snd_ctl_elem_value_get_byte(control, index);
break;
default:
return BAD_VALUE;
}
return NO_ERROR;
}
status_t ALSAControl::set(const char *name, unsigned int value, int index)
{
if (!mHandle) return NO_INIT;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_value_t *control;
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, name);
snd_ctl_elem_info_set_id(info, id);
int ret = snd_ctl_elem_info(mHandle, info);
if (ret < 0) return BAD_VALUE;
snd_ctl_elem_info_get_id(info, id);
snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(info);
unsigned int count = snd_ctl_elem_info_get_count(info);
if (index >= (int)count) return BAD_VALUE;
if (index == -1)
index = 0; // Range over all of them
else
count = index + 1; // Just do the one specified
snd_ctl_elem_value_set_id(control, id);
for (unsigned int i = index; i < count; i++)
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
snd_ctl_elem_value_set_boolean(control, i, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_set_integer(control, i, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
snd_ctl_elem_value_set_integer64(control, i, value);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
snd_ctl_elem_value_set_enumerated(control, i, value);
break;
case SND_CTL_ELEM_TYPE_BYTES:
snd_ctl_elem_value_set_byte(control, i, value);
break;
default:
break;
}
ret = snd_ctl_elem_write(mHandle, control);
return (ret < 0) ? BAD_VALUE : NO_ERROR;
}
//------------------------------------------------------------------------------
// Downsampler
//------------------------------------------------------------------------------
/*
* 2.30 fixed point FIR filter coefficients for conversion 44100 -> 22050.
* (Works equivalently for 22010 -> 11025 or any other halving, of course.)
*
* Transition band from about 18 kHz, passband ripple < 0.1 dB,
* stopband ripple at about -55 dB, linear phase.
*
* Design and display in MATLAB or Octave using:
*
* filter = fir1(19, 0.5); filter = round(filter * 2**30); freqz(filter * 2**-30);
*/
static const int32_t filter_22khz_coeff[] = {
2089257, 2898328, -5820678, -10484531,
19038724, 30542725, -50469415, -81505260,
152544464, 478517512, 478517512, 152544464,
-81505260, -50469415, 30542725, 19038724,
-10484531, -5820678, 2898328, 2089257,
};
#define NUM_COEFF_22KHZ (sizeof(filter_22khz_coeff) / sizeof(filter_22khz_coeff[0]))
#define OVERLAP_22KHZ (NUM_COEFF_22KHZ - 2)
/*
* Convolution of signals A and reverse(B). (In our case, the filter response
* is symmetric, so the reversing doesn't matter.)
* A is taken to be in 0.16 fixed-point, and B is taken to be in 2.30 fixed-point.
* The answer will be in 16.16 fixed-point, unclipped.
*
* This function would probably be the prime candidate for SIMD conversion if
* you want more speed.
*/
int32_t fir_convolve(const int16_t* a, const int32_t* b, int num_samples)
{
int32_t sum = 1 << 13;
for (int i = 0; i < num_samples; ++i) {
sum += a[i] * (b[i] >> 16);
}
return sum >> 14;
}
/* Clip from 16.16 fixed-point to 0.16 fixed-point. */
int16_t clip(int32_t x)
{
if (x < -32768) {
return -32768;
} else if (x > 32767) {
return 32767;
} else {
return x;
}
}
/*
* Convert a chunk from 44 kHz to 22 kHz. Will update num_samples_in and num_samples_out
* accordingly, since it may leave input samples in the buffer due to overlap.
*
* Input and output are taken to be in 0.16 fixed-point.
*/
void resample_2_1(int16_t* input, int16_t* output, int* num_samples_in, int* num_samples_out)
{
if (*num_samples_in < (int)NUM_COEFF_22KHZ) {
*num_samples_out = 0;
return;
}
int odd_smp = *num_samples_in & 0x1;
int num_samples = *num_samples_in - odd_smp - OVERLAP_22KHZ;
for (int i = 0; i < num_samples; i += 2) {
output[i / 2] = clip(fir_convolve(input + i, filter_22khz_coeff, NUM_COEFF_22KHZ));
}
memmove(input, input + num_samples, (OVERLAP_22KHZ + odd_smp) * sizeof(*input));
*num_samples_out = num_samples / 2;
*num_samples_in = OVERLAP_22KHZ + odd_smp;
}
/*
* 2.30 fixed point FIR filter coefficients for conversion 22050 -> 16000,
* or 11025 -> 8000.
*
* Transition band from about 14 kHz, passband ripple < 0.1 dB,
* stopband ripple at about -50 dB, linear phase.
*
* Design and display in MATLAB or Octave using:
*
* filter = fir1(23, 16000 / 22050); filter = round(filter * 2**30); freqz(filter * 2**-30);
*/
static const int32_t filter_16khz_coeff[] = {
2057290, -2973608, 1880478, 4362037,
-14639744, 18523609, -1609189, -38502470,
78073125, -68353935, -59103896, 617555440,
617555440, -59103896, -68353935, 78073125,
-38502470, -1609189, 18523609, -14639744,
4362037, 1880478, -2973608, 2057290,
};
#define NUM_COEFF_16KHZ (sizeof(filter_16khz_coeff) / sizeof(filter_16khz_coeff[0]))
#define OVERLAP_16KHZ (NUM_COEFF_16KHZ - 1)
/*
* Convert a chunk from 22 kHz to 16 kHz. Will update num_samples_in and
* num_samples_out accordingly, since it may leave input samples in the buffer
* due to overlap.
*
* This implementation is rather ad-hoc; it first low-pass filters the data
* into a temporary buffer, and then converts chunks of 441 input samples at a
* time into 320 output samples by simple linear interpolation. A better
* implementation would use a polyphase filter bank to do these two operations
* in one step.
*
* Input and output are taken to be in 0.16 fixed-point.
*/
#define RESAMPLE_16KHZ_SAMPLES_IN 441
#define RESAMPLE_16KHZ_SAMPLES_OUT 320
void resample_441_320(int16_t* input, int16_t* output, int* num_samples_in, int* num_samples_out)
{
const int num_blocks = (*num_samples_in - OVERLAP_16KHZ) / RESAMPLE_16KHZ_SAMPLES_IN;
if (num_blocks < 1) {
*num_samples_out = 0;
return;
}
for (int i = 0; i < num_blocks; ++i) {
uint32_t tmp[RESAMPLE_16KHZ_SAMPLES_IN];
for (int j = 0; j < RESAMPLE_16KHZ_SAMPLES_IN; ++j) {
tmp[j] = fir_convolve(input + i * RESAMPLE_16KHZ_SAMPLES_IN + j,
filter_16khz_coeff,
NUM_COEFF_16KHZ);
}
const float step_float = (float)RESAMPLE_16KHZ_SAMPLES_IN / (float)RESAMPLE_16KHZ_SAMPLES_OUT;
uint32_t in_sample_num = 0; // 16.16 fixed point
const uint32_t step = (uint32_t)(step_float * 65536.0f + 0.5f); // 16.16 fixed point
for (int j = 0; j < RESAMPLE_16KHZ_SAMPLES_OUT; ++j, in_sample_num += step) {
const uint32_t whole = in_sample_num >> 16;
const uint32_t frac = (in_sample_num & 0xffff); // 0.16 fixed point
const int32_t s1 = tmp[whole];
const int32_t s2 = tmp[whole + 1];
*output++ = clip(s1 + (((s2 - s1) * (int32_t)frac) >> 16));
}
}
const int samples_consumed = num_blocks * RESAMPLE_16KHZ_SAMPLES_IN;
memmove(input, input + samples_consumed, (*num_samples_in - samples_consumed) * sizeof(*input));
*num_samples_in -= samples_consumed;
*num_samples_out = RESAMPLE_16KHZ_SAMPLES_OUT * num_blocks;
}
ALSADownsampler::ALSADownsampler(uint32_t outSampleRate,
uint32_t channelCount,
uint32_t frameCount,
ALSABufferProvider* provider)
: mStatus(NO_INIT), mProvider(provider), mSampleRate(outSampleRate),
mChannelCount(channelCount), mFrameCount(frameCount),
mInLeft(NULL), mInRight(NULL), mTmpLeft(NULL), mTmpRight(NULL),
mTmp2Left(NULL), mTmp2Right(NULL), mOutLeft(NULL), mOutRight(NULL)
{
LOGV("ALSADownsampler() cstor SR %d channels %d frames %d",
mSampleRate, mChannelCount, mFrameCount);
if (mSampleRate != 8000 && mSampleRate != 11025 && mSampleRate != 16000 &&
mSampleRate != 22050) {
LOGW("ALSADownsampler cstor: bad sampling rate: %d", mSampleRate);
return;
}
mInLeft = new int16_t[mFrameCount];
mInRight = new int16_t[mFrameCount];
mTmpLeft = new int16_t[mFrameCount];
mTmpRight = new int16_t[mFrameCount];
mTmp2Left = new int16_t[mFrameCount];
mTmp2Right = new int16_t[mFrameCount];
mOutLeft = new int16_t[mFrameCount];
mOutRight = new int16_t[mFrameCount];
mStatus = NO_ERROR;
}
ALSADownsampler::~ALSADownsampler()
{
if (mInLeft) delete[] mInLeft;
if (mInRight) delete[] mInRight;
if (mTmpLeft) delete[] mTmpLeft;
if (mTmpRight) delete[] mTmpRight;
if (mTmp2Left) delete[] mTmp2Left;
if (mTmp2Right) delete[] mTmp2Right;
if (mOutLeft) delete[] mOutLeft;
if (mOutRight) delete[] mOutRight;
}
void ALSADownsampler::reset()
{
mInInBuf = 0;
mInTmpBuf = 0;
mInTmp2Buf = 0;
mOutBufPos = 0;
mInOutBuf = 0;
}
int ALSADownsampler::resample(int16_t* out, size_t *outFrameCount)
{
if (mStatus != NO_ERROR) {
return mStatus;
}
if (out == NULL || outFrameCount == NULL) {
return BAD_VALUE;
}
int16_t *outLeft = mTmp2Left;
int16_t *outRight = mTmp2Left;
if (mSampleRate == 22050) {
outLeft = mTmpLeft;
outRight = mTmpRight;
} else if (mSampleRate == 8000){
outLeft = mOutLeft;
outRight = mOutRight;
}
int outFrames = 0;
int remaingFrames = *outFrameCount;
if (mInOutBuf) {
int frames = (remaingFrames > mInOutBuf) ? mInOutBuf : remaingFrames;
for (int i = 0; i < frames; ++i) {
out[i] = outLeft[mOutBufPos + i];
}
if (mChannelCount == 2) {
for (int i = 0; i < frames; ++i) {
out[i * 2] = outLeft[mOutBufPos + i];
out[i * 2 + 1] = outRight[mOutBufPos + i];
}
}
remaingFrames -= frames;
mInOutBuf -= frames;
mOutBufPos += frames;
outFrames += frames;
}
while (remaingFrames) {
LOGW_IF((mInOutBuf != 0), "mInOutBuf should be 0 here");
ALSABufferProvider::Buffer buf;
buf.frameCount = mFrameCount - mInInBuf;
int ret = mProvider->getNextBuffer(&buf);
if (buf.raw == NULL) {
*outFrameCount = outFrames;
return ret;
}
for (size_t i = 0; i < buf.frameCount; ++i) {
mInLeft[i + mInInBuf] = buf.i16[i];
}
if (mChannelCount == 2) {
for (size_t i = 0; i < buf.frameCount; ++i) {
mInLeft[i + mInInBuf] = buf.i16[i * 2];
mInRight[i + mInInBuf] = buf.i16[i * 2 + 1];
}
}
mInInBuf += buf.frameCount;
mProvider->releaseBuffer(&buf);
/* 44010 -> 22050 */
{
int samples_in_left = mInInBuf;
int samples_out_left;
resample_2_1(mInLeft, mTmpLeft + mInTmpBuf, &samples_in_left, &samples_out_left);
if (mChannelCount == 2) {
int samples_in_right = mInInBuf;
int samples_out_right;
resample_2_1(mInRight, mTmpRight + mInTmpBuf, &samples_in_right, &samples_out_right);
}
mInInBuf = samples_in_left;
mInTmpBuf += samples_out_left;
mInOutBuf = samples_out_left;
}
if (mSampleRate == 11025 || mSampleRate == 8000) {
/* 22050 - > 11025 */
int samples_in_left = mInTmpBuf;
int samples_out_left;
resample_2_1(mTmpLeft, mTmp2Left + mInTmp2Buf, &samples_in_left, &samples_out_left);
if (mChannelCount == 2) {
int samples_in_right = mInTmpBuf;
int samples_out_right;
resample_2_1(mTmpRight, mTmp2Right + mInTmp2Buf, &samples_in_right, &samples_out_right);
}
mInTmpBuf = samples_in_left;
mInTmp2Buf += samples_out_left;
mInOutBuf = samples_out_left;
if (mSampleRate == 8000) {
/* 11025 -> 8000*/
int samples_in_left = mInTmp2Buf;
int samples_out_left;
resample_441_320(mTmp2Left, mOutLeft, &samples_in_left, &samples_out_left);
if (mChannelCount == 2) {
int samples_in_right = mInTmp2Buf;
int samples_out_right;
resample_441_320(mTmp2Right, mOutRight, &samples_in_right, &samples_out_right);
}
mInTmp2Buf = samples_in_left;
mInOutBuf = samples_out_left;
} else {
mInTmp2Buf = 0;
}
} else if (mSampleRate == 16000) {
/* 22050 -> 16000*/
int samples_in_left = mInTmpBuf;
int samples_out_left;
resample_441_320(mTmpLeft, mTmp2Left, &samples_in_left, &samples_out_left);
if (mChannelCount == 2) {
int samples_in_right = mInTmpBuf;
int samples_out_right;
resample_441_320(mTmpRight, mTmp2Right, &samples_in_right, &samples_out_right);
}
mInTmpBuf = samples_in_left;
mInOutBuf = samples_out_left;
} else {
mInTmpBuf = 0;
}
int frames = (remaingFrames > mInOutBuf) ? mInOutBuf : remaingFrames;
for (int i = 0; i < frames; ++i) {
out[outFrames + i] = outLeft[i];
}
if (mChannelCount == 2) {
for (int i = 0; i < frames; ++i) {
out[(outFrames + i) * 2] = outLeft[i];
out[(outFrames + i) * 2 + 1] = outRight[i];
}
}
remaingFrames -= frames;
outFrames += frames;
mOutBufPos = frames;
mInOutBuf -= frames;
}
return 0;
}
}; // namespace android