/* * Copyright (C) 2010 The Android Open Source Project * * 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 "sles_allinclusive.h" #include "math.h" #include "utils/RefBase.h" #include "utils/String16.h" #include #include #include #include #include #include #include #include #include using android::content::AttributionSourceState; static const int EQUALIZER_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t) + EFFECT_STRING_LEN_MAX; static const int BASSBOOST_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); static const int VIRTUALIZER_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); static const int ENVREVERB_PARAM_SIZE_MAX_SINGLE = sizeof(effect_param_t) + 2 * sizeof(int32_t); static const int ENVREVERB_PARAM_SIZE_MAX_ALL = sizeof(effect_param_t) + sizeof(int32_t) + sizeof(s_reverb_settings); static const int PRESETREVERB_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); static inline SLuint32 KEY_FROM_GUID(SLInterfaceID pUuid) { return pUuid->time_low; } //----------------------------------------------------------------------------- static uint32_t eq_paramSize(int32_t param) { uint32_t size; switch (param) { case EQ_PARAM_NUM_BANDS: case EQ_PARAM_LEVEL_RANGE: case EQ_PARAM_CUR_PRESET: case EQ_PARAM_GET_NUM_OF_PRESETS: size = sizeof(int32_t); break; case EQ_PARAM_BAND_LEVEL: case EQ_PARAM_CENTER_FREQ: case EQ_PARAM_BAND_FREQ_RANGE: case EQ_PARAM_GET_BAND: case EQ_PARAM_GET_PRESET_NAME: size = 2 * sizeof(int32_t); break; default: size = 2 * sizeof(int32_t); SL_LOGE("Trying to use an unknown EQ parameter %d", param); break; } return size; } static uint32_t eq_valueSize(int32_t param) { uint32_t size; switch (param) { case EQ_PARAM_NUM_BANDS: case EQ_PARAM_CUR_PRESET: case EQ_PARAM_GET_NUM_OF_PRESETS: case EQ_PARAM_BAND_LEVEL: case EQ_PARAM_GET_BAND: size = sizeof(int16_t); break; case EQ_PARAM_LEVEL_RANGE: size = 2 * sizeof(int16_t); break; case EQ_PARAM_CENTER_FREQ: size = sizeof(int32_t); break; case EQ_PARAM_BAND_FREQ_RANGE: size = 2 * sizeof(int32_t); break; case EQ_PARAM_GET_PRESET_NAME: size = EFFECT_STRING_LEN_MAX; break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown EQ parameter %d", param); break; } return size; } //----------------------------------------------------------------------------- /** * returns the size in bytes of the value of each bass boost parameter */ static uint32_t bb_valueSize(int32_t param) { uint32_t size; switch (param) { case BASSBOOST_PARAM_STRENGTH_SUPPORTED: size = sizeof(int32_t); break; case BASSBOOST_PARAM_STRENGTH: size = sizeof(int16_t); break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown BassBoost parameter %d", param); break; } return size; } //----------------------------------------------------------------------------- /** * returns the size in bytes of the value of each virtualizer parameter */ static uint32_t virt_valueSize(int32_t param) { uint32_t size; switch (param) { case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: size = sizeof(int32_t); break; case VIRTUALIZER_PARAM_STRENGTH: size = sizeof(int16_t); break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown Virtualizer parameter %d", param); break; } return size; } //----------------------------------------------------------------------------- /** * returns the size in bytes of the value of each environmental reverb parameter */ static uint32_t erev_valueSize(int32_t param) { uint32_t size; switch (param) { case REVERB_PARAM_ROOM_LEVEL: case REVERB_PARAM_ROOM_HF_LEVEL: case REVERB_PARAM_REFLECTIONS_LEVEL: case REVERB_PARAM_REVERB_LEVEL: size = sizeof(int16_t); // millibel break; case REVERB_PARAM_DECAY_TIME: case REVERB_PARAM_REFLECTIONS_DELAY: case REVERB_PARAM_REVERB_DELAY: size = sizeof(uint32_t); // milliseconds break; case REVERB_PARAM_DECAY_HF_RATIO: case REVERB_PARAM_DIFFUSION: case REVERB_PARAM_DENSITY: size = sizeof(int16_t); // permille break; case REVERB_PARAM_PROPERTIES: size = sizeof(s_reverb_settings); // struct of all reverb properties break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown Environmental Reverb parameter %d", param); break; } return size; } //----------------------------------------------------------------------------- android::status_t android_eq_getParam(const android::sp& pFx, int32_t param, int32_t param2, void *pValue) { android::status_t status; uint32_t buf32[(EQUALIZER_PARAM_SIZE_MAX - 1) / sizeof(uint32_t) + 1]; effect_param_t *p = (effect_param_t *)buf32; p->psize = eq_paramSize(param); *(int32_t *)p->data = param; if (p->psize == 2 * sizeof(int32_t)) { *((int32_t *)p->data + 1) = param2; } p->vsize = eq_valueSize(param); status = pFx->getParameter(p); if (android::NO_ERROR == status) { status = p->status; if (android::NO_ERROR == status) { memcpy(pValue, p->data + p->psize, p->vsize); } } return status; } //----------------------------------------------------------------------------- android::status_t android_eq_setParam(const android::sp& pFx, int32_t param, int32_t param2, void *pValue) { android::status_t status; uint32_t buf32[(EQUALIZER_PARAM_SIZE_MAX - 1) / sizeof(uint32_t) + 1]; effect_param_t *p = (effect_param_t *)buf32; p->psize = eq_paramSize(param); *(int32_t *)p->data = param; if (p->psize == 2 * sizeof(int32_t)) { *((int32_t *)p->data + 1) = param2; } p->vsize = eq_valueSize(param); memcpy(p->data + p->psize, pValue, p->vsize); status = pFx->setParameter(p); if (android::NO_ERROR == status) { status = p->status; } return status; } //----------------------------------------------------------------------------- android::status_t android_bb_setParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_setParam(pFx, param, BASSBOOST_PARAM_SIZE_MAX, pValue, bb_valueSize(param)); } //----------------------------------------------------------------------------- android::status_t android_bb_getParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_getParam(pFx, param, BASSBOOST_PARAM_SIZE_MAX, pValue, bb_valueSize(param)); } //----------------------------------------------------------------------------- void android_bb_init(audio_session_t sessionId, IBassBoost* ibb) { SL_LOGV("session %d", sessionId); if (!android_fx_initEffectObj(sessionId, ibb->mBassBoostEffect, &ibb->mBassBoostDescriptor.type)) { SL_LOGE("BassBoost effect initialization failed"); return; } // initialize strength int16_t strength; if (android::NO_ERROR == android_bb_getParam(ibb->mBassBoostEffect, BASSBOOST_PARAM_STRENGTH, &strength)) { ibb->mStrength = (SLpermille) strength; } } //----------------------------------------------------------------------------- void android_eq_init(audio_session_t sessionId, IEqualizer* ieq) { SL_LOGV("android_eq_init on session %d", sessionId); if (!android_fx_initEffectObj(sessionId, ieq->mEqEffect, &ieq->mEqDescriptor.type)) { SL_LOGE("Equalizer effect initialization failed"); return; } // initialize number of bands, band level range, and number of presets uint16_t num = 0; if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, EQ_PARAM_NUM_BANDS, 0, &num)) { ieq->mNumBands = num; } int16_t range[2] = {0, 0}; if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, EQ_PARAM_LEVEL_RANGE, 0, range)) { ieq->mBandLevelRangeMin = range[0]; ieq->mBandLevelRangeMax = range[1]; } SL_LOGV(" EQ init: num bands = %u, band range=[%d %d]mB", num, range[0], range[1]); // FIXME don't store presets names, they can be queried each time they're needed // initialize preset number and names, store in IEngine uint16_t numPresets = 0; if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, EQ_PARAM_GET_NUM_OF_PRESETS, 0, &numPresets)) { ieq->mThis->mEngine->mEqNumPresets = numPresets; ieq->mNumPresets = numPresets; } object_lock_exclusive(&ieq->mThis->mEngine->mObject); char name[EFFECT_STRING_LEN_MAX]; if ((0 < numPresets) && (NULL == ieq->mThis->mEngine->mEqPresetNames)) { ieq->mThis->mEngine->mEqPresetNames = (char **)new char *[numPresets]; for(uint32_t i = 0 ; i < numPresets ; i++) { if (android::NO_ERROR == android_eq_getParam(ieq->mEqEffect, EQ_PARAM_GET_PRESET_NAME, i, name)) { ieq->mThis->mEngine->mEqPresetNames[i] = new char[strlen(name) + 1]; strcpy(ieq->mThis->mEngine->mEqPresetNames[i], name); SL_LOGV(" EQ init: presets = %u is %s", i, ieq->mThis->mEngine->mEqPresetNames[i]); } } } object_unlock_exclusive(&ieq->mThis->mEngine->mObject); } //----------------------------------------------------------------------------- void android_virt_init(audio_session_t sessionId, IVirtualizer* ivi) { SL_LOGV("android_virt_init on session %d", sessionId); if (!android_fx_initEffectObj(sessionId, ivi->mVirtualizerEffect, &ivi->mVirtualizerDescriptor.type)) { SL_LOGE("Virtualizer effect initialization failed"); return; } // initialize strength int16_t strength; if (android::NO_ERROR == android_virt_getParam(ivi->mVirtualizerEffect, VIRTUALIZER_PARAM_STRENGTH, &strength)) { ivi->mStrength = (SLpermille) strength; } } //----------------------------------------------------------------------------- android::status_t android_virt_setParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_setParam(pFx, param, VIRTUALIZER_PARAM_SIZE_MAX, pValue, virt_valueSize(param)); } //----------------------------------------------------------------------------- android::status_t android_virt_getParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_getParam(pFx, param, VIRTUALIZER_PARAM_SIZE_MAX, pValue, virt_valueSize(param)); } //----------------------------------------------------------------------------- void android_prev_init(IPresetReverb* ipr) { SL_LOGV("session is implicitly %d (aux effect)", AUDIO_SESSION_OUTPUT_MIX); if (!android_fx_initEffectObj(AUDIO_SESSION_OUTPUT_MIX /*sessionId*/, ipr->mPresetReverbEffect, &ipr->mPresetReverbDescriptor.type)) { SL_LOGE("PresetReverb effect initialization failed"); return; } // initialize preset uint16_t preset; if (android::NO_ERROR == android_prev_getPreset(ipr->mPresetReverbEffect, &preset)) { ipr->mPreset = preset; // enable the effect if it has a preset loaded ipr->mPresetReverbEffect->setEnabled(SL_REVERBPRESET_NONE != preset); } } //----------------------------------------------------------------------------- android::status_t android_prev_setPreset(const android::sp& pFx, uint16_t preset) { android::status_t status = android_fx_setParam(pFx, REVERB_PARAM_PRESET, PRESETREVERB_PARAM_SIZE_MAX, &preset, sizeof(uint16_t)); // enable the effect if the preset is different from SL_REVERBPRESET_NONE pFx->setEnabled(SL_REVERBPRESET_NONE != preset); return status; } //----------------------------------------------------------------------------- android::status_t android_prev_getPreset(const android::sp& pFx, uint16_t* preset) { return android_fx_getParam(pFx, REVERB_PARAM_PRESET, PRESETREVERB_PARAM_SIZE_MAX, preset, sizeof(uint16_t)); } //----------------------------------------------------------------------------- void android_erev_init(IEnvironmentalReverb* ier) { SL_LOGV("session is implicitly %d (aux effect)", AUDIO_SESSION_OUTPUT_MIX); if (!android_fx_initEffectObj(AUDIO_SESSION_OUTPUT_MIX /*sessionId*/, ier->mEnvironmentalReverbEffect, &ier->mEnvironmentalReverbDescriptor.type)) { SL_LOGE("EnvironmentalReverb effect initialization failed"); return; } // enable env reverb: other SL ES effects have an explicit SetEnabled() function, and the // preset reverb state depends on the selected preset. ier->mEnvironmentalReverbEffect->setEnabled(true); // initialize reverb properties SLEnvironmentalReverbSettings properties; if (android::NO_ERROR == android_erev_getParam(ier->mEnvironmentalReverbEffect, REVERB_PARAM_PROPERTIES, &properties)) { ier->mProperties = properties; } } //----------------------------------------------------------------------------- android::status_t android_erev_setParam(const android::sp& pFx, int32_t param, void *pValue) { // given the size difference between a single reverb property and the whole set of reverb // properties, select which max size to pass to avoid allocating too much memory if (param == REVERB_PARAM_PROPERTIES) { return android_fx_setParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_ALL, pValue, erev_valueSize(param)); } else { return android_fx_setParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_SINGLE, pValue, erev_valueSize(param)); } } //----------------------------------------------------------------------------- android::status_t android_erev_getParam(const android::sp& pFx, int32_t param, void *pValue) { // given the size difference between a single reverb property and the whole set of reverb // properties, select which max size to pass to avoid allocating too much memory if (param == REVERB_PARAM_PROPERTIES) { return android_fx_getParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_ALL, pValue, erev_valueSize(param)); } else { return android_fx_getParam(pFx, param, ENVREVERB_PARAM_SIZE_MAX_SINGLE, pValue, erev_valueSize(param)); } } //----------------------------------------------------------------------------- void android_aec_init(audio_session_t sessionId, IAndroidAcousticEchoCancellation* iaec) { SL_LOGV("android_aec_init on session %d", sessionId); if (!android_fx_initEffectObj(sessionId, iaec->mAECEffect, &iaec->mAECDescriptor.type)) { SL_LOGE("AEC effect initialization failed"); return; } } //----------------------------------------------------------------------------- void android_agc_init(audio_session_t sessionId, IAndroidAutomaticGainControl* iagc) { SL_LOGV("android_agc_init on session %d", sessionId); if (!android_fx_initEffectObj(sessionId, iagc->mAGCEffect, &iagc->mAGCDescriptor.type)) { SL_LOGE("AGC effect initialization failed"); return; } } //----------------------------------------------------------------------------- void android_ns_init(audio_session_t sessionId, IAndroidNoiseSuppression* ins) { SL_LOGV("android_ns_init on session %d", sessionId); if (!android_fx_initEffectObj(sessionId, ins->mNSEffect, &ins->mNSDescriptor.type)) { SL_LOGE("NS effect initialization failed"); return; } } //----------------------------------------------------------------------------- /** * pre-condition: * ap != NULL * for media players: * ap->mAPlayer != 0 * ap->mTrackPlayer->mAudioTrack == 0 * for buffer queue players: * ap->mAPlayer == 0 * ap->mTrackPlayer->mAudioTrack != 0 is optional; if no track yet then the setting is deferred */ android::status_t android_fxSend_attach(CAudioPlayer* ap, bool attach, const android::sp& pFx, SLmillibel sendLevel) { if (pFx == 0) { return android::INVALID_OPERATION; } // There are 3 cases: // mAPlayer != 0 && mAudioTrack == 0 means playing decoded audio // mAPlayer == 0 && mAudioTrack != 0 means playing PCM audio // mAPlayer == 0 && mAudioTrack == 0 means player not fully configured yet // The asserts document and verify this. if (ap->mAPlayer != 0) { assert(ap->mTrackPlayer->mAudioTrack == 0); if (attach) { ap->mAPlayer->attachAuxEffect(pFx->id()); ap->mAPlayer->setAuxEffectSendLevel( sles_to_android_amplification(sendLevel) ); } else { ap->mAPlayer->attachAuxEffect(0); } return android::NO_ERROR; } if (ap->mTrackPlayer->mAudioTrack == 0) { // the player doesn't have an AudioTrack at the moment, so store this info to use it // when the AudioTrack becomes available if (attach) { ap->mAuxEffect = pFx; } else { ap->mAuxEffect.clear(); } // we keep track of the send level, independently of the current audio player level ap->mAuxSendLevel = sendLevel - ap->mVolume.mLevel; return android::NO_ERROR; } if (attach) { android::status_t status = ap->mTrackPlayer->mAudioTrack->attachAuxEffect(pFx->id()); //SL_LOGV("attachAuxEffect(%d) returned %d", pFx->id(), status); if (android::NO_ERROR == status) { status = ap->mTrackPlayer->mAudioTrack->setAuxEffectSendLevel( sles_to_android_amplification(sendLevel) ); } return status; } else { return ap->mTrackPlayer->mAudioTrack->attachAuxEffect(0); } } //----------------------------------------------------------------------------- /** * pre-condition: * ap != NULL * ap->mOutputMix != NULL */ SLresult android_fxSend_attachToAux(CAudioPlayer* ap, SLInterfaceID pUuid, SLboolean attach, SLmillibel sendLevel) { COutputMix *outputMix = CAudioPlayer_GetOutputMix(ap); ssize_t index = outputMix->mAndroidEffect.mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); if (0 > index) { SL_LOGE("invalid effect ID: no such effect attached to the OutputMix"); return SL_RESULT_PARAMETER_INVALID; } android::sp pFx = outputMix->mAndroidEffect.mEffects->valueAt(index); if (pFx == 0) { return SL_RESULT_RESOURCE_ERROR; } if (android::NO_ERROR == android_fxSend_attach( ap, (bool) attach, pFx, sendLevel) ) { return SL_RESULT_SUCCESS; } else { return SL_RESULT_RESOURCE_ERROR; } } //----------------------------------------------------------------------------- /** * pre-condition: * ap != NULL * for media players: * ap->mAPlayer != 0 * ap->mTrackPlayer->mAudioTrack == 0 * for buffer queue players: * ap->mAPlayer == 0 * ap->mTrackPlayer->mAudioTrack != 0 is optional; if no track yet then the setting is deferred */ android::status_t android_fxSend_setSendLevel(CAudioPlayer* ap, SLmillibel sendLevel) { // we keep track of the send level, independently of the current audio player level ap->mAuxSendLevel = sendLevel - ap->mVolume.mLevel; if (ap->mAPlayer != 0) { assert(ap->mTrackPlayer->mAudioTrack == 0); ap->mAPlayer->setAuxEffectSendLevel( sles_to_android_amplification(sendLevel) ); return android::NO_ERROR; } if (ap->mTrackPlayer->mAudioTrack == 0) { return android::NO_ERROR; } return ap->mTrackPlayer->mAudioTrack->setAuxEffectSendLevel( sles_to_android_amplification(sendLevel) ); } //----------------------------------------------------------------------------- android::status_t android_fx_setParam(const android::sp& pFx, int32_t param, uint32_t paramSizeMax, void *pValue, uint32_t valueSize) { android::status_t status; uint32_t buf32[(paramSizeMax - 1) / sizeof(uint32_t) + 1]; effect_param_t *p = (effect_param_t *)buf32; p->psize = sizeof(int32_t); *(int32_t *)p->data = param; p->vsize = valueSize; memcpy(p->data + p->psize, pValue, p->vsize); status = pFx->setParameter(p); if (android::NO_ERROR == status) { status = p->status; } return status; } //----------------------------------------------------------------------------- android::status_t android_fx_getParam(const android::sp& pFx, int32_t param, uint32_t paramSizeMax, void *pValue, uint32_t valueSize) { android::status_t status; uint32_t buf32[(paramSizeMax - 1) / sizeof(uint32_t) + 1]; effect_param_t *p = (effect_param_t *)buf32; p->psize = sizeof(int32_t); *(int32_t *)p->data = param; p->vsize = valueSize; status = pFx->getParameter(p); if (android::NO_ERROR == status) { status = p->status; if (android::NO_ERROR == status) { memcpy(pValue, p->data + p->psize, p->vsize); } } return status; } //----------------------------------------------------------------------------- SLresult android_fx_statusToResult(android::status_t status) { if ((android::INVALID_OPERATION == status) || (android::DEAD_OBJECT == status)) { return SL_RESULT_CONTROL_LOST; } else { return SL_RESULT_SUCCESS; } } //----------------------------------------------------------------------------- bool android_fx_initEffectObj(audio_session_t sessionId, android::sp& effect, const effect_uuid_t *type) { //SL_LOGV("android_fx_initEffectObj on session %d", sessionId); // TODO b/182392769: use attribution source util AttributionSourceState attributionSource; attributionSource.uid = VALUE_OR_FATAL(android::legacy2aidl_uid_t_int32_t(getuid())); attributionSource.pid = VALUE_OR_FATAL(android::legacy2aidl_pid_t_int32_t(getpid())); attributionSource.token = android::sp::make(); effect = android::sp::make(attributionSource); effect->set(type, EFFECT_UUID_NULL, 0,// priority nullptr,// effect callback sessionId,// session ID 0); // output android::status_t status = effect->initCheck(); if (android::NO_ERROR != status) { effect.clear(); SL_LOGE("Effect initCheck() returned %d", status); return false; } return true; } //----------------------------------------------------------------------------- bool android_fx_initEffectDescriptor(const SLInterfaceID effectId, effect_descriptor_t* fxDescrLoc) { uint32_t numEffects = 0; effect_descriptor_t descriptor; bool foundEffect = false; // any effects? android::status_t res = android::AudioEffect::queryNumberEffects(&numEffects); if (android::NO_ERROR != res) { SL_LOGE("unable to find any effects."); goto effectError; } // request effect in the effects? for (uint32_t i=0 ; i < numEffects ; i++) { res = android::AudioEffect::queryEffect(i, &descriptor); if ((android::NO_ERROR == res) && (0 == memcmp(effectId, &descriptor.type, sizeof(effect_uuid_t)))) { SL_LOGV("found effect %d %s", i, descriptor.name); foundEffect = true; break; } } if (foundEffect) { memcpy(fxDescrLoc, &descriptor, sizeof(effect_descriptor_t)); } else { SL_LOGE("unable to find an implementation for the requested effect."); goto effectError; } return true; effectError: // the requested effect wasn't found memset(fxDescrLoc, 0, sizeof(effect_descriptor_t)); return false; } //----------------------------------------------------------------------------- SLresult android_genericFx_queryNumEffects(SLuint32 *pNumSupportedAudioEffects) { if (NULL == pNumSupportedAudioEffects) { return SL_RESULT_PARAMETER_INVALID; } android::status_t status = android::AudioEffect::queryNumberEffects((uint32_t*)pNumSupportedAudioEffects); SLresult result = SL_RESULT_SUCCESS; switch (status) { case android::NO_ERROR: result = SL_RESULT_SUCCESS; break; case android::PERMISSION_DENIED: result = SL_RESULT_PERMISSION_DENIED; break; case android::NO_INIT: result = SL_RESULT_RESOURCE_ERROR; break; case android::BAD_VALUE: result = SL_RESULT_PARAMETER_INVALID; break; default: result = SL_RESULT_INTERNAL_ERROR; SL_LOGE("received invalid status %d from AudioEffect::queryNumberEffects()", status); break; } return result; } //----------------------------------------------------------------------------- SLresult android_genericFx_queryEffect(SLuint32 index, effect_descriptor_t* pDescriptor) { if (NULL == pDescriptor) { return SL_RESULT_PARAMETER_INVALID; } android::status_t status = android::AudioEffect::queryEffect(index, pDescriptor); SLresult result = SL_RESULT_SUCCESS; if (android::NO_ERROR != status) { switch (status) { case android::PERMISSION_DENIED: result = SL_RESULT_PERMISSION_DENIED; break; case android::NO_INIT: case android::INVALID_OPERATION: result = SL_RESULT_RESOURCE_ERROR; break; case android::BAD_VALUE: result = SL_RESULT_PARAMETER_INVALID; break; default: result = SL_RESULT_INTERNAL_ERROR; SL_LOGE("received invalid status %d from AudioEffect::queryNumberEffects()", status); break; } // an error occurred, reset the effect descriptor memset(pDescriptor, 0, sizeof(effect_descriptor_t)); } return result; } //----------------------------------------------------------------------------- SLresult android_genericFx_createEffect(IAndroidEffect* iae, SLInterfaceID pUuid, audio_session_t sessionId) { SLresult result = SL_RESULT_SUCCESS; // does this effect already exist? if (0 <= iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid))) { return result; } // create new effect // TODO b/182392769: use attribution source util AttributionSourceState attributionSource; attributionSource.uid = VALUE_OR_FATAL(android::legacy2aidl_uid_t_int32_t(getuid())); attributionSource.pid = VALUE_OR_FATAL(android::legacy2aidl_pid_t_int32_t(getpid())); attributionSource.token = android::sp::make(); const auto pFx = android::sp::make(attributionSource); pFx->set(NULL, // not using type to create effect (const effect_uuid_t*)pUuid, 0,// priority nullptr,// effect callback sessionId, 0 );// output // verify effect was successfully created before storing it android::status_t status = pFx->initCheck(); if (android::NO_ERROR != status) { SL_LOGE("AudioEffect initCheck() returned %d, effect will not be stored", status); result = SL_RESULT_RESOURCE_ERROR; } else { SL_LOGV("AudioEffect successfully created on session %d", sessionId); iae->mEffects->add(KEY_FROM_GUID(pUuid), pFx); } return result; } //----------------------------------------------------------------------------- SLresult android_genericFx_releaseEffect(IAndroidEffect* iae, SLInterfaceID pUuid) { ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); if (0 > index) { return SL_RESULT_PARAMETER_INVALID; } else { iae->mEffects->removeItem(index); return SL_RESULT_SUCCESS; } } //----------------------------------------------------------------------------- SLresult android_genericFx_setEnabled(IAndroidEffect* iae, SLInterfaceID pUuid, SLboolean enabled) { ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); if (0 > index) { return SL_RESULT_PARAMETER_INVALID; } else { android::sp pFx = iae->mEffects->valueAt(index); android::status_t status = pFx->setEnabled(SL_BOOLEAN_TRUE == enabled); return android_fx_statusToResult(status); } } //----------------------------------------------------------------------------- SLresult android_genericFx_isEnabled(IAndroidEffect* iae, SLInterfaceID pUuid, SLboolean *pEnabled) { ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); if (0 > index) { return SL_RESULT_PARAMETER_INVALID; } else { android::sp pFx = iae->mEffects->valueAt(index); *pEnabled = (SLboolean) pFx->getEnabled(); return SL_RESULT_SUCCESS; } } //----------------------------------------------------------------------------- SLresult android_genericFx_sendCommand(IAndroidEffect* iae, SLInterfaceID pUuid, SLuint32 command, SLuint32 commandSize, void* pCommandData, SLuint32 *replySize, void *pReplyData) { ssize_t index = iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid)); if (0 > index) { return SL_RESULT_PARAMETER_INVALID; } else { android::sp pFx = iae->mEffects->valueAt(index); android::status_t status = pFx->command( (uint32_t) command, (uint32_t) commandSize, pCommandData, (uint32_t*)replySize, pReplyData); if (android::BAD_VALUE == status) { return SL_RESULT_PARAMETER_INVALID; } else { return SL_RESULT_SUCCESS; } } } //----------------------------------------------------------------------------- /** * returns true if the given effect id is present in the AndroidEffect interface */ bool android_genericFx_hasEffect(IAndroidEffect* iae, SLInterfaceID pUuid) { return( 0 <= iae->mEffects->indexOfKey(KEY_FROM_GUID(pUuid))); } //----------------------------------------------------------------------------- static const int AEC_PARAM_SIZE_MAX = sizeof(effect_param_t) + (2 * sizeof(int32_t)); /** * returns the size in bytes of the value of each acoustic echo cancellation parameter */ uint32_t aec_valueSize(int32_t param) { uint32_t size; switch (param) { case AEC_PARAM_ECHO_DELAY: size = sizeof(int32_t); break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown Acoustic Echo Cancellation parameter %d", param); break; } return size; } android::status_t android_aec_setParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_setParam(pFx, param, AEC_PARAM_SIZE_MAX, pValue, aec_valueSize(param)); } android::status_t android_aec_getParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_getParam(pFx, param, AEC_PARAM_SIZE_MAX, pValue, aec_valueSize(param)); } //----------------------------------------------------------------------------- static const int AGC_PARAM_SIZE_MAX = sizeof(effect_param_t) + (2 * sizeof(int16_t)) + sizeof(bool); /** * returns the size in bytes of the value of each automatic gain control parameter */ uint32_t agc_valueSize(int32_t param) { uint32_t size; switch (param) { case AGC_PARAM_TARGET_LEVEL: case AGC_PARAM_COMP_GAIN: size = sizeof(int16_t); break; case AGC_PARAM_LIMITER_ENA: size = sizeof(bool); break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown Automatic Gain Control parameter %d", param); break; } return size; } android::status_t android_agc_setParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_setParam(pFx, param, AGC_PARAM_SIZE_MAX, pValue, agc_valueSize(param)); } android::status_t android_agc_getParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_getParam(pFx, param, AGC_PARAM_SIZE_MAX, pValue, agc_valueSize(param)); } //----------------------------------------------------------------------------- static const int NS_PARAM_SIZE_MAX = sizeof(effect_param_t) + 2 * sizeof(int32_t); /** * returns the size in bytes of the value of each noise suppression parameter */ uint32_t ns_valueSize(int32_t param) { uint32_t size; switch (param) { case NS_PARAM_LEVEL: size = sizeof(int32_t); break; default: size = sizeof(int32_t); SL_LOGE("Trying to access an unknown Noise suppression parameter %d", param); break; } return size; } android::status_t android_ns_setParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_setParam(pFx, param, NS_PARAM_SIZE_MAX, pValue, ns_valueSize(param)); } android::status_t android_ns_getParam(const android::sp& pFx, int32_t param, void *pValue) { return android_fx_getParam(pFx, param, NS_PARAM_SIZE_MAX, pValue, ns_valueSize(param)); }