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(); }