String8 AudioALSAStreamOut::getParameters(const String8 &keys)
{
#ifdef MTK_DYNAMIC_CHANGE_HAL_BUFFER_SIZE
ALOGD("%s, keyvalue %s", __FUNCTION__, keys.string());
String8 value;
String8 keyLowLatency = String8("LowLatency");
AudioParameter param = AudioParameter(keys);
AudioParameter returnParam = AudioParameter();
if (param.get(keyLowLatency, value) == NO_ERROR)
{
param.remove(keyLowLatency);
char buf[10];
sprintf(buf, "%d", LOW_LATENCY_HAL_BUFFER_SIZE);
returnParam.add(keyLowLatency, String8(buf));
}
const String8 keyValuePairs = returnParam.toString();
ALOGD("-%s(), return \"%s\"", __FUNCTION__, keyValuePairs.string());
return keyValuePairs;
#else
ALOGD("%s()", __FUNCTION__);
AudioParameter param = AudioParameter(keys);
return param.toString();
#endif
}
String8 A2dpAudioInterface::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
AudioParameter a2dpParam = AudioParameter();
String8 value;
String8 key;
key = "bluetooth_enabled";
if (param.get(key, value) == NO_ERROR) {
value = mBluetoothEnabled ? "true" : "false";
a2dpParam.add(key, value);
param.remove(key);
}
key = "A2dpSuspended";
if (param.get(key, value) == NO_ERROR) {
value = mSuspended ? "true" : "false";
a2dpParam.add(key, value);
param.remove(key);
}
String8 keyValuePairs = a2dpParam.toString();
if (param.size()) {
if (keyValuePairs != "") {
keyValuePairs += ";";
}
keyValuePairs += mHardwareInterface->getParameters(param.toString());
}
LOGV("getParameters() %s", keyValuePairs.string());
return keyValuePairs;
}
void AudioOffloadPlayer::SendMetaDataToHal(sp<AudioSink>& aSink,
const sp<MetaData>& aMeta)
{
int32_t sampleRate = 0;
int32_t bitRate = 0;
int32_t channelMask = 0;
int32_t delaySamples = 0;
int32_t paddingSamples = 0;
CHECK(aSink.get());
AudioParameter param = AudioParameter();
if (aMeta->findInt32(kKeySampleRate, &sampleRate)) {
param.addInt(String8(AUDIO_OFFLOAD_CODEC_SAMPLE_RATE), sampleRate);
}
if (aMeta->findInt32(kKeyChannelMask, &channelMask)) {
param.addInt(String8(AUDIO_OFFLOAD_CODEC_NUM_CHANNEL), channelMask);
}
if (aMeta->findInt32(kKeyBitRate, &bitRate)) {
param.addInt(String8(AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE), bitRate);
}
if (aMeta->findInt32(kKeyEncoderDelay, &delaySamples)) {
param.addInt(String8(AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES), delaySamples);
}
if (aMeta->findInt32(kKeyEncoderPadding, &paddingSamples)) {
param.addInt(String8(AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES), paddingSamples);
}
AUDIO_OFFLOAD_LOG(PR_LOG_DEBUG, ("SendMetaDataToHal: bitRate %d,"
" sampleRate %d, chanMask %d, delaySample %d, paddingSample %d", bitRate,
sampleRate, channelMask, delaySamples, paddingSamples));
aSink->SetParameters(param.toString());
return;
}
status_t AudioPolicyManager::startInput(audio_io_handle_t input)
{
status_t status = AudioPolicyManagerBase::startInput(input);
if (status == NO_ERROR) {
AudioInputDescriptor *inputDesc = mInputs.valueFor(input);
String8 key = String8("Input Source");
String8 value;
switch(inputDesc->mInputSource) {
case AUDIO_SOURCE_VOICE_RECOGNITION:
value = String8("Voice Recognition");
break;
case AUDIO_SOURCE_CAMCORDER:
value = String8("Camcorder");
break;
case AUDIO_SOURCE_DEFAULT:
case AUDIO_SOURCE_MIC:
value = String8("Default");
default:
break;
}
AudioParameter param = AudioParameter();
param.add(key, value);
mpClientInterface->setParameters(input, param.toString());
}
return status;
}
status_t A2dpAudioInterface::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 value;
String8 key;
status_t status = NO_ERROR;
LOGV("setParameters() %s", keyValuePairs.string());
key = "bluetooth_enabled";
if (param.get(key, value) == NO_ERROR) {
mBluetoothEnabled = (value == "true");
if (mOutput) {
mOutput->setBluetoothEnabled(mBluetoothEnabled);
}
param.remove(key);
}
key = String8("A2dpSuspended");
if (param.get(key, value) == NO_ERROR) {
mSuspended = (value == "true");
if (mOutput) {
mOutput->setSuspended(mSuspended);
}
param.remove(key);
}
if (param.size()) {
status_t hwStatus = mHardwareInterface->setParameters(param.toString());
if (status == NO_ERROR) {
status = hwStatus;
}
}
return status;
}
status_t AudioStreamInMotorola::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
status_t status = NO_ERROR;
int device;
String8 key;
int source;
LOGD("setParameters(%s) called", keyValuePairs.string());
// reading routing parameter
key = String8(AudioParameter::keyRouting);
if (param.getInt(key, device) == NO_ERROR) {
LOGD("setParameters(): set input routing %x", device);
if (device & (device - 1)) {
LOGE("setParameters(): device value is invalid for routing");
status = BAD_VALUE;
} else {
mDevices = device;
status = mHardware->doRouting();
}
param.remove(key);
}
if (param.size()) {
LOGE("setParameters(): parameter size is invalid");
status = BAD_VALUE;
}
return status;
}
status_t AudioStreamInWrapper::setParameters(const String8& keyValuePairs)
{
LOGV("AudioStreamInWrapper::setParameters(\"%s\")", keyValuePairs.string());
AudioParameter param = AudioParameter(keyValuePairs);
String8 key;
status_t status = NO_ERROR;
int device;
// reading routing parameter
key = String8(AudioParameter::keyRouting);
if (param.getInt(key, device) == NO_ERROR) {
LOGV("set input routing %x", device);
if (device & (device - 1)) {
status = BAD_VALUE;
} else {
mDevices = device;
status = mHardware->doRouting();
}
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
int exiting = -1;
AudioParameter parms = AudioParameter(String8(kvpairs));
// FIXME this is using hard-coded strings but in the future, this functionality will be
// converted to use audio HAL extensions required to support tunneling
if ((parms.getInt(String8("exiting"), exiting) == NO_ERROR) && (exiting > 0)) {
const struct submix_stream_out *out =
reinterpret_cast<const struct submix_stream_out *>(stream);
pthread_mutex_lock(&out->dev->lock);
{ // using the sink
sp<MonoPipe> sink = out->dev->rsxSink.get();
if (sink == 0) {
pthread_mutex_unlock(&out->dev->lock);
return 0;
}
ALOGI("shutdown");
sink->shutdown(true);
} // done using the sink
pthread_mutex_unlock(&out->dev->lock);
}
return 0;
}
String8 AudioAACStreamIn::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);
}
ALOGV("getParameters() %s", param.toString().string());
return param.toString();
}
String8 AudioStreamInMotorola::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);
}
LOGD("getParameters(%s)", param.toString().string());
return param.toString();
}
String8 AudioHardware::AudioStreamOutMSM72xx::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
LOGV("get routing %x", mDevices);
param.addInt(key, (int)mDevices);
}
LOGV("AudioStreamOutMSM72xx::getParameters() %s", param.toString().string());
return param.toString();
}
status_t AudioResourceManager::setParameter(const String8& keyValuePairs) {
String8 key;
String8 value;
status_t status = NO_ERROR;
AudioParameter param = AudioParameter(keyValuePairs);
Mutex::Autolock autolock(mLock);
ALOGD(" setParameter %s:", keyValuePairs.string());
for(uint8_t i=0; i < ARRAY_SIZE(sUseCaseNameToEnumValue); i++) {
key = sUseCaseNameToEnumValue[i].name;
if (param.get(key, value) == NO_ERROR) {
audio_use_case_value_t useCase =
(audio_use_case_value_t) extractMetaData(
sUseCaseNameToEnumValue,
ARRAY_SIZE(sUseCaseNameToEnumValue),
key);
ALOGD("key = %s, value = %s, useCase = %d",
key.string(), value.string(), (int32_t)useCase);
if(value == "true") {
// check if there is a conflicting usecase
// if yes, return error without updating the refCount
// if no increment the refCount
ALOGV("handleConcurrency");
status = handleConcurrency(useCase, true);
}
else if(value == "false") {
// Decrement the refCount
ALOGV("updateUsecaseRefCount");
status = updateUsecaseRefCount(useCase, false);
}
else {
ALOGE(" Wrong value set for use case = %s", key.string());
status = BAD_VALUE;
}
break;
} else {
status = NAME_NOT_FOUND;
ALOGV("Not a concurrency setParameter - Not an error");
}
}
param.remove(key);
return status;
}
String8 AudioStreamInWrapper::getParameters(const String8& keys)
{
LOGV("AudioStreamInWrapper::getParameters(\"%s\")", keys.string());
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8(AudioParameter::keyRouting);
if (param.get(key, value) == NO_ERROR) {
LOGV("get routing %x", mDevices);
param.addInt(key, (int)mDevices);
}
LOGV("AudioStreamInWrapper::getParameters() %s", param.toString().string());
return param.toString();
}
String8 A2dpAudioInterface::A2dpAudioStreamOut::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
String8 value;
String8 key = String8("a2dp_sink_address");
if (param.get(key, value) == NO_ERROR) {
value = mA2dpAddress;
param.add(key, value);
}
key = AudioParameter::keyRouting;
if (param.get(key, value) == NO_ERROR) {
param.addInt(key, (int)mDevice);
}
LOGV("A2dpAudioStreamOut::getParameters() %s", param.toString().string());
return param.toString();
}
status_t AudioAACStreamIn::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 key = String8(AudioParameter::keyRouting);
status_t status = NO_ERROR;
int device;
ALOGV("setParameters() %s", keyValuePairs.string());
if (param.getInt(key, device) == NO_ERROR) {
mDevice = device;
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
int AudioFtm::Audio_FM_I2S_Play(char bEnable)
{
ALOGD("%s()", __FUNCTION__);
const float kMaxFmVolume = 1.0;
if (mStreamOut == NULL)
{
if (mStreamManager->getStreamOutVectorSize() == 0) // Factory mode
{
uint32_t devices = 0x2;
int format = 0x1;
uint32_t channels = 0x3;
uint32_t sampleRate = 44100;
status_t status = 0;
mStreamManager->openOutputStream(devices, &format, &channels, &sampleRate, &status);
}
mStreamOut = mStreamManager->getStreamOut(0);
}
if (bEnable == true)
{
// force assigned earphone
AudioParameter paramRouting = AudioParameter();
paramRouting.addInt(String8(AudioParameter::keyRouting), AUDIO_DEVICE_OUT_WIRED_HEADPHONE);
mStreamOut->setParameters(paramRouting.toString());
// enable
mStreamManager->setFmVolume(0);
mStreamManager->setFmEnable(true);
mStreamManager->setFmVolume(kMaxFmVolume);
}
else
{
// disable
mStreamManager->setFmVolume(0);
mStreamManager->setFmEnable(false);
}
return true;
}
/*
Overwriting this function from base class to allow 2 acitve AudioRecord clients in case of FM.
One for FM A2DP playbck and other for FM recording.
*/
status_t AudioPolicyManager::startInput(audio_io_handle_t input)
{
LOGV("startInput() input %d", input);
ssize_t index = mInputs.indexOfKey(input);
if (index < 0) {
LOGW("startInput() unknow input %d", input);
return BAD_VALUE;
}
AudioInputDescriptor *inputDesc = mInputs.valueAt(index);
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyRouting), (int)inputDesc->mDevice);
// use Voice Recognition mode or not for this input based on input source
int vr_enabled = inputDesc->mInputSource == AUDIO_SOURCE_VOICE_RECOGNITION ? 1 : 0;
param.addInt(String8("vr_mode"), vr_enabled);
LOGV("AudioPolicyManager::startInput(%d), setting vr_mode to %d", inputDesc->mInputSource, vr_enabled);
mpClientInterface->setParameters(input, param.toString());
inputDesc->mRefCount = 1;
return NO_ERROR;
}
status_t AudioStreamInHandler::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 key = String8(AudioParameter::keyRouting);
status_t status = NO_ERROR;
int device;
ALOGV("setParameters() %s", keyValuePairs.string());
if(msetAttribute.mdevices == 0xFFFFFFFF)
{
ALOGD("setparameter to device invalid");
return status;
}
if(mStreamInput){
return mStreamInput->setParameters (keyValuePairs);
}
return status;
}
status_t AudioHardware::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 value;
String8 key;
const char BT_NREC_KEY[] = "bt_headset_nrec";
const char BT_NAME_KEY[] = "bt_headset_name";
const char BT_NREC_VALUE_ON[] = "on";
LOGV("setParameters() %s", keyValuePairs.string());
if (keyValuePairs.length() == 0) return BAD_VALUE;
key = String8(BT_NREC_KEY);
if (param.get(key, value) == NO_ERROR) {
if (value == BT_NREC_VALUE_ON) {
mBluetoothNrec = true;
} else {
mBluetoothNrec = false;
LOGI("Turning noise reduction and echo cancellation off for BT "
"headset");
}
}
key = String8(BT_NAME_KEY);
if (param.get(key, value) == NO_ERROR) {
mBluetoothId = 0;
for (int i = 0; i < mNumSndEndpoints; i++) {
if (!strcasecmp(value.string(), mSndEndpoints[i].name)) {
mBluetoothId = mSndEndpoints[i].id;
LOGI("Using custom acoustic parameters for %s", value.string());
break;
}
}
if (mBluetoothId == 0) {
LOGI("Using default acoustic parameters "
"(%s not in acoustic database)", value.string());
doRouting();
}
}
return NO_ERROR;
}
status_t AudioHardware::AudioStreamOutMSM72xx::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 key = String8(AudioParameter::keyRouting);
status_t status = NO_ERROR;
int device;
LOGV("AudioStreamOutMSM72xx::setParameters() %s", keyValuePairs.string());
if (param.getInt(key, device) == NO_ERROR) {
mDevices = device;
LOGV("set output routing %x", mDevices);
status = mHardware->doRouting();
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
char* AudioHardwareOutput::getParameters(const char* keys) {
Settings s;
// Explicit scope for auto-lock pattern.
{
// Snapshot the current settings so we don't have to hold the settings
// lock while formatting the results.
Mutex::Autolock _l(mSettingsLock);
s = mSettings;
}
AudioParameter param = AudioParameter(String8(keys));
String8 tmp;
/***************************************************************
* HDMI Audio Options *
***************************************************************/
if (param.get(kHDMIAllowedParamKey, tmp) == NO_ERROR)
param.addInt(kHDMIAllowedParamKey, s.hdmi.allowed ? 1 : 0);
if (param.get(kHDMIDelayCompParamKey, tmp) == NO_ERROR)
param.addFloat(kHDMIDelayCompParamKey,
static_cast<float>(s.hdmi.delayCompUsec) / 1000.0);
if (param.get(kFixedHDMIOutputParamKey, tmp) == NO_ERROR)
param.addInt(kFixedHDMIOutputParamKey, s.hdmi.isFixed ? 1 : 0);
if (param.get(kFixedHDMIOutputLevelParamKey, tmp) == NO_ERROR)
param.addFloat(kFixedHDMIOutputLevelParamKey, s.hdmi.fixedLvl);
/***************************************************************
* Other Options *
***************************************************************/
if (param.get(kVideoDelayCompParamKey, tmp) == NO_ERROR)
param.addFloat(kVideoDelayCompParamKey,
static_cast<float>(s.videoDelayCompUsec) / 1000.0);
return strdup(param.toString().string());
}
status_t AudioStreamOutWrapper::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 key = String8(AudioParameter::keyRouting);
status_t status = NO_ERROR;
int device;
LOGV("AudioStreamOutWrapper::setParameters(\"%s\")", keyValuePairs.string());
if (param.getInt(key, device) == NO_ERROR) {
mDevices = device;
LOGV("set output routing %x", mDevices);
uint32_t routes = devicesToRoutes(mDevices);
status = mHardware->setRouting(AudioSystem::MODE_NORMAL, routes);
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
status_t A2dpAudioInterface::A2dpAudioStreamOut::setParameters(const String8& keyValuePairs)
{
AudioParameter param = AudioParameter(keyValuePairs);
String8 value;
String8 key = String8("a2dp_sink_address");
status_t status = NO_ERROR;
int device;
LOGV("A2dpAudioStreamOut::setParameters() %s", keyValuePairs.string());
if (param.get(key, value) == NO_ERROR) {
if (value.length() != strlen("00:00:00:00:00:00")) {
status = BAD_VALUE;
} else {
setAddress(value.string());
}
param.remove(key);
}
key = String8("closing");
if (param.get(key, value) == NO_ERROR) {
mClosing = (value == "true");
param.remove(key);
}
key = AudioParameter::keyRouting;
if (param.getInt(key, device) == NO_ERROR) {
if (AudioSystem::isA2dpDevice((AudioSystem::audio_devices)device)) {
mDevice = device;
status = NO_ERROR;
} else {
status = BAD_VALUE;
}
param.remove(key);
}
if (param.size()) {
status = BAD_VALUE;
}
return status;
}
status_t AudioHardwareOutput::setParameters(const char* kvpairs) {
AudioParameter param = AudioParameter(String8(kvpairs));
status_t status = NO_ERROR;
float floatVal;
int intVal;
Settings initial, s;
{
// Record the initial state of the settings from inside the lock. Then
// leave the lock in order to parse the changes to be made.
Mutex::Autolock _l(mSettingsLock);
initial = s = mSettings;
}
/***************************************************************
* HDMI Audio Options *
***************************************************************/
if (param.getInt(kHDMIAllowedParamKey, intVal) == NO_ERROR) {
s.hdmi.allowed = (intVal != 0);
param.remove(kHDMIAllowedParamKey);
}
if ((param.getFloat(kHDMIDelayCompParamKey, floatVal) == NO_ERROR) &&
(floatVal >= 0.0) &&
(floatVal <= AudioOutput::kMaxDelayCompensationMSec)) {
uint32_t delay_comp = static_cast<uint32_t>(floatVal * 1000.0);
s.hdmi.delayCompUsec = delay_comp;
param.remove(kHDMIDelayCompParamKey);
}
if (param.getInt(kFixedHDMIOutputParamKey, intVal) == NO_ERROR) {
s.hdmi.isFixed = (intVal != 0);
param.remove(kFixedHDMIOutputParamKey);
}
if ((param.getFloat(kFixedHDMIOutputLevelParamKey, floatVal) == NO_ERROR)
&& (floatVal <= 0.0)) {
s.hdmi.fixedLvl = floatVal;
param.remove(kFixedHDMIOutputLevelParamKey);
}
/***************************************************************
* Other Options *
***************************************************************/
if ((param.getFloat(kVideoDelayCompParamKey, floatVal) == NO_ERROR) &&
(floatVal >= 0.0) &&
(floatVal <= AudioOutput::kMaxDelayCompensationMSec)) {
s.videoDelayCompUsec = static_cast<uint32_t>(floatVal * 1000.0);
param.remove(kVideoDelayCompParamKey);
}
if (param.size())
status = BAD_VALUE;
// If there was a change made to settings, go ahead and apply it now.
bool allowedOutputsChanged = false;
if (memcmp(&initial, &s, sizeof(initial))) {
Mutex::Autolock _l1(mOutputLock);
Mutex::Autolock _l2(mSettingsLock);
if (memcmp(&initial.hdmi, &s.hdmi, sizeof(initial.hdmi)))
allowedOutputsChanged = allowedOutputsChanged ||
applyOutputSettings_l(initial.hdmi, s.hdmi, mSettings.hdmi,
HDMIAudioOutput::classDevMask());
if (initial.videoDelayCompUsec != s.videoDelayCompUsec)
mSettings.videoDelayCompUsec = s.videoDelayCompUsec;
uint32_t tmp = 0;
if (mSettings.hdmi.allowed && (tmp < mSettings.hdmi.delayCompUsec))
tmp = mSettings.hdmi.delayCompUsec;
if (mMaxDelayCompUsec != tmp)
mMaxDelayCompUsec = tmp;
}
if (allowedOutputsChanged) {
Mutex::Autolock _l(mStreamLock);
updateTgtDevices_l();
}
return status;
}
status_t AudioPolicyManager::setDeviceConnectionState(AudioSystem::audio_devices device,
AudioSystem::device_connection_state state,
const char *device_address)
{
LOGV("setDeviceConnectionState() device: %x, state %d, address %s", device, state, device_address);
// connect/disconnect only 1 device at a time
if (AudioSystem::popCount(device) != 1) return BAD_VALUE;
if (strlen(device_address) >= MAX_DEVICE_ADDRESS_LEN) {
LOGE("setDeviceConnectionState() invalid address: %s", device_address);
return BAD_VALUE;
}
// handle output devices
if (AudioSystem::isOutputDevice(device)) {
#ifndef WITH_A2DP
if (AudioSystem::isA2dpDevice(device)) {
LOGE("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}
#endif
switch (state)
{
// handle output device connection
case AudioSystem::DEVICE_STATE_AVAILABLE:
if (mAvailableOutputDevices & device) {
LOGW("setDeviceConnectionState() device already connected: %x", device);
return INVALID_OPERATION;
}
LOGV("setDeviceConnectionState() connecting device %x", device);
// register new device as available
mAvailableOutputDevices |= device;
#ifdef WITH_A2DP
// handle A2DP device connection
if (AudioSystem::isA2dpDevice(device)) {
status_t status = handleA2dpConnection(device, device_address);
if (status != NO_ERROR) {
mAvailableOutputDevices &= ~device;
return status;
}
} else
#endif
{
if (AudioSystem::isBluetoothScoDevice(device)) {
LOGV("setDeviceConnectionState() BT SCO device, address %s", device_address);
// keep track of SCO device address
mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
}
}
break;
// handle output device disconnection
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableOutputDevices & device)) {
LOGW("setDeviceConnectionState() device not connected: %x", device);
return INVALID_OPERATION;
}
LOGV("setDeviceConnectionState() disconnecting device %x", device);
// remove device from available output devices
mAvailableOutputDevices &= ~device;
#ifdef WITH_A2DP
// handle A2DP device disconnection
if (AudioSystem::isA2dpDevice(device)) {
status_t status = handleA2dpDisconnection(device, device_address);
if (status != NO_ERROR) {
mAvailableOutputDevices |= device;
return status;
}
} else
#endif
{
if (AudioSystem::isBluetoothScoDevice(device)) {
mScoDeviceAddress = "";
}
}
} break;
default:
LOGE("setDeviceConnectionState() invalid state: %x", state);
return BAD_VALUE;
}
#ifdef HAVE_FM_RADIO
if (device == AudioSystem::DEVICE_OUT_FM) {
AudioOutputDescriptor *out = mOutputs.valueFor(mHardwareOutput);
if (state == AudioSystem::DEVICE_STATE_AVAILABLE) {
out->changeRefCount(AudioSystem::FM, 1);
if (out->mRefCount[AudioSystem::FM] > 0)
mpClientInterface->setParameters(0, String8("fm_on=1"));
}
else {
out->changeRefCount(AudioSystem::FM, -1);
if (out->mRefCount[AudioSystem::FM] <= 0)
mpClientInterface->setParameters(0, String8("fm_off=1"));
}
}
#endif
// request routing change if necessary
uint32_t newDevice = getNewDevice(mHardwareOutput, false);
#ifdef WITH_A2DP
checkA2dpSuspend();
checkOutputForAllStrategies();
// A2DP outputs must be closed after checkOutputForAllStrategies() is executed
if (state == AudioSystem::DEVICE_STATE_UNAVAILABLE && AudioSystem::isA2dpDevice(device)) {
closeA2dpOutputs();
}
#endif
updateDeviceForStrategy();
setOutputDevice(mHardwareOutput, newDevice);
if (device == AudioSystem::DEVICE_OUT_WIRED_HEADSET) {
device = AudioSystem::DEVICE_IN_WIRED_HEADSET;
} else if (device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO ||
device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET ||
device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET;
} else {
return NO_ERROR;
}
}
// handle input devices
if (AudioSystem::isInputDevice(device)) {
switch (state)
{
// handle input device connection
case AudioSystem::DEVICE_STATE_AVAILABLE: {
if (mAvailableInputDevices & device) {
LOGW("setDeviceConnectionState() device already connected: %d", device);
return INVALID_OPERATION;
}
mAvailableInputDevices |= device;
}
break;
// handle input device disconnection
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableInputDevices & device)) {
LOGW("setDeviceConnectionState() device not connected: %d", device);
return INVALID_OPERATION;
}
mAvailableInputDevices &= ~device;
} break;
default:
LOGE("setDeviceConnectionState() invalid state: %x", state);
return BAD_VALUE;
}
audio_io_handle_t activeInput = getActiveInput();
if (activeInput != 0) {
AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
uint32_t newDevice = getDeviceForInputSource(inputDesc->mInputSource);
if (newDevice != inputDesc->mDevice) {
LOGV("setDeviceConnectionState() changing device from %x to %x for input %d",
inputDesc->mDevice, newDevice, activeInput);
inputDesc->mDevice = newDevice;
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
mpClientInterface->setParameters(activeInput, param.toString());
}
}
return NO_ERROR;
}
LOGW("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}
status_t AudioALSAStreamIn::setParameters(const String8 &keyValuePairs)
{
ALOGD("+%s(): %s", __FUNCTION__, keyValuePairs.string());
AudioParameter param = AudioParameter(keyValuePairs);
/// keys
const String8 keyInputSource = String8(AudioParameter::keyInputSource);
const String8 keyRouting = String8(AudioParameter::keyRouting);
/// parse key value pairs
status_t status = NO_ERROR;
int value = 0;
/// intput source
if (param.getInt(keyInputSource, value) == NO_ERROR)
{
param.remove(keyInputSource);
// TODO(Harvey): input source
AudioAutoTimeoutLock _l(mLock);
ALOGD("%s() InputSource = %d", __FUNCTION__, value);
mStreamAttributeTarget.input_source = static_cast<audio_source_t>(value);
if (mStreamAttributeTarget.BesRecord_Info.besrecord_ForceMagiASREnable == true)
{
ALOGD("%s() force input source to AUDIO_SOURCE_CUSTOMIZATION1", __FUNCTION__);
mStreamAttributeTarget.input_source = AUDIO_SOURCE_CUSTOMIZATION1;
}
if (mStreamAttributeTarget.BesRecord_Info.besrecord_ForceAECRecEnable == true)
{
ALOGD("%s() force input source to AUDIO_SOURCE_CUSTOMIZATION2", __FUNCTION__);
mStreamAttributeTarget.input_source = AUDIO_SOURCE_CUSTOMIZATION2;
}
}
/// routing
if (param.getInt(keyRouting, value) == NO_ERROR)
{
param.remove(keyRouting);
AudioAutoTimeoutLock _l(mLock);
audio_devices_t inputdevice = static_cast<audio_devices_t>(value);
//only need to modify the device while VoIP
if (mStreamAttributeTarget.BesRecord_Info.besrecord_voip_enable == true)
{
if (mStreamAttributeTarget.output_devices == AUDIO_DEVICE_OUT_SPEAKER)
{
if (inputdevice == AUDIO_DEVICE_IN_BUILTIN_MIC)
{
if (USE_REFMIC_IN_LOUDSPK == 1)
{
inputdevice = AUDIO_DEVICE_IN_BACK_MIC;
ALOGD("%s() force change to back mic", __FUNCTION__);
}
}
}
}
status = mStreamManager->routingInputDevice(mStreamAttributeTarget.input_device, inputdevice);
}
if (param.size())
{
ALOGW("%s(), still have param.size() = %d, remain param = \"%s\"",
__FUNCTION__, param.size(), param.toString().string());
status = BAD_VALUE;
}
ALOGD("-%s(): %s ", __FUNCTION__, keyValuePairs.string());
return status;
}
status_t AudioALSAStreamOut::setParameters(const String8 &keyValuePairs)
{
ALOGD("+%s(): %s", __FUNCTION__, keyValuePairs.string());
AudioParameter param = AudioParameter(keyValuePairs);
/// keys
const String8 keyRouting = String8(AudioParameter::keyRouting);
const String8 keySampleRate = String8(AudioParameter::keySamplingRate);
const String8 keyDynamicSampleRate = String8("DynamicSampleRate");
const String8 keyLowLatencyMode = String8("LowLatencyMode");
const String8 keyRoutingToNone = String8(AudioParameter::keyRoutingToNone);
const String8 keyFmDirectControl = String8(AudioParameter::keyFmDirectControl);
audio_devices_t mydevice = 0;
/// parse key value pairs
status_t status = NO_ERROR;
int value = 0;
/// routing
if (param.getInt(keyRouting, value) == NO_ERROR)
{
param.remove(keyRouting);
mydevice = static_cast<audio_devices_t>(value);
ALOGD("%s(), mydevice 0x%x", __FUNCTION__, mydevice);
AudioAutoTimeoutLock _l(mLock);
if (mStreamOutType == STREAM_OUT_PRIMARY)
{
status = mStreamManager->routingOutputDevice(mStreamAttributeSource.output_devices, static_cast<audio_devices_t>(value));
}
else if ((mStreamOutType == STREAM_OUT_HDMI_STEREO) || (mStreamOutType == STREAM_OUT_HDMI_MULTI_CHANNEL))
{
ALOGD("%s(), HDMI \"%s\"", __FUNCTION__, param.toString().string());
status = mStreamManager->routingOutputDevice(mStreamAttributeSource.output_devices, static_cast<audio_devices_t>(value));
}
else
{
ALOGW("%s(), NUM_STREAM_OUT_TYPE \"%s\"", __FUNCTION__, param.toString().string());
status = INVALID_OPERATION;
}
}
if (param.getInt(keyFmDirectControl, value) == NO_ERROR)
{
param.remove(keyFmDirectControl);
AudioAutoTimeoutLock _l(mLock);
AudioALSAFMController::getInstance()->setUseFmDirectConnectionMode(value?true:false);
}
// routing none, for no stream but has device change. e.g. vow path change
if (param.getInt(keyRoutingToNone, value) == NO_ERROR)
{
param.remove(keyRoutingToNone);
AudioAutoTimeoutLock _l(mLock);
status = mStreamManager->DeviceNoneUpdate();
}
// samplerate
if (param.getInt(keySampleRate, value) == NO_ERROR)
{
param.remove(keySampleRate);
AudioAutoTimeoutLock _l(mLock);
if (mPlaybackHandler == NULL)
{
UpdateSampleRate(value);
}
else
{
status = INVALID_OPERATION;
}
}
/// sample rate
if (param.getInt(keyDynamicSampleRate, value) == NO_ERROR)
{
param.remove(keyRouting);
AudioAutoTimeoutLock _l(mLock);
if (mStreamOutType == STREAM_OUT_PRIMARY)
{
status = NO_ERROR; //AudioALSASampleRateController::getInstance()->setPrimaryStreamOutSampleRate(value); // TODO(Harvey): enable it later
}
else
{
ALOGW("%s(), HDMI bypass \"%s\"", __FUNCTION__, param.toString().string());
status = INVALID_OPERATION;
}
}
#ifdef MTK_DYNAMIC_CHANGE_HAL_BUFFER_SIZE
// set low latency
if (param.getInt(keyLowLatencyMode, value) == NO_ERROR)
{
param.remove(keyLowLatencyMode);
setLowLatencyMode(value);
}
#endif
if (param.size())
{
ALOGW("%s(), still have param.size() = %d, remain param = \"%s\"",
__FUNCTION__, param.size(), param.toString().string());
status = BAD_VALUE;
}
ALOGD("-%s(): %s ", __FUNCTION__, keyValuePairs.string());
return status;
}
// default implementation
String8 AudioHardwareBase::getParameters(const String8 &keys)
{
AudioParameter param = AudioParameter(keys);
return param.toString();
}
String8 AudioStreamInStub::getParameters(const String8& keys)
{
AudioParameter param = AudioParameter(keys);
return param.toString();
}
String8 AudioALSAStreamIn::getParameters(const String8 &keys)
{
ALOGD("%s()", __FUNCTION__);
AudioParameter param = AudioParameter(keys);
return param.toString();
}
