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 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; }
void AudioPolicyManagerSPRD::releaseOutput(audio_io_handle_t output) { #ifdef DUMP_DEBUG ALOGD("releaseOutput() %d", output); #endif ssize_t index = mOutputs.indexOfKey(output); if (index < 0) { ALOGW("releaseOutput() releasing unknown output %d", output); return; } if(is_voip_set) { AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); if(outputDesc->mRefCount[AudioSystem::VOICE_CALL] == 0) { AudioParameter param; param.add(String8("sprd_voip_start"), String8("false")); mpClientInterface->setParameters(0, param.toString()); is_voip_set = false; } } #ifdef AUDIO_POLICY_TEST int testIndex = testOutputIndex(output); if (testIndex != 0) { AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); if (outputDesc->isActive()) { mpClientInterface->closeOutput(output); delete mOutputs.valueAt(index); mOutputs.removeItem(output); mTestOutputs[testIndex] = 0; } return; } #endif //AUDIO_POLICY_TEST AudioOutputDescriptor *desc = mOutputs.valueAt(index); if (desc->mFlags & AudioSystem::OUTPUT_FLAG_DIRECT) { if (desc->mDirectOpenCount <= 0) { ALOGW("releaseOutput() invalid open count %d for output %d", desc->mDirectOpenCount, output); return; } if (--desc->mDirectOpenCount == 0) { closeOutput(output); // If effects where present on the output, audioflinger moved them to the primary // output by default: move them back to the appropriate output. audio_io_handle_t dstOutput = getOutputForEffect(); if (dstOutput != mPrimaryOutput) { mpClientInterface->moveEffects(AUDIO_SESSION_OUTPUT_MIX, mPrimaryOutput, dstOutput); } } } }
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 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 }
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; }
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; }
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 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 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; }
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; }
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 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; }
bool WrappedJucePlugin::loadPluginStuff () { if (instance) { int numParams = instance->getNumParameters(); setNumParameters (numParams); for (int i=0; i<numParams; i++) { AudioParameter* parameter = new AudioParameter (); parameter->part (i); parameter->name (instance->getParameterName(i)); parameter->get (MakeDelegate (this, &WrappedJucePlugin::getParameterReal)); parameter->set (MakeDelegate (this, &WrappedJucePlugin::setParameterReal)); parameter->text (MakeDelegate (this, &WrappedJucePlugin::getParameterTextReal)); registerParameter(i, parameter); } } return true; }
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 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; }
String8 AudioALSAStreamIn::getParameters(const String8 &keys) { ALOGD("%s()", __FUNCTION__); AudioParameter param = AudioParameter(keys); return param.toString(); }
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(); }
//============================================================================== bool LadspaPlugin::loadPluginFromFile (const File& filePath) { ptrLibrary = PlatformUtilities::loadDynamicLibrary (filePath.getFullPathName()); if (ptrLibrary != 0) { LADSPA_Descriptor_Function pfDescriptorFunction = (LADSPA_Descriptor_Function) PlatformUtilities::getProcedureEntryPoint (ptrLibrary, T("ladspa_descriptor")); if (pfDescriptorFunction != 0) { for (uint32 iPluginIndex = 0;; iPluginIndex++) { ptrPlug = pfDescriptorFunction (iPluginIndex); if (ptrPlug != NULL) break; } if (ptrPlug == 0) { printf ("Cannot find any valid descriptor in shared library \n"); return false; } } else { // plugin raised an exception printf ("Cannot find any valid plugin in shared library \n"); return false; } } else { printf ("You are trying to load a shared library ? \n"); return false; } jassert (ptrPlug); pluginFile = filePath; plugin = ptrPlug->instantiate (ptrPlug, (unsigned int) samplingRate); ins.clear (); outs.clear (); pars.clear (); for (unsigned int i = 0; i < ptrPlug->PortCount; i++) { if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_CONTROL) pars.add (i); if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_AUDIO) { if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_INPUT) ins.add (i); if (ptrPlug->PortDescriptors [i] & LADSPA_PORT_OUTPUT) outs.add (i); } } int numParams = pars.size (); params = new float [numParams]; normalized = new float [numParams]; memset (params, 0, numParams * sizeof (float)); memset (normalized, 0, numParams * sizeof (float)); for (int i = 0; i < numParams; i++) ptrPlug->connect_port (plugin, pars [i], &normalized[i]); // create params setNumParameters (numParams); for (int i = 0; i < numParams; i++) { AudioParameter* parameter = new AudioParameter (); parameter->part (i); parameter->name (ptrPlug->PortNames [pars [i]]); parameter->get (MakeDelegate (this, &LadspaPlugin::getParameterReal)); parameter->set (MakeDelegate (this, &LadspaPlugin::setParameterReal)); parameter->text (MakeDelegate (this, &LadspaPlugin::getParameterTextReal)); registerParameter (i, parameter); } // setCurrentProgram (0); return true; }