1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_AUDIOPOLICYEFFECTS_H 18 #define ANDROID_AUDIOPOLICYEFFECTS_H 19 20 #include <stdlib.h> 21 #include <stdio.h> 22 #include <string.h> 23 #include <cutils/misc.h> 24 #include <media/AudioEffect.h> 25 #include <system/audio.h> 26 #include <utils/Vector.h> 27 #include <utils/SortedVector.h> 28 29 namespace android { 30 31 // ---------------------------------------------------------------------------- 32 33 // AudioPolicyEffects class 34 // This class will manage all effects attached to input and output streams in 35 // AudioPolicyService as configured in audio_effects.conf. 36 class AudioPolicyEffects : public RefBase 37 { 38 39 public: 40 41 // The constructor will parse audio_effects.conf 42 // First it will look whether vendor specific file exists, 43 // otherwise it will parse the system default file. 44 AudioPolicyEffects(); 45 virtual ~AudioPolicyEffects(); 46 47 // NOTE: methods on AudioPolicyEffects should never be called with the AudioPolicyService 48 // main mutex (mLock) held as they will indirectly call back into AudioPolicyService when 49 // managing audio effects. 50 51 // Return a list of effect descriptors for default input effects 52 // associated with audioSession 53 status_t queryDefaultInputEffects(audio_session_t audioSession, 54 effect_descriptor_t *descriptors, 55 uint32_t *count); 56 57 // Add all input effects associated with this input 58 // Effects are attached depending on the audio_source_t 59 status_t addInputEffects(audio_io_handle_t input, 60 audio_source_t inputSource, 61 audio_session_t audioSession); 62 63 // Add all input effects associated to this input 64 status_t releaseInputEffects(audio_io_handle_t input, 65 audio_session_t audioSession); 66 67 68 // Return a list of effect descriptors for default output effects 69 // associated with audioSession 70 status_t queryDefaultOutputSessionEffects(audio_session_t audioSession, 71 effect_descriptor_t *descriptors, 72 uint32_t *count); 73 74 // Add all output effects associated to this output 75 // Effects are attached depending on the audio_stream_type_t 76 status_t addOutputSessionEffects(audio_io_handle_t output, 77 audio_stream_type_t stream, 78 audio_session_t audioSession); 79 80 // release all output effects associated with this output stream and audiosession 81 status_t releaseOutputSessionEffects(audio_io_handle_t output, 82 audio_stream_type_t stream, 83 audio_session_t audioSession); 84 85 private: 86 87 // class to store the description of an effects and its parameters 88 // as defined in audio_effects.conf 89 class EffectDesc { 90 public: EffectDesc(const char * name,const effect_uuid_t & uuid)91 EffectDesc(const char *name, const effect_uuid_t& uuid) : 92 mName(strdup(name)), 93 mUuid(uuid) { } EffectDesc(const EffectDesc & orig)94 EffectDesc(const EffectDesc& orig) : 95 mName(strdup(orig.mName)), 96 mUuid(orig.mUuid) { 97 // deep copy mParams 98 for (size_t k = 0; k < orig.mParams.size(); k++) { 99 effect_param_t *origParam = orig.mParams[k]; 100 // psize and vsize are rounded up to an int boundary for allocation 101 size_t origSize = sizeof(effect_param_t) + 102 ((origParam->psize + 3) & ~3) + 103 ((origParam->vsize + 3) & ~3); 104 effect_param_t *dupParam = (effect_param_t *) malloc(origSize); 105 memcpy(dupParam, origParam, origSize); 106 // This works because the param buffer allocation is also done by 107 // multiples of 4 bytes originally. In theory we should memcpy only 108 // the actual param size, that is without rounding vsize. 109 mParams.add(dupParam); 110 } 111 } ~EffectDesc()112 /*virtual*/ ~EffectDesc() { 113 free(mName); 114 for (size_t k = 0; k < mParams.size(); k++) { 115 free(mParams[k]); 116 } 117 } 118 char *mName; 119 effect_uuid_t mUuid; 120 Vector <effect_param_t *> mParams; 121 }; 122 123 // class to store voctor of EffectDesc 124 class EffectDescVector { 125 public: EffectDescVector()126 EffectDescVector() {} ~EffectDescVector()127 /*virtual*/ ~EffectDescVector() { 128 for (size_t j = 0; j < mEffects.size(); j++) { 129 delete mEffects[j]; 130 } 131 } 132 Vector <EffectDesc *> mEffects; 133 }; 134 135 // class to store voctor of AudioEffects 136 class EffectVector { 137 public: EffectVector(audio_session_t session)138 explicit EffectVector(audio_session_t session) : mSessionId(session), mRefCount(0) {} ~EffectVector()139 /*virtual*/ ~EffectVector() {} 140 141 // Enable or disable all effects in effect vector 142 void setProcessorEnabled(bool enabled); 143 144 const audio_session_t mSessionId; 145 // AudioPolicyManager keeps mLock, no need for lock on reference count here 146 int mRefCount; 147 Vector< sp<AudioEffect> >mEffects; 148 }; 149 150 151 static const char * const kInputSourceNames[AUDIO_SOURCE_CNT -1]; 152 static audio_source_t inputSourceNameToEnum(const char *name); 153 154 static const char *kStreamNames[AUDIO_STREAM_PUBLIC_CNT+1]; //+1 required as streams start from -1 155 audio_stream_type_t streamNameToEnum(const char *name); 156 157 // Parse audio_effects.conf 158 status_t loadAudioEffectConfig(const char *path); // TODO: add legacy in the name 159 status_t loadAudioEffectXmlConfig(); // TODO: remove "Xml" in the name 160 161 // Load all effects descriptors in configuration file 162 status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects); 163 EffectDesc *loadEffect(cnode *root); 164 165 // Load all automatic effect configurations 166 status_t loadInputEffectConfigurations(cnode *root, const Vector <EffectDesc *>& effects); 167 status_t loadStreamEffectConfigurations(cnode *root, const Vector <EffectDesc *>& effects); 168 EffectDescVector *loadEffectConfig(cnode *root, const Vector <EffectDesc *>& effects); 169 170 // Load all automatic effect parameters 171 void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params); 172 effect_param_t *loadEffectParameter(cnode *root); 173 size_t readParamValue(cnode *node, 174 char **param, 175 size_t *curSize, 176 size_t *totSize); 177 size_t growParamSize(char **param, 178 size_t size, 179 size_t *curSize, 180 size_t *totSize); 181 182 // protects access to mInputSources, mInputSessions, mOutputStreams, mOutputSessions 183 Mutex mLock; 184 // Automatic input effects are configured per audio_source_t 185 KeyedVector< audio_source_t, EffectDescVector* > mInputSources; 186 // Automatic input effects are unique for audio_io_handle_t 187 KeyedVector< audio_session_t, EffectVector* > mInputSessions; 188 189 // Automatic output effects are organized per audio_stream_type_t 190 KeyedVector< audio_stream_type_t, EffectDescVector* > mOutputStreams; 191 // Automatic output effects are unique for audiosession ID 192 KeyedVector< audio_session_t, EffectVector* > mOutputSessions; 193 }; 194 195 }; // namespace android 196 197 #endif // ANDROID_AUDIOPOLICYEFFECTS_H 198