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.
376 lines
11 KiB
376 lines
11 KiB
/* ALSAStreamOps.cpp
|
|
**
|
|
** Copyright 2008-2009 Wind River Systems
|
|
** Copyright (c) 2011, 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 "ALSAStreamOps"
|
|
//#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 "AudioUtil.h"
|
|
#include "AudioHardwareALSA.h"
|
|
|
|
namespace android_audio_legacy
|
|
{
|
|
|
|
// unused 'enumVal;' is to catch error at compile time if enumVal ever changes
|
|
// or applied on a non-existent enum
|
|
#define ENUM_TO_STRING(var, enumVal) {var = #enumVal; enumVal;}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
ALSAStreamOps::ALSAStreamOps(AudioHardwareALSA *parent, alsa_handle_t *handle) :
|
|
mParent(parent),
|
|
mHandle(handle)
|
|
{
|
|
}
|
|
|
|
ALSAStreamOps::~ALSAStreamOps()
|
|
{
|
|
Mutex::Autolock autoLock(mParent->mLock);
|
|
|
|
if((!strcmp(mHandle->useCase, SND_USE_CASE_VERB_IP_VOICECALL)) ||
|
|
(!strcmp(mHandle->useCase, SND_USE_CASE_MOD_PLAY_VOIP))) {
|
|
if((mParent->mVoipStreamCount)) {
|
|
mParent->mVoipStreamCount--;
|
|
if(mParent->mVoipStreamCount > 0) {
|
|
ALOGD("ALSAStreamOps::close() Ignore");
|
|
return ;
|
|
}
|
|
}
|
|
mParent->mVoipStreamCount = 0;
|
|
mParent->mVoipBitRate = 0;
|
|
}
|
|
close();
|
|
|
|
for(ALSAHandleList::iterator it = mParent->mDeviceList.begin();
|
|
it != mParent->mDeviceList.end(); ++it) {
|
|
if (mHandle == &(*it)) {
|
|
it->useCase[0] = 0;
|
|
mParent->mDeviceList.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// use emulated popcount optimization
|
|
// http://www.df.lth.se/~john_e/gems/gem002d.html
|
|
static inline uint32_t popCount(uint32_t u)
|
|
{
|
|
u = ((u&0x55555555) + ((u>>1)&0x55555555));
|
|
u = ((u&0x33333333) + ((u>>2)&0x33333333));
|
|
u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
|
|
u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
|
|
u = ( u&0x0000ffff) + (u>>16);
|
|
return u;
|
|
}
|
|
|
|
status_t ALSAStreamOps::set(int *format,
|
|
uint32_t *channels,
|
|
uint32_t *rate,
|
|
uint32_t device)
|
|
{
|
|
mDevices = device;
|
|
if (channels && *channels != 0) {
|
|
if (mHandle->channels != popCount(*channels))
|
|
return BAD_VALUE;
|
|
} else if (channels) {
|
|
if (mHandle->devices & AudioSystem::DEVICE_OUT_ALL) {
|
|
switch(*channels) {
|
|
case AUDIO_CHANNEL_OUT_5POINT1: // 5.0
|
|
case (AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER): // 5.1
|
|
case AUDIO_CHANNEL_OUT_QUAD:
|
|
case AUDIO_CHANNEL_OUT_STEREO:
|
|
case AUDIO_CHANNEL_OUT_MONO:
|
|
break;
|
|
default:
|
|
*channels = AUDIO_CHANNEL_OUT_STEREO;
|
|
return BAD_VALUE;
|
|
}
|
|
} else {
|
|
switch(*channels) {
|
|
#ifdef QCOM_SSR_ENABLED
|
|
// For 5.1 recording
|
|
case AudioSystem::CHANNEL_IN_5POINT1:
|
|
#endif
|
|
// Do not fall through...
|
|
case AUDIO_CHANNEL_IN_MONO:
|
|
case AUDIO_CHANNEL_IN_STEREO:
|
|
case AUDIO_CHANNEL_IN_FRONT_BACK:
|
|
break;
|
|
default:
|
|
*channels = AUDIO_CHANNEL_IN_MONO;
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rate && *rate > 0) {
|
|
if (mHandle->sampleRate != *rate)
|
|
return BAD_VALUE;
|
|
} else if (rate) {
|
|
*rate = mHandle->sampleRate;
|
|
}
|
|
|
|
snd_pcm_format_t iformat = mHandle->format;
|
|
|
|
if (format) {
|
|
switch(*format) {
|
|
case AudioSystem::FORMAT_DEFAULT:
|
|
break;
|
|
|
|
case AudioSystem::PCM_16_BIT:
|
|
iformat = SNDRV_PCM_FORMAT_S16_LE;
|
|
break;
|
|
case AudioSystem::AMR_NB:
|
|
case AudioSystem::AMR_WB:
|
|
#ifdef QCOM_QCHAT_ENABLED
|
|
case AudioSystem::EVRC:
|
|
case AudioSystem::EVRCB:
|
|
case AudioSystem::EVRCWB:
|
|
#endif
|
|
iformat = *format;
|
|
break;
|
|
|
|
case AudioSystem::PCM_8_BIT:
|
|
iformat = SNDRV_PCM_FORMAT_S8;
|
|
break;
|
|
|
|
default:
|
|
ALOGE("Unknown PCM format %i. Forcing default", *format);
|
|
break;
|
|
}
|
|
|
|
if (mHandle->format != iformat)
|
|
return BAD_VALUE;
|
|
|
|
switch(iformat) {
|
|
case SNDRV_PCM_FORMAT_S16_LE:
|
|
*format = AudioSystem::PCM_16_BIT;
|
|
break;
|
|
case SNDRV_PCM_FORMAT_S8:
|
|
*format = AudioSystem::PCM_8_BIT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t ALSAStreamOps::setParameters(const String8& keyValuePairs)
|
|
{
|
|
AudioParameter param = AudioParameter(keyValuePairs);
|
|
String8 key = String8(AudioParameter::keyRouting);
|
|
int device;
|
|
|
|
#ifdef SEPERATED_AUDIO_INPUT
|
|
String8 key_input = String8(AudioParameter::keyInputSource);
|
|
int source;
|
|
|
|
if (param.getInt(key_input, source) == NO_ERROR) {
|
|
ALOGD("setParameters(), input_source = %d", source);
|
|
mParent->mALSADevice->setInput(source);
|
|
param.remove(key_input);
|
|
}
|
|
#endif
|
|
|
|
if (param.getInt(key, device) == NO_ERROR) {
|
|
// Ignore routing if device is 0.
|
|
ALOGD("setParameters(): keyRouting with device 0x%x", device);
|
|
// reset to speaker when disconnecting HDMI to avoid timeout due to write errors
|
|
if ((device == 0) && (mDevices == AudioSystem::DEVICE_OUT_AUX_DIGITAL)) {
|
|
device = AudioSystem::DEVICE_OUT_SPEAKER;
|
|
}
|
|
if (device)
|
|
mDevices = device;
|
|
else
|
|
ALOGV("must not change mDevices to 0");
|
|
|
|
if(device) {
|
|
mParent->doRouting(device);
|
|
}
|
|
param.remove(key);
|
|
}
|
|
#ifdef QCOM_FM_ENABLED
|
|
else {
|
|
key = String8(AudioParameter::keyHandleFm);
|
|
if (param.getInt(key, device) == NO_ERROR) {
|
|
ALOGD("setParameters(): handleFm with device %d", device);
|
|
mDevices = device;
|
|
if(device) {
|
|
mParent->handleFm(device);
|
|
}
|
|
param.remove(key);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
String8 ALSAStreamOps::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)mDevices);
|
|
}
|
|
else {
|
|
#ifdef QCOM_VOIP_ENABLED
|
|
key = String8(AudioParameter::keyVoipCheck);
|
|
if (param.get(key, value) == NO_ERROR) {
|
|
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))))
|
|
param.addInt(key, true);
|
|
else
|
|
param.addInt(key, false);
|
|
}
|
|
#endif
|
|
}
|
|
key = String8(AUDIO_PARAMETER_STREAM_SUP_CHANNELS);
|
|
if (param.get(key, value) == NO_ERROR) {
|
|
EDID_AUDIO_INFO info = { 0 };
|
|
bool first = true;
|
|
value = String8();
|
|
if (AudioUtil::getHDMIAudioSinkCaps(&info)) {
|
|
for (int i = 0; i < info.nAudioBlocks && i < MAX_EDID_BLOCKS; i++) {
|
|
String8 append;
|
|
switch (info.AudioBlocksArray[i].nChannels) {
|
|
//Do not handle stereo output in Multi-channel cases
|
|
//Stereo case is handled in normal playback path
|
|
case 6:
|
|
ENUM_TO_STRING(append, AUDIO_CHANNEL_OUT_5POINT1);
|
|
break;
|
|
case 8:
|
|
ENUM_TO_STRING(append, AUDIO_CHANNEL_OUT_7POINT1);
|
|
break;
|
|
default:
|
|
ALOGD("Unsupported number of channels %d", info.AudioBlocksArray[i].nChannels);
|
|
break;
|
|
}
|
|
if (!append.isEmpty()) {
|
|
value += (first ? append : String8("|") + append);
|
|
first = false;
|
|
}
|
|
}
|
|
} else {
|
|
ALOGE("Failed to get HDMI sink capabilities");
|
|
}
|
|
param.add(key, value);
|
|
}
|
|
ALOGV("getParameters() %s", param.toString().string());
|
|
return param.toString();
|
|
}
|
|
|
|
uint32_t ALSAStreamOps::sampleRate() const
|
|
{
|
|
return mHandle->sampleRate;
|
|
}
|
|
|
|
//
|
|
// Return the number of bytes (not frames)
|
|
//
|
|
size_t ALSAStreamOps::bufferSize() const
|
|
{
|
|
ALOGV("bufferSize() returns %d", mHandle->bufferSize);
|
|
return mHandle->bufferSize;
|
|
}
|
|
|
|
int ALSAStreamOps::format() const
|
|
{
|
|
int audioSystemFormat;
|
|
|
|
snd_pcm_format_t ALSAFormat = mHandle->format;
|
|
|
|
switch(ALSAFormat) {
|
|
case SNDRV_PCM_FORMAT_S8:
|
|
audioSystemFormat = AudioSystem::PCM_8_BIT;
|
|
break;
|
|
|
|
case AudioSystem::AMR_NB:
|
|
case AudioSystem::AMR_WB:
|
|
#ifdef QCOM_QCHAT_ENABLED
|
|
case AudioSystem::EVRC:
|
|
case AudioSystem::EVRCB:
|
|
case AudioSystem::EVRCWB:
|
|
#endif
|
|
audioSystemFormat = mHandle->format;
|
|
break;
|
|
case SNDRV_PCM_FORMAT_S16_LE:
|
|
audioSystemFormat = AudioSystem::PCM_16_BIT;
|
|
break;
|
|
|
|
default:
|
|
LOG_FATAL("Unknown AudioSystem bit width %d!", audioSystemFormat);
|
|
audioSystemFormat = AudioSystem::PCM_16_BIT;
|
|
break;
|
|
}
|
|
|
|
ALOGV("ALSAFormat:0x%x,audioSystemFormat:0x%x",ALSAFormat,audioSystemFormat);
|
|
return audioSystemFormat;
|
|
}
|
|
|
|
uint32_t ALSAStreamOps::channels() const
|
|
{
|
|
return mHandle->channelMask;
|
|
}
|
|
|
|
void ALSAStreamOps::close()
|
|
{
|
|
ALOGD("close");
|
|
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)))) {
|
|
mParent->mVoipBitRate = 0;
|
|
mParent->mVoipStreamCount = 0;
|
|
}
|
|
mParent->mALSADevice->close(mHandle);
|
|
}
|
|
|
|
//
|
|
// 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::open(int mode)
|
|
{
|
|
ALOGD("open");
|
|
return mParent->mALSADevice->open(mHandle);
|
|
}
|
|
|
|
} // namespace androidi_audio_legacy
|