1 /* 2 * Copyright (C) 2010 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 /* Virtualizer implementation */ 18 19 #include "sles_allinclusive.h" 20 #ifdef ANDROID 21 #include <audio_effects/effect_virtualizer.h> 22 #endif 23 24 #define VIRTUALIZER_STRENGTH_MIN 0 25 #define VIRTUALIZER_STRENGTH_MAX 1000 26 27 28 #if defined(ANDROID) 29 /** 30 * returns true if this interface is not associated with an initialized Virtualizer effect 31 */ 32 static inline bool NO_VIRTUALIZER(IVirtualizer* v) { 33 return (v->mVirtualizerEffect == 0); 34 } 35 #endif 36 37 38 static SLresult IVirtualizer_SetEnabled(SLVirtualizerItf self, SLboolean enabled) 39 { 40 SL_ENTER_INTERFACE 41 42 IVirtualizer *thiz = (IVirtualizer *) self; 43 interface_lock_exclusive(thiz); 44 thiz->mEnabled = (SLboolean) enabled; 45 #if !defined(ANDROID) 46 result = SL_RESULT_SUCCESS; 47 #else 48 if (NO_VIRTUALIZER(thiz)) { 49 result = SL_RESULT_CONTROL_LOST; 50 } else { 51 android::status_t status = 52 thiz->mVirtualizerEffect->setEnabled((bool) thiz->mEnabled); 53 result = android_fx_statusToResult(status); 54 } 55 #endif 56 interface_unlock_exclusive(thiz); 57 58 SL_LEAVE_INTERFACE 59 60 } 61 62 63 static SLresult IVirtualizer_IsEnabled(SLVirtualizerItf self, SLboolean *pEnabled) 64 { 65 SL_ENTER_INTERFACE 66 67 if (NULL == pEnabled) { 68 result = SL_RESULT_PARAMETER_INVALID; 69 } else { 70 IVirtualizer *thiz = (IVirtualizer *) self; 71 interface_lock_exclusive(thiz); 72 SLboolean enabled = thiz->mEnabled; 73 #if !defined(ANDROID) 74 *pEnabled = enabled; 75 result = SL_RESULT_SUCCESS; 76 #else 77 if (NO_VIRTUALIZER(thiz)) { 78 result = SL_RESULT_CONTROL_LOST; 79 } else { 80 *pEnabled = (SLboolean) thiz->mVirtualizerEffect->getEnabled(); 81 result = SL_RESULT_SUCCESS; 82 } 83 #endif 84 interface_unlock_exclusive(thiz); 85 } 86 87 SL_LEAVE_INTERFACE 88 } 89 90 91 static SLresult IVirtualizer_SetStrength(SLVirtualizerItf self, SLpermille strength) 92 { 93 SL_ENTER_INTERFACE 94 95 if ((VIRTUALIZER_STRENGTH_MIN > strength) || (VIRTUALIZER_STRENGTH_MAX < strength)) { 96 result = SL_RESULT_PARAMETER_INVALID; 97 } else { 98 IVirtualizer *thiz = (IVirtualizer *) self; 99 interface_lock_exclusive(thiz); 100 #if !defined(ANDROID) 101 thiz->mStrength = strength; 102 result = SL_RESULT_SUCCESS; 103 #else 104 if (NO_VIRTUALIZER(thiz)) { 105 result = SL_RESULT_CONTROL_LOST; 106 } else { 107 android::status_t status = android_virt_setParam(thiz->mVirtualizerEffect, 108 VIRTUALIZER_PARAM_STRENGTH, &strength); 109 result = android_fx_statusToResult(status); 110 } 111 #endif 112 interface_unlock_exclusive(thiz); 113 } 114 115 SL_LEAVE_INTERFACE 116 } 117 118 119 static SLresult IVirtualizer_GetRoundedStrength(SLVirtualizerItf self, SLpermille *pStrength) 120 { 121 SL_ENTER_INTERFACE 122 123 if (NULL == pStrength) { 124 result = SL_RESULT_PARAMETER_INVALID; 125 } else { 126 IVirtualizer *thiz = (IVirtualizer *) self; 127 interface_lock_exclusive(thiz); 128 SLpermille strength = thiz->mStrength;; 129 #if !defined(ANDROID) 130 result = SL_RESULT_SUCCESS; 131 #else 132 if (NO_VIRTUALIZER(thiz)) { 133 result = SL_RESULT_CONTROL_LOST; 134 } else { 135 android::status_t status = android_virt_getParam(thiz->mVirtualizerEffect, 136 VIRTUALIZER_PARAM_STRENGTH, &strength); 137 result = android_fx_statusToResult(status); 138 } 139 #endif 140 interface_unlock_exclusive(thiz); 141 *pStrength = strength; 142 } 143 144 SL_LEAVE_INTERFACE 145 } 146 147 148 static SLresult IVirtualizer_IsStrengthSupported(SLVirtualizerItf self, SLboolean *pSupported) 149 { 150 SL_ENTER_INTERFACE 151 152 if (NULL == pSupported) { 153 result = SL_RESULT_PARAMETER_INVALID; 154 } else { 155 #if !defined(ANDROID) 156 *pSupported = SL_BOOLEAN_TRUE; 157 result = SL_RESULT_SUCCESS; 158 #else 159 IVirtualizer *thiz = (IVirtualizer *) self; 160 int32_t supported = 0; 161 interface_lock_exclusive(thiz); 162 if (NO_VIRTUALIZER(thiz)) { 163 result = SL_RESULT_CONTROL_LOST; 164 } else { 165 android::status_t status = 166 android_virt_getParam(thiz->mVirtualizerEffect, 167 VIRTUALIZER_PARAM_STRENGTH_SUPPORTED, &supported); 168 result = android_fx_statusToResult(status); 169 } 170 interface_unlock_exclusive(thiz); 171 *pSupported = (SLboolean) (supported != 0); 172 #endif 173 } 174 175 SL_LEAVE_INTERFACE 176 } 177 178 179 static const struct SLVirtualizerItf_ IVirtualizer_Itf = { 180 IVirtualizer_SetEnabled, 181 IVirtualizer_IsEnabled, 182 IVirtualizer_SetStrength, 183 IVirtualizer_GetRoundedStrength, 184 IVirtualizer_IsStrengthSupported 185 }; 186 187 void IVirtualizer_init(void *self) 188 { 189 IVirtualizer *thiz = (IVirtualizer *) self; 190 thiz->mItf = &IVirtualizer_Itf; 191 thiz->mEnabled = SL_BOOLEAN_FALSE; 192 thiz->mStrength = 0; 193 #if defined(ANDROID) 194 memset(&thiz->mVirtualizerDescriptor, 0, sizeof(effect_descriptor_t)); 195 // placement new (explicit constructor) 196 (void) new (&thiz->mVirtualizerEffect) android::sp<android::AudioEffect>(); 197 #endif 198 } 199 200 void IVirtualizer_deinit(void *self) 201 { 202 #if defined(ANDROID) 203 IVirtualizer *thiz = (IVirtualizer *) self; 204 // explicit destructor 205 thiz->mVirtualizerEffect.~sp(); 206 #endif 207 } 208 209 bool IVirtualizer_Expose(void *self) 210 { 211 #if defined(ANDROID) 212 IVirtualizer *thiz = (IVirtualizer *) self; 213 if (!android_fx_initEffectDescriptor(SL_IID_VIRTUALIZER, &thiz->mVirtualizerDescriptor)) { 214 SL_LOGE("Virtualizer initialization failed."); 215 return false; 216 } 217 #endif 218 return true; 219 } 220
