| /* |
| * 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. |
| */ |
| |
| /* EffectSend implementation */ |
| |
| #include "sles_allinclusive.h" |
| |
| |
| /** \brief Maps AUX index to OutputMix interface index */ |
| |
| static const unsigned char AUX_to_MPH[AUX_MAX] = { |
| MPH_ENVIRONMENTALREVERB, |
| MPH_PRESETREVERB |
| }; |
| |
| |
| /** \brief This is a private function that validates the effect interface specified by the |
| * application when it calls EnableEffectSend, IsEnabled, SetSendLevel, or GetSendLevel. |
| * For the interface to be valid, it has to satisfy these requirements: |
| * - object is an audio player (MIDI player is not supported yet) |
| * - audio sink is an output mix |
| * - interface was exposed at object creation time or by DynamicInterface::AddInterface |
| * - interface was "gotten" with Object::GetInterface |
| */ |
| |
| static struct EnableLevel *getEnableLevel(IEffectSend *thiz, const void *pAuxEffect) |
| { |
| // Make sure this effect send is on an audio player, not a MIDI player |
| CAudioPlayer *audioPlayer = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ? |
| (CAudioPlayer *) thiz->mThis : NULL; |
| if (NULL == audioPlayer) { |
| return NULL; |
| } |
| // Get the output mix for this player |
| COutputMix *outputMix = CAudioPlayer_GetOutputMix(audioPlayer); |
| unsigned aux; |
| if (pAuxEffect == &outputMix->mEnvironmentalReverb.mItf) { |
| aux = AUX_ENVIRONMENTALREVERB; |
| } else if (pAuxEffect == &outputMix->mPresetReverb.mItf) { |
| aux = AUX_PRESETREVERB; |
| } else { |
| SL_LOGE("EffectSend on unknown aux effect %p", pAuxEffect); |
| return NULL; |
| } |
| assert(aux < AUX_MAX); |
| // Validate that the application has a valid interface for the effect. The interface must have |
| // been exposed at object creation time or by DynamicInterface::AddInterface, and it also must |
| // have been "gotten" with Object::GetInterface. |
| unsigned MPH = AUX_to_MPH[aux]; |
| int index = MPH_to_OutputMix[MPH]; |
| if (0 > index) { |
| SL_LOGE("EffectSend aux=%u MPH=%u", aux, MPH); |
| return NULL; |
| } |
| unsigned mask = 1 << index; |
| object_lock_shared(&outputMix->mObject); |
| SLuint32 state = outputMix->mObject.mInterfaceStates[index]; |
| mask &= outputMix->mObject.mGottenMask; |
| object_unlock_shared(&outputMix->mObject); |
| switch (state) { |
| case INTERFACE_EXPOSED: |
| case INTERFACE_ADDED: |
| case INTERFACE_SUSPENDED: |
| case INTERFACE_SUSPENDING: |
| case INTERFACE_RESUMING_1: |
| case INTERFACE_RESUMING_2: |
| if (mask) { |
| return &thiz->mEnableLevels[aux]; |
| } |
| SL_LOGE("EffectSend no GetInterface yet"); |
| break; |
| default: |
| SL_LOGE("EffectSend invalid interface state %u", state); |
| break; |
| } |
| return NULL; |
| } |
| |
| #if defined(ANDROID) |
| /** \brief This is a private function that translates an Android effect framework status code |
| * to the SL ES result code used in the EnableEffectSend() function of the SLEffectSendItf |
| * interface. |
| */ |
| static SLresult translateEnableFxSendError(android::status_t status) { |
| switch (status) { |
| case android::NO_ERROR: |
| return SL_RESULT_SUCCESS; |
| case android::INVALID_OPERATION: |
| case android::BAD_VALUE: |
| default: |
| SL_LOGE("EffectSend status %u", status); |
| return SL_RESULT_RESOURCE_ERROR; |
| } |
| } |
| #endif |
| |
| |
| static SLresult IEffectSend_EnableEffectSend(SLEffectSendItf self, |
| const void *pAuxEffect, SLboolean enable, SLmillibel initialLevel) |
| { |
| SL_ENTER_INTERFACE |
| |
| //if (!((SL_MILLIBEL_MIN <= initialLevel) && (initialLevel <= 0))) { |
| // comparison (SL_MILLIBEL_MIN <= initialLevel) is always true due to range of SLmillibel |
| if (!(initialLevel <= 0)) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IEffectSend *thiz = (IEffectSend *) self; |
| struct EnableLevel *enableLevel = getEnableLevel(thiz, pAuxEffect); |
| if (NULL == enableLevel) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| interface_lock_exclusive(thiz); |
| enableLevel->mEnable = SL_BOOLEAN_FALSE != enable; // normalize |
| enableLevel->mSendLevel = initialLevel; |
| #if !defined(ANDROID) |
| result = SL_RESULT_SUCCESS; |
| #else |
| // TODO do not repeat querying of CAudioPlayer, done inside getEnableLevel() |
| CAudioPlayer *ap = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ? |
| (CAudioPlayer *) thiz->mThis : NULL; |
| // note that if this was a MIDI player, getEnableLevel would have returned NULL |
| assert(NULL != ap); |
| // check which effect the send is attached to, attach and set level |
| COutputMix *outputMix = CAudioPlayer_GetOutputMix(ap); |
| // the initial send level set here is the total energy on the aux bus, |
| // so it must take into account the player volume level |
| if (pAuxEffect == &outputMix->mPresetReverb.mItf) { |
| result = translateEnableFxSendError(android_fxSend_attach(ap, (bool) enable, |
| outputMix->mPresetReverb.mPresetReverbEffect, |
| initialLevel + ap->mVolume.mLevel)); |
| } else if (pAuxEffect == &outputMix->mEnvironmentalReverb.mItf) { |
| result = translateEnableFxSendError(android_fxSend_attach(ap, (bool) enable, |
| outputMix->mEnvironmentalReverb.mEnvironmentalReverbEffect, |
| initialLevel + ap->mVolume.mLevel)); |
| } else { |
| SL_LOGE("EffectSend unknown aux effect %p", pAuxEffect); |
| result = SL_RESULT_PARAMETER_INVALID; |
| } |
| #endif |
| interface_unlock_exclusive(thiz); |
| } |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IEffectSend_IsEnabled(SLEffectSendItf self, |
| const void *pAuxEffect, SLboolean *pEnable) |
| { |
| SL_ENTER_INTERFACE |
| |
| if (NULL == pEnable) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IEffectSend *thiz = (IEffectSend *) self; |
| struct EnableLevel *enableLevel = getEnableLevel(thiz, pAuxEffect); |
| if (NULL == enableLevel) { |
| *pEnable = SL_BOOLEAN_FALSE; |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| interface_lock_shared(thiz); |
| SLboolean enable = enableLevel->mEnable; |
| interface_unlock_shared(thiz); |
| *pEnable = enable; |
| result = SL_RESULT_SUCCESS; |
| } |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IEffectSend_SetDirectLevel(SLEffectSendItf self, SLmillibel directLevel) |
| { |
| SL_ENTER_INTERFACE |
| |
| //if (!((SL_MILLIBEL_MIN <= directLevel) && (directLevel <= 0))) { |
| // comparison (SL_MILLIBEL_MIN <= directLevel) is always true due to range of SLmillibel |
| if (!(directLevel <= 0)) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IEffectSend *thiz = (IEffectSend *) self; |
| interface_lock_exclusive(thiz); |
| CAudioPlayer *ap = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ? |
| (CAudioPlayer *) thiz->mThis : NULL; |
| if (NULL != ap) { |
| SLmillibel oldDirectLevel = ap->mDirectLevel; |
| if (oldDirectLevel != directLevel) { |
| ap->mDirectLevel = directLevel; |
| #if defined(ANDROID) |
| ap->mAmplFromDirectLevel = sles_to_android_amplification(directLevel); |
| interface_unlock_exclusive_attributes(thiz, ATTR_GAIN); |
| #else |
| interface_unlock_exclusive(thiz); |
| #endif |
| } else { |
| interface_unlock_exclusive(thiz); |
| } |
| } else { |
| // MIDI player is silently not supported |
| interface_unlock_exclusive(thiz); |
| } |
| result = SL_RESULT_SUCCESS; |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IEffectSend_GetDirectLevel(SLEffectSendItf self, SLmillibel *pDirectLevel) |
| { |
| SL_ENTER_INTERFACE |
| |
| if (NULL == pDirectLevel) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IEffectSend *thiz = (IEffectSend *) self; |
| interface_lock_shared(thiz); |
| CAudioPlayer *ap = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ? |
| (CAudioPlayer *) thiz->mThis : NULL; |
| if (NULL != ap) { |
| *pDirectLevel = ap->mDirectLevel; |
| } else { |
| // MIDI player is silently not supported |
| *pDirectLevel = 0; |
| } |
| interface_unlock_shared(thiz); |
| result = SL_RESULT_SUCCESS; |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IEffectSend_SetSendLevel(SLEffectSendItf self, const void *pAuxEffect, |
| SLmillibel sendLevel) |
| { |
| SL_ENTER_INTERFACE |
| |
| //if (!((SL_MILLIBEL_MIN <= sendLevel) && (sendLevel <= 0))) { |
| // comparison (SL_MILLIBEL_MIN <= sendLevel) is always true due to range of SLmillibel |
| if (!(sendLevel <= 0)) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IEffectSend *thiz = (IEffectSend *) self; |
| struct EnableLevel *enableLevel = getEnableLevel(thiz, pAuxEffect); |
| if (NULL == enableLevel) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| result = SL_RESULT_SUCCESS; |
| // EnableEffectSend is exclusive, so this has to be also |
| interface_lock_exclusive(thiz); |
| enableLevel->mSendLevel = sendLevel; |
| #if defined(ANDROID) |
| CAudioPlayer *ap = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ? |
| (CAudioPlayer *) thiz->mThis : NULL; |
| if (NULL != ap) { |
| // the send level set here is the total energy on the aux bus, so it must take |
| // into account the player volume level |
| result = android_fxSend_setSendLevel(ap, sendLevel + ap->mVolume.mLevel); |
| } |
| #endif |
| interface_unlock_exclusive(thiz); |
| |
| } |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IEffectSend_GetSendLevel(SLEffectSendItf self, const void *pAuxEffect, |
| SLmillibel *pSendLevel) |
| { |
| SL_ENTER_INTERFACE |
| |
| if (NULL == pSendLevel) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IEffectSend *thiz = (IEffectSend *) self; |
| struct EnableLevel *enableLevel = getEnableLevel(thiz, pAuxEffect); |
| if (NULL == enableLevel) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| interface_lock_shared(thiz); |
| SLmillibel sendLevel = enableLevel->mSendLevel; |
| interface_unlock_shared(thiz); |
| *pSendLevel = sendLevel; |
| result = SL_RESULT_SUCCESS; |
| } |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static const struct SLEffectSendItf_ IEffectSend_Itf = { |
| IEffectSend_EnableEffectSend, |
| IEffectSend_IsEnabled, |
| IEffectSend_SetDirectLevel, |
| IEffectSend_GetDirectLevel, |
| IEffectSend_SetSendLevel, |
| IEffectSend_GetSendLevel |
| }; |
| |
| void IEffectSend_init(void *self) |
| { |
| IEffectSend *thiz = (IEffectSend *) self; |
| thiz->mItf = &IEffectSend_Itf; |
| struct EnableLevel *enableLevel = thiz->mEnableLevels; |
| unsigned aux; |
| for (aux = 0; aux < AUX_MAX; ++aux, ++enableLevel) { |
| enableLevel->mEnable = SL_BOOLEAN_FALSE; |
| enableLevel->mSendLevel = SL_MILLIBEL_MIN; |
| } |
| } |
