Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 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 | #define LOG_TAG "EffectReverb" |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 18 | //#define LOG_NDEBUG 0 |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 19 | #include <cutils/log.h> |
Eric Laurent | be916aa | 2010-06-01 23:49:17 -0700 | [diff] [blame] | 20 | #include <stdlib.h> |
| 21 | #include <string.h> |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 22 | #include <stdbool.h> |
| 23 | #include "EffectReverb.h" |
| 24 | #include "EffectsMath.h" |
| 25 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 26 | // effect_handle_t interface implementation for reverb effect |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 27 | const struct effect_interface_s gReverbInterface = { |
| 28 | Reverb_Process, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 29 | Reverb_Command, |
Eric Laurent | ba7b8f8 | 2011-06-17 18:54:16 -0700 | [diff] [blame] | 30 | Reverb_GetDescriptor, |
| 31 | NULL |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 32 | }; |
| 33 | |
| 34 | // Google auxiliary environmental reverb UUID: 1f0ae2e0-4ef7-11df-bc09-0002a5d5c51b |
| 35 | static const effect_descriptor_t gAuxEnvReverbDescriptor = { |
| 36 | {0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}}, |
| 37 | {0x1f0ae2e0, 0x4ef7, 0x11df, 0xbc09, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 38 | EFFECT_CONTROL_API_VERSION, |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 39 | // flags other than EFFECT_FLAG_TYPE_AUXILIARY set for test purpose |
| 40 | EFFECT_FLAG_TYPE_AUXILIARY | EFFECT_FLAG_DEVICE_IND | EFFECT_FLAG_AUDIO_MODE_IND, |
| 41 | 0, // TODO |
| 42 | 33, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 43 | "Aux Environmental Reverb", |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 44 | "The Android Open Source Project" |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 45 | }; |
| 46 | |
| 47 | // Google insert environmental reverb UUID: aa476040-6342-11df-91a4-0002a5d5c51b |
| 48 | static const effect_descriptor_t gInsertEnvReverbDescriptor = { |
| 49 | {0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}}, |
| 50 | {0xaa476040, 0x6342, 0x11df, 0x91a4, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 51 | EFFECT_CONTROL_API_VERSION, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 52 | EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST, |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 53 | 0, // TODO |
| 54 | 33, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 55 | "Insert Environmental reverb", |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 56 | "The Android Open Source Project" |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 57 | }; |
| 58 | |
| 59 | // Google auxiliary preset reverb UUID: 63909320-53a6-11df-bdbd-0002a5d5c51b |
| 60 | static const effect_descriptor_t gAuxPresetReverbDescriptor = { |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 61 | {0x47382d60, 0xddd8, 0x11db, 0xbf3a, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 62 | {0x63909320, 0x53a6, 0x11df, 0xbdbd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 63 | EFFECT_CONTROL_API_VERSION, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 64 | EFFECT_FLAG_TYPE_AUXILIARY, |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 65 | 0, // TODO |
| 66 | 33, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 67 | "Aux Preset Reverb", |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 68 | "The Android Open Source Project" |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 69 | }; |
| 70 | |
| 71 | // Google insert preset reverb UUID: d93dc6a0-6342-11df-b128-0002a5d5c51b |
| 72 | static const effect_descriptor_t gInsertPresetReverbDescriptor = { |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 73 | {0x47382d60, 0xddd8, 0x11db, 0xbf3a, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 74 | {0xd93dc6a0, 0x6342, 0x11df, 0xb128, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 75 | EFFECT_CONTROL_API_VERSION, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 76 | EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST, |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 77 | 0, // TODO |
| 78 | 33, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 79 | "Insert Preset Reverb", |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 80 | "The Android Open Source Project" |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 81 | }; |
| 82 | |
| 83 | // gDescriptors contains pointers to all defined effect descriptor in this library |
| 84 | static const effect_descriptor_t * const gDescriptors[] = { |
| 85 | &gAuxEnvReverbDescriptor, |
| 86 | &gInsertEnvReverbDescriptor, |
| 87 | &gAuxPresetReverbDescriptor, |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 88 | &gInsertPresetReverbDescriptor |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 89 | }; |
| 90 | |
| 91 | /*---------------------------------------------------------------------------- |
| 92 | * Effect API implementation |
| 93 | *--------------------------------------------------------------------------*/ |
| 94 | |
| 95 | /*--- Effect Library Interface Implementation ---*/ |
| 96 | |
Glenn Kasten | 5e92a78 | 2012-01-30 07:40:52 -0800 | [diff] [blame] | 97 | int EffectCreate(const effect_uuid_t *uuid, |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 98 | int32_t sessionId, |
| 99 | int32_t ioId, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 100 | effect_handle_t *pHandle) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 101 | int ret; |
| 102 | int i; |
| 103 | reverb_module_t *module; |
| 104 | const effect_descriptor_t *desc; |
| 105 | int aux = 0; |
| 106 | int preset = 0; |
| 107 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 108 | ALOGV("EffectLibCreateEffect start"); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 109 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 110 | if (pHandle == NULL || uuid == NULL) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 111 | return -EINVAL; |
| 112 | } |
| 113 | |
| 114 | for (i = 0; gDescriptors[i] != NULL; i++) { |
| 115 | desc = gDescriptors[i]; |
| 116 | if (memcmp(uuid, &desc->uuid, sizeof(effect_uuid_t)) |
| 117 | == 0) { |
| 118 | break; |
| 119 | } |
| 120 | } |
| 121 | |
| 122 | if (gDescriptors[i] == NULL) { |
| 123 | return -ENOENT; |
| 124 | } |
| 125 | |
| 126 | module = malloc(sizeof(reverb_module_t)); |
| 127 | |
| 128 | module->itfe = &gReverbInterface; |
| 129 | |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 130 | module->context.mState = REVERB_STATE_UNINITIALIZED; |
| 131 | |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 132 | if (memcmp(&desc->type, SL_IID_PRESETREVERB, sizeof(effect_uuid_t)) == 0) { |
| 133 | preset = 1; |
| 134 | } |
| 135 | if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { |
| 136 | aux = 1; |
| 137 | } |
| 138 | ret = Reverb_Init(module, aux, preset); |
| 139 | if (ret < 0) { |
Steve Block | 5ff1dd5 | 2012-01-05 23:22:43 +0000 | [diff] [blame] | 140 | ALOGW("EffectLibCreateEffect() init failed"); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 141 | free(module); |
| 142 | return ret; |
| 143 | } |
| 144 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 145 | *pHandle = (effect_handle_t) module; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 146 | |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 147 | module->context.mState = REVERB_STATE_INITIALIZED; |
| 148 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 149 | ALOGV("EffectLibCreateEffect %p ,size %d", module, sizeof(reverb_module_t)); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 150 | |
| 151 | return 0; |
| 152 | } |
| 153 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 154 | int EffectRelease(effect_handle_t handle) { |
| 155 | reverb_module_t *pRvbModule = (reverb_module_t *)handle; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 156 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 157 | ALOGV("EffectLibReleaseEffect %p", handle); |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 158 | if (handle == NULL) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 159 | return -EINVAL; |
| 160 | } |
| 161 | |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 162 | pRvbModule->context.mState = REVERB_STATE_UNINITIALIZED; |
| 163 | |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 164 | free(pRvbModule); |
| 165 | return 0; |
| 166 | } |
| 167 | |
Glenn Kasten | 5e92a78 | 2012-01-30 07:40:52 -0800 | [diff] [blame] | 168 | int EffectGetDescriptor(const effect_uuid_t *uuid, |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 169 | effect_descriptor_t *pDescriptor) { |
| 170 | int i; |
| 171 | int length = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *); |
| 172 | |
| 173 | if (pDescriptor == NULL || uuid == NULL){ |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 174 | ALOGV("EffectGetDescriptor() called with NULL pointer"); |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 175 | return -EINVAL; |
| 176 | } |
| 177 | |
| 178 | for (i = 0; i < length; i++) { |
| 179 | if (memcmp(uuid, &gDescriptors[i]->uuid, sizeof(effect_uuid_t)) == 0) { |
Glenn Kasten | a189a68 | 2012-02-20 12:16:30 -0800 | [diff] [blame] | 180 | *pDescriptor = *gDescriptors[i]; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 181 | ALOGV("EffectGetDescriptor - UUID matched Reverb type %d, UUID = %x", |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 182 | i, gDescriptors[i]->uuid.timeLow); |
| 183 | return 0; |
| 184 | } |
| 185 | } |
| 186 | |
| 187 | return -EINVAL; |
| 188 | } /* end EffectGetDescriptor */ |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 189 | |
| 190 | /*--- Effect Control Interface Implementation ---*/ |
| 191 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 192 | static int Reverb_Process(effect_handle_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 193 | reverb_object_t *pReverb; |
| 194 | int16_t *pSrc, *pDst; |
| 195 | reverb_module_t *pRvbModule = (reverb_module_t *)self; |
| 196 | |
| 197 | if (pRvbModule == NULL) { |
| 198 | return -EINVAL; |
| 199 | } |
| 200 | |
| 201 | if (inBuffer == NULL || inBuffer->raw == NULL || |
| 202 | outBuffer == NULL || outBuffer->raw == NULL || |
| 203 | inBuffer->frameCount != outBuffer->frameCount) { |
| 204 | return -EINVAL; |
| 205 | } |
| 206 | |
| 207 | pReverb = (reverb_object_t*) &pRvbModule->context; |
| 208 | |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 209 | if (pReverb->mState == REVERB_STATE_UNINITIALIZED) { |
| 210 | return -EINVAL; |
| 211 | } |
| 212 | if (pReverb->mState == REVERB_STATE_INITIALIZED) { |
| 213 | return -ENODATA; |
| 214 | } |
| 215 | |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 216 | //if bypassed or the preset forces the signal to be completely dry |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 217 | if (pReverb->m_bBypass != 0) { |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 218 | if (inBuffer->raw != outBuffer->raw) { |
| 219 | int16_t smp; |
| 220 | pSrc = inBuffer->s16; |
| 221 | pDst = outBuffer->s16; |
| 222 | size_t count = inBuffer->frameCount; |
| 223 | if (pRvbModule->config.inputCfg.channels == pRvbModule->config.outputCfg.channels) { |
| 224 | count *= 2; |
| 225 | while (count--) { |
| 226 | *pDst++ = *pSrc++; |
| 227 | } |
| 228 | } else { |
| 229 | while (count--) { |
| 230 | smp = *pSrc++; |
| 231 | *pDst++ = smp; |
| 232 | *pDst++ = smp; |
| 233 | } |
| 234 | } |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 235 | } |
| 236 | return 0; |
| 237 | } |
| 238 | |
| 239 | if (pReverb->m_nNextRoom != pReverb->m_nCurrentRoom) { |
| 240 | ReverbUpdateRoom(pReverb, true); |
| 241 | } |
| 242 | |
| 243 | pSrc = inBuffer->s16; |
| 244 | pDst = outBuffer->s16; |
| 245 | size_t numSamples = outBuffer->frameCount; |
| 246 | while (numSamples) { |
| 247 | uint32_t processedSamples; |
| 248 | if (numSamples > (uint32_t) pReverb->m_nUpdatePeriodInSamples) { |
| 249 | processedSamples = (uint32_t) pReverb->m_nUpdatePeriodInSamples; |
| 250 | } else { |
| 251 | processedSamples = numSamples; |
| 252 | } |
| 253 | |
| 254 | /* increment update counter */ |
| 255 | pReverb->m_nUpdateCounter += (int16_t) processedSamples; |
| 256 | /* check if update counter needs to be reset */ |
| 257 | if (pReverb->m_nUpdateCounter >= pReverb->m_nUpdatePeriodInSamples) { |
| 258 | /* update interval has elapsed, so reset counter */ |
| 259 | pReverb->m_nUpdateCounter -= pReverb->m_nUpdatePeriodInSamples; |
| 260 | ReverbUpdateXfade(pReverb, pReverb->m_nUpdatePeriodInSamples); |
| 261 | |
| 262 | } /* end if m_nUpdateCounter >= update interval */ |
| 263 | |
| 264 | Reverb(pReverb, processedSamples, pDst, pSrc); |
| 265 | |
| 266 | numSamples -= processedSamples; |
| 267 | if (pReverb->m_Aux) { |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 268 | pSrc += processedSamples; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 269 | } else { |
| 270 | pSrc += processedSamples * NUM_OUTPUT_CHANNELS; |
| 271 | } |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 272 | pDst += processedSamples * NUM_OUTPUT_CHANNELS; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | return 0; |
| 276 | } |
| 277 | |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 278 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 279 | static int Reverb_Command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize, |
Eric Laurent | 25f4395 | 2010-07-28 05:40:18 -0700 | [diff] [blame] | 280 | void *pCmdData, uint32_t *replySize, void *pReplyData) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 281 | reverb_module_t *pRvbModule = (reverb_module_t *) self; |
| 282 | reverb_object_t *pReverb; |
| 283 | int retsize; |
| 284 | |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 285 | if (pRvbModule == NULL || |
| 286 | pRvbModule->context.mState == REVERB_STATE_UNINITIALIZED) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 287 | return -EINVAL; |
| 288 | } |
| 289 | |
| 290 | pReverb = (reverb_object_t*) &pRvbModule->context; |
| 291 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 292 | ALOGV("Reverb_Command command %d cmdSize %d",cmdCode, cmdSize); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 293 | |
| 294 | switch (cmdCode) { |
| 295 | case EFFECT_CMD_INIT: |
| 296 | if (pReplyData == NULL || *replySize != sizeof(int)) { |
| 297 | return -EINVAL; |
| 298 | } |
| 299 | *(int *) pReplyData = Reverb_Init(pRvbModule, pReverb->m_Aux, pReverb->m_Preset); |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 300 | if (*(int *) pReplyData == 0) { |
| 301 | pRvbModule->context.mState = REVERB_STATE_INITIALIZED; |
| 302 | } |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 303 | break; |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 304 | case EFFECT_CMD_SET_CONFIG: |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 305 | if (pCmdData == NULL || cmdSize != sizeof(effect_config_t) |
| 306 | || pReplyData == NULL || *replySize != sizeof(int)) { |
| 307 | return -EINVAL; |
| 308 | } |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 309 | *(int *) pReplyData = Reverb_setConfig(pRvbModule, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 310 | (effect_config_t *)pCmdData, false); |
| 311 | break; |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 312 | case EFFECT_CMD_GET_CONFIG: |
| 313 | if (pReplyData == NULL || *replySize != sizeof(effect_config_t)) { |
| 314 | return -EINVAL; |
| 315 | } |
| 316 | Reverb_getConfig(pRvbModule, (effect_config_t *) pCmdData); |
| 317 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 318 | case EFFECT_CMD_RESET: |
| 319 | Reverb_Reset(pReverb, false); |
| 320 | break; |
| 321 | case EFFECT_CMD_GET_PARAM: |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 322 | ALOGV("Reverb_Command EFFECT_CMD_GET_PARAM pCmdData %p, *replySize %d, pReplyData: %p",pCmdData, *replySize, pReplyData); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 323 | |
| 324 | if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) || |
| 325 | pReplyData == NULL || *replySize < (int) sizeof(effect_param_t)) { |
| 326 | return -EINVAL; |
| 327 | } |
| 328 | effect_param_t *rep = (effect_param_t *) pReplyData; |
| 329 | memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(int32_t)); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 330 | ALOGV("Reverb_Command EFFECT_CMD_GET_PARAM param %d, replySize %d",*(int32_t *)rep->data, rep->vsize); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 331 | rep->status = Reverb_getParameter(pReverb, *(int32_t *)rep->data, &rep->vsize, |
| 332 | rep->data + sizeof(int32_t)); |
| 333 | *replySize = sizeof(effect_param_t) + sizeof(int32_t) + rep->vsize; |
| 334 | break; |
| 335 | case EFFECT_CMD_SET_PARAM: |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 336 | ALOGV("Reverb_Command EFFECT_CMD_SET_PARAM cmdSize %d pCmdData %p, *replySize %d, pReplyData %p", |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 337 | cmdSize, pCmdData, *replySize, pReplyData); |
| 338 | if (pCmdData == NULL || (cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t))) |
| 339 | || pReplyData == NULL || *replySize != (int)sizeof(int32_t)) { |
| 340 | return -EINVAL; |
| 341 | } |
| 342 | effect_param_t *cmd = (effect_param_t *) pCmdData; |
| 343 | *(int *)pReplyData = Reverb_setParameter(pReverb, *(int32_t *)cmd->data, |
| 344 | cmd->vsize, cmd->data + sizeof(int32_t)); |
| 345 | break; |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 346 | case EFFECT_CMD_ENABLE: |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 347 | if (pReplyData == NULL || *replySize != sizeof(int)) { |
| 348 | return -EINVAL; |
| 349 | } |
| 350 | if (pReverb->mState != REVERB_STATE_INITIALIZED) { |
| 351 | return -ENOSYS; |
| 352 | } |
| 353 | pReverb->mState = REVERB_STATE_ACTIVE; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 354 | ALOGV("EFFECT_CMD_ENABLE() OK"); |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 355 | *(int *)pReplyData = 0; |
| 356 | break; |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 357 | case EFFECT_CMD_DISABLE: |
| 358 | if (pReplyData == NULL || *replySize != sizeof(int)) { |
| 359 | return -EINVAL; |
| 360 | } |
Eric Laurent | e44b1ef | 2010-07-09 13:34:17 -0700 | [diff] [blame] | 361 | if (pReverb->mState != REVERB_STATE_ACTIVE) { |
| 362 | return -ENOSYS; |
| 363 | } |
| 364 | pReverb->mState = REVERB_STATE_INITIALIZED; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 365 | ALOGV("EFFECT_CMD_DISABLE() OK"); |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 366 | *(int *)pReplyData = 0; |
| 367 | break; |
| 368 | case EFFECT_CMD_SET_DEVICE: |
| 369 | if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) { |
| 370 | return -EINVAL; |
| 371 | } |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 372 | ALOGV("Reverb_Command EFFECT_CMD_SET_DEVICE: 0x%08x", *(uint32_t *)pCmdData); |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 373 | break; |
| 374 | case EFFECT_CMD_SET_VOLUME: { |
| 375 | // audio output is always stereo => 2 channel volumes |
| 376 | if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t) * 2) { |
| 377 | return -EINVAL; |
| 378 | } |
| 379 | float left = (float)(*(uint32_t *)pCmdData) / (1 << 24); |
| 380 | float right = (float)(*((uint32_t *)pCmdData + 1)) / (1 << 24); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 381 | ALOGV("Reverb_Command EFFECT_CMD_SET_VOLUME: left %f, right %f ", left, right); |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 382 | break; |
| 383 | } |
| 384 | case EFFECT_CMD_SET_AUDIO_MODE: |
| 385 | if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) { |
| 386 | return -EINVAL; |
| 387 | } |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 388 | ALOGV("Reverb_Command EFFECT_CMD_SET_AUDIO_MODE: %d", *(uint32_t *)pCmdData); |
Eric Laurent | ffe9c25 | 2010-06-23 17:38:20 -0700 | [diff] [blame] | 389 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 390 | default: |
Steve Block | 5ff1dd5 | 2012-01-05 23:22:43 +0000 | [diff] [blame] | 391 | ALOGW("Reverb_Command invalid command %d",cmdCode); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 392 | return -EINVAL; |
| 393 | } |
| 394 | |
| 395 | return 0; |
| 396 | } |
| 397 | |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 398 | int Reverb_GetDescriptor(effect_handle_t self, |
| 399 | effect_descriptor_t *pDescriptor) |
| 400 | { |
| 401 | reverb_module_t *pRvbModule = (reverb_module_t *) self; |
| 402 | reverb_object_t *pReverb; |
| 403 | const effect_descriptor_t *desc; |
| 404 | |
| 405 | if (pRvbModule == NULL || |
| 406 | pRvbModule->context.mState == REVERB_STATE_UNINITIALIZED) { |
| 407 | return -EINVAL; |
| 408 | } |
| 409 | |
| 410 | pReverb = (reverb_object_t*) &pRvbModule->context; |
| 411 | |
| 412 | if (pReverb->m_Aux) { |
| 413 | if (pReverb->m_Preset) { |
| 414 | desc = &gAuxPresetReverbDescriptor; |
| 415 | } else { |
| 416 | desc = &gAuxEnvReverbDescriptor; |
| 417 | } |
| 418 | } else { |
| 419 | if (pReverb->m_Preset) { |
| 420 | desc = &gInsertPresetReverbDescriptor; |
| 421 | } else { |
| 422 | desc = &gInsertEnvReverbDescriptor; |
| 423 | } |
| 424 | } |
| 425 | |
Glenn Kasten | a189a68 | 2012-02-20 12:16:30 -0800 | [diff] [blame] | 426 | *pDescriptor = *desc; |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 427 | |
| 428 | return 0; |
| 429 | } /* end Reverb_getDescriptor */ |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 430 | |
| 431 | /*---------------------------------------------------------------------------- |
| 432 | * Reverb internal functions |
| 433 | *--------------------------------------------------------------------------*/ |
| 434 | |
| 435 | /*---------------------------------------------------------------------------- |
| 436 | * Reverb_Init() |
| 437 | *---------------------------------------------------------------------------- |
| 438 | * Purpose: |
| 439 | * Initialize reverb context and apply default parameters |
| 440 | * |
| 441 | * Inputs: |
| 442 | * pRvbModule - pointer to reverb effect module |
| 443 | * aux - indicates if the reverb is used as auxiliary (1) or insert (0) |
| 444 | * preset - indicates if the reverb is used in preset (1) or environmental (0) mode |
| 445 | * |
| 446 | * Outputs: |
| 447 | * |
| 448 | * Side Effects: |
| 449 | * |
| 450 | *---------------------------------------------------------------------------- |
| 451 | */ |
| 452 | |
| 453 | int Reverb_Init(reverb_module_t *pRvbModule, int aux, int preset) { |
| 454 | int ret; |
| 455 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 456 | ALOGV("Reverb_Init module %p, aux: %d, preset: %d", pRvbModule,aux, preset); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 457 | |
| 458 | memset(&pRvbModule->context, 0, sizeof(reverb_object_t)); |
| 459 | |
| 460 | pRvbModule->context.m_Aux = (uint16_t)aux; |
| 461 | pRvbModule->context.m_Preset = (uint16_t)preset; |
| 462 | |
| 463 | pRvbModule->config.inputCfg.samplingRate = 44100; |
| 464 | if (aux) { |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 465 | pRvbModule->config.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 466 | } else { |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 467 | pRvbModule->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 468 | } |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 469 | pRvbModule->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 470 | pRvbModule->config.inputCfg.bufferProvider.getBuffer = NULL; |
| 471 | pRvbModule->config.inputCfg.bufferProvider.releaseBuffer = NULL; |
| 472 | pRvbModule->config.inputCfg.bufferProvider.cookie = NULL; |
| 473 | pRvbModule->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; |
| 474 | pRvbModule->config.inputCfg.mask = EFFECT_CONFIG_ALL; |
| 475 | pRvbModule->config.outputCfg.samplingRate = 44100; |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 476 | pRvbModule->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; |
| 477 | pRvbModule->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 478 | pRvbModule->config.outputCfg.bufferProvider.getBuffer = NULL; |
| 479 | pRvbModule->config.outputCfg.bufferProvider.releaseBuffer = NULL; |
| 480 | pRvbModule->config.outputCfg.bufferProvider.cookie = NULL; |
| 481 | pRvbModule->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE; |
| 482 | pRvbModule->config.outputCfg.mask = EFFECT_CONFIG_ALL; |
| 483 | |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 484 | ret = Reverb_setConfig(pRvbModule, &pRvbModule->config, true); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 485 | if (ret < 0) { |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 486 | ALOGV("Reverb_Init error %d on module %p", ret, pRvbModule); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 487 | } |
| 488 | |
| 489 | return ret; |
| 490 | } |
| 491 | |
| 492 | /*---------------------------------------------------------------------------- |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 493 | * Reverb_setConfig() |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 494 | *---------------------------------------------------------------------------- |
| 495 | * Purpose: |
| 496 | * Set input and output audio configuration. |
| 497 | * |
| 498 | * Inputs: |
| 499 | * pRvbModule - pointer to reverb effect module |
| 500 | * pConfig - pointer to effect_config_t structure containing input |
| 501 | * and output audio parameters configuration |
| 502 | * init - true if called from init function |
| 503 | * Outputs: |
| 504 | * |
| 505 | * Side Effects: |
| 506 | * |
| 507 | *---------------------------------------------------------------------------- |
| 508 | */ |
| 509 | |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 510 | int Reverb_setConfig(reverb_module_t *pRvbModule, effect_config_t *pConfig, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 511 | bool init) { |
| 512 | reverb_object_t *pReverb = &pRvbModule->context; |
| 513 | int bufferSizeInSamples; |
| 514 | int updatePeriodInSamples; |
| 515 | int xfadePeriodInSamples; |
| 516 | |
| 517 | // Check configuration compatibility with build options |
| 518 | if (pConfig->inputCfg.samplingRate |
| 519 | != pConfig->outputCfg.samplingRate |
| 520 | || pConfig->outputCfg.channels != OUTPUT_CHANNELS |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 521 | || pConfig->inputCfg.format != AUDIO_FORMAT_PCM_16_BIT |
| 522 | || pConfig->outputCfg.format != AUDIO_FORMAT_PCM_16_BIT) { |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 523 | ALOGV("Reverb_setConfig invalid config"); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 524 | return -EINVAL; |
| 525 | } |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 526 | if ((pReverb->m_Aux && (pConfig->inputCfg.channels != AUDIO_CHANNEL_OUT_MONO)) || |
| 527 | (!pReverb->m_Aux && (pConfig->inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO))) { |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 528 | ALOGV("Reverb_setConfig invalid config"); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 529 | return -EINVAL; |
| 530 | } |
| 531 | |
Glenn Kasten | a189a68 | 2012-02-20 12:16:30 -0800 | [diff] [blame] | 532 | pRvbModule->config = *pConfig; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 533 | |
| 534 | pReverb->m_nSamplingRate = pRvbModule->config.outputCfg.samplingRate; |
| 535 | |
| 536 | switch (pReverb->m_nSamplingRate) { |
| 537 | case 8000: |
| 538 | pReverb->m_nUpdatePeriodInBits = 5; |
| 539 | bufferSizeInSamples = 4096; |
| 540 | pReverb->m_nCosWT_5KHz = -23170; |
| 541 | break; |
| 542 | case 16000: |
| 543 | pReverb->m_nUpdatePeriodInBits = 6; |
| 544 | bufferSizeInSamples = 8192; |
| 545 | pReverb->m_nCosWT_5KHz = -12540; |
| 546 | break; |
| 547 | case 22050: |
| 548 | pReverb->m_nUpdatePeriodInBits = 7; |
| 549 | bufferSizeInSamples = 8192; |
| 550 | pReverb->m_nCosWT_5KHz = 4768; |
| 551 | break; |
| 552 | case 32000: |
| 553 | pReverb->m_nUpdatePeriodInBits = 7; |
| 554 | bufferSizeInSamples = 16384; |
| 555 | pReverb->m_nCosWT_5KHz = 18205; |
| 556 | break; |
| 557 | case 44100: |
| 558 | pReverb->m_nUpdatePeriodInBits = 8; |
| 559 | bufferSizeInSamples = 16384; |
| 560 | pReverb->m_nCosWT_5KHz = 24799; |
| 561 | break; |
| 562 | case 48000: |
| 563 | pReverb->m_nUpdatePeriodInBits = 8; |
| 564 | bufferSizeInSamples = 16384; |
| 565 | pReverb->m_nCosWT_5KHz = 25997; |
| 566 | break; |
| 567 | default: |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 568 | ALOGV("Reverb_setConfig invalid sampling rate %d", pReverb->m_nSamplingRate); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 569 | return -EINVAL; |
| 570 | } |
| 571 | |
| 572 | // Define a mask for circular addressing, so that array index |
| 573 | // can wraparound and stay in array boundary of 0, 1, ..., (buffer size -1) |
| 574 | // The buffer size MUST be a power of two |
| 575 | pReverb->m_nBufferMask = (int32_t) (bufferSizeInSamples - 1); |
| 576 | /* reverb parameters are updated every 2^(pReverb->m_nUpdatePeriodInBits) samples */ |
| 577 | updatePeriodInSamples = (int32_t) (0x1L << pReverb->m_nUpdatePeriodInBits); |
| 578 | /* |
| 579 | calculate the update counter by bitwise ANDING with this value to |
| 580 | generate a 2^n modulo value |
| 581 | */ |
| 582 | pReverb->m_nUpdatePeriodInSamples = (int32_t) updatePeriodInSamples; |
| 583 | |
| 584 | xfadePeriodInSamples = (int32_t) (REVERB_XFADE_PERIOD_IN_SECONDS |
| 585 | * (double) pReverb->m_nSamplingRate); |
| 586 | |
| 587 | // set xfade parameters |
| 588 | pReverb->m_nPhaseIncrement |
| 589 | = (int16_t) (65536 / ((int16_t) xfadePeriodInSamples |
| 590 | / (int16_t) updatePeriodInSamples)); |
| 591 | |
| 592 | if (init) { |
| 593 | ReverbReadInPresets(pReverb); |
| 594 | |
| 595 | // for debugging purposes, allow noise generator |
| 596 | pReverb->m_bUseNoise = true; |
| 597 | |
| 598 | // for debugging purposes, allow bypass |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 599 | pReverb->m_bBypass = 0; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 600 | |
| 601 | pReverb->m_nNextRoom = 1; |
| 602 | |
| 603 | pReverb->m_nNoise = (int16_t) 0xABCD; |
| 604 | } |
| 605 | |
| 606 | Reverb_Reset(pReverb, init); |
| 607 | |
| 608 | return 0; |
| 609 | } |
| 610 | |
| 611 | /*---------------------------------------------------------------------------- |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 612 | * Reverb_getConfig() |
| 613 | *---------------------------------------------------------------------------- |
| 614 | * Purpose: |
| 615 | * Get input and output audio configuration. |
| 616 | * |
| 617 | * Inputs: |
| 618 | * pRvbModule - pointer to reverb effect module |
| 619 | * pConfig - pointer to effect_config_t structure containing input |
| 620 | * and output audio parameters configuration |
| 621 | * Outputs: |
| 622 | * |
| 623 | * Side Effects: |
| 624 | * |
| 625 | *---------------------------------------------------------------------------- |
| 626 | */ |
| 627 | |
| 628 | void Reverb_getConfig(reverb_module_t *pRvbModule, effect_config_t *pConfig) |
| 629 | { |
Glenn Kasten | a189a68 | 2012-02-20 12:16:30 -0800 | [diff] [blame] | 630 | *pConfig = pRvbModule->config; |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 631 | } |
| 632 | |
| 633 | /*---------------------------------------------------------------------------- |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 634 | * Reverb_Reset() |
| 635 | *---------------------------------------------------------------------------- |
| 636 | * Purpose: |
| 637 | * Reset internal states and clear delay lines. |
| 638 | * |
| 639 | * Inputs: |
| 640 | * pReverb - pointer to reverb context |
| 641 | * init - true if called from init function |
| 642 | * |
| 643 | * Outputs: |
| 644 | * |
| 645 | * Side Effects: |
| 646 | * |
| 647 | *---------------------------------------------------------------------------- |
| 648 | */ |
| 649 | |
| 650 | void Reverb_Reset(reverb_object_t *pReverb, bool init) { |
| 651 | int bufferSizeInSamples = (int32_t) (pReverb->m_nBufferMask + 1); |
| 652 | int maxApSamples; |
| 653 | int maxDelaySamples; |
| 654 | int maxEarlySamples; |
| 655 | int ap1In; |
| 656 | int delay0In; |
| 657 | int delay1In; |
| 658 | int32_t i; |
| 659 | uint16_t nOffset; |
| 660 | |
| 661 | maxApSamples = ((int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16); |
| 662 | maxDelaySamples = ((int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate) |
| 663 | >> 16); |
| 664 | maxEarlySamples = ((int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate) |
| 665 | >> 16); |
| 666 | |
| 667 | ap1In = (AP0_IN + maxApSamples + GUARD); |
| 668 | delay0In = (ap1In + maxApSamples + GUARD); |
| 669 | delay1In = (delay0In + maxDelaySamples + GUARD); |
| 670 | // Define the max offsets for the end points of each section |
| 671 | // i.e., we don't expect a given section's taps to go beyond |
| 672 | // the following limits |
| 673 | |
| 674 | pReverb->m_nEarly0in = (delay1In + maxDelaySamples + GUARD); |
| 675 | pReverb->m_nEarly1in = (pReverb->m_nEarly0in + maxEarlySamples + GUARD); |
| 676 | |
| 677 | pReverb->m_sAp0.m_zApIn = AP0_IN; |
| 678 | |
| 679 | pReverb->m_zD0In = delay0In; |
| 680 | |
| 681 | pReverb->m_sAp1.m_zApIn = ap1In; |
| 682 | |
| 683 | pReverb->m_zD1In = delay1In; |
| 684 | |
| 685 | pReverb->m_zOutLpfL = 0; |
| 686 | pReverb->m_zOutLpfR = 0; |
| 687 | |
| 688 | pReverb->m_nRevFbkR = 0; |
| 689 | pReverb->m_nRevFbkL = 0; |
| 690 | |
| 691 | // set base index into circular buffer |
| 692 | pReverb->m_nBaseIndex = 0; |
| 693 | |
| 694 | // clear the reverb delay line |
| 695 | for (i = 0; i < bufferSizeInSamples; i++) { |
| 696 | pReverb->m_nDelayLine[i] = 0; |
| 697 | } |
| 698 | |
| 699 | ReverbUpdateRoom(pReverb, init); |
| 700 | |
| 701 | pReverb->m_nUpdateCounter = 0; |
| 702 | |
| 703 | pReverb->m_nPhase = -32768; |
| 704 | |
| 705 | pReverb->m_nSin = 0; |
| 706 | pReverb->m_nCos = 0; |
| 707 | pReverb->m_nSinIncrement = 0; |
| 708 | pReverb->m_nCosIncrement = 0; |
| 709 | |
| 710 | // set delay tap lengths |
| 711 | nOffset = ReverbCalculateNoise(pReverb); |
| 712 | |
| 713 | pReverb->m_zD1Cross = pReverb->m_nDelay1Out - pReverb->m_nMaxExcursion |
| 714 | + nOffset; |
| 715 | |
| 716 | nOffset = ReverbCalculateNoise(pReverb); |
| 717 | |
| 718 | pReverb->m_zD0Cross = pReverb->m_nDelay0Out - pReverb->m_nMaxExcursion |
| 719 | - nOffset; |
| 720 | |
| 721 | nOffset = ReverbCalculateNoise(pReverb); |
| 722 | |
| 723 | pReverb->m_zD0Self = pReverb->m_nDelay0Out - pReverb->m_nMaxExcursion |
| 724 | - nOffset; |
| 725 | |
| 726 | nOffset = ReverbCalculateNoise(pReverb); |
| 727 | |
| 728 | pReverb->m_zD1Self = pReverb->m_nDelay1Out - pReverb->m_nMaxExcursion |
| 729 | + nOffset; |
| 730 | } |
| 731 | |
| 732 | /*---------------------------------------------------------------------------- |
| 733 | * Reverb_getParameter() |
| 734 | *---------------------------------------------------------------------------- |
| 735 | * Purpose: |
| 736 | * Get a Reverb parameter |
| 737 | * |
| 738 | * Inputs: |
| 739 | * pReverb - handle to instance data |
| 740 | * param - parameter |
| 741 | * pValue - pointer to variable to hold retrieved value |
| 742 | * pSize - pointer to value size: maximum size as input |
| 743 | * |
| 744 | * Outputs: |
| 745 | * *pValue updated with parameter value |
| 746 | * *pSize updated with actual value size |
| 747 | * |
| 748 | * |
| 749 | * Side Effects: |
| 750 | * |
| 751 | *---------------------------------------------------------------------------- |
| 752 | */ |
Ashok Bhat | b302bd5 | 2014-02-18 11:40:00 +0000 | [diff] [blame] | 753 | int Reverb_getParameter(reverb_object_t *pReverb, int32_t param, uint32_t *pSize, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 754 | void *pValue) { |
| 755 | int32_t *pValue32; |
| 756 | int16_t *pValue16; |
Eric Laurent | 23e1de7 | 2010-07-23 00:19:11 -0700 | [diff] [blame] | 757 | t_reverb_settings *pProperties; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 758 | int32_t i; |
| 759 | int32_t temp; |
| 760 | int32_t temp2; |
Ashok Bhat | b302bd5 | 2014-02-18 11:40:00 +0000 | [diff] [blame] | 761 | uint32_t size; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 762 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 763 | if (pReverb->m_Preset) { |
| 764 | if (param != REVERB_PARAM_PRESET || *pSize < sizeof(int16_t)) { |
| 765 | return -EINVAL; |
| 766 | } |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 767 | size = sizeof(int16_t); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 768 | pValue16 = (int16_t *)pValue; |
| 769 | // REVERB_PRESET_NONE is mapped to bypass |
| 770 | if (pReverb->m_bBypass != 0) { |
| 771 | *pValue16 = (int16_t)REVERB_PRESET_NONE; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 772 | } else { |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 773 | *pValue16 = (int16_t)(pReverb->m_nNextRoom + 1); |
| 774 | } |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 775 | ALOGV("get REVERB_PARAM_PRESET, preset %d", *pValue16); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 776 | } else { |
| 777 | switch (param) { |
| 778 | case REVERB_PARAM_ROOM_LEVEL: |
| 779 | case REVERB_PARAM_ROOM_HF_LEVEL: |
| 780 | case REVERB_PARAM_DECAY_HF_RATIO: |
| 781 | case REVERB_PARAM_REFLECTIONS_LEVEL: |
| 782 | case REVERB_PARAM_REVERB_LEVEL: |
| 783 | case REVERB_PARAM_DIFFUSION: |
| 784 | case REVERB_PARAM_DENSITY: |
| 785 | size = sizeof(int16_t); |
| 786 | break; |
| 787 | |
| 788 | case REVERB_PARAM_BYPASS: |
| 789 | case REVERB_PARAM_DECAY_TIME: |
| 790 | case REVERB_PARAM_REFLECTIONS_DELAY: |
| 791 | case REVERB_PARAM_REVERB_DELAY: |
| 792 | size = sizeof(int32_t); |
| 793 | break; |
| 794 | |
| 795 | case REVERB_PARAM_PROPERTIES: |
Eric Laurent | 23e1de7 | 2010-07-23 00:19:11 -0700 | [diff] [blame] | 796 | size = sizeof(t_reverb_settings); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 797 | break; |
| 798 | |
| 799 | default: |
| 800 | return -EINVAL; |
| 801 | } |
| 802 | |
| 803 | if (*pSize < size) { |
| 804 | return -EINVAL; |
| 805 | } |
| 806 | |
| 807 | pValue32 = (int32_t *) pValue; |
| 808 | pValue16 = (int16_t *) pValue; |
Eric Laurent | 23e1de7 | 2010-07-23 00:19:11 -0700 | [diff] [blame] | 809 | pProperties = (t_reverb_settings *) pValue; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 810 | |
| 811 | switch (param) { |
| 812 | case REVERB_PARAM_BYPASS: |
| 813 | *pValue32 = (int32_t) pReverb->m_bBypass; |
| 814 | break; |
| 815 | |
| 816 | case REVERB_PARAM_PROPERTIES: |
| 817 | pValue16 = &pProperties->roomLevel; |
| 818 | /* FALL THROUGH */ |
| 819 | |
| 820 | case REVERB_PARAM_ROOM_LEVEL: |
| 821 | // Convert m_nRoomLpfFwd to millibels |
| 822 | temp = (pReverb->m_nRoomLpfFwd << 15) |
| 823 | / (32767 - pReverb->m_nRoomLpfFbk); |
| 824 | *pValue16 = Effects_Linear16ToMillibels(temp); |
| 825 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 826 | ALOGV("get REVERB_PARAM_ROOM_LEVEL %d, gain %d, m_nRoomLpfFwd %d, m_nRoomLpfFbk %d", *pValue16, temp, pReverb->m_nRoomLpfFwd, pReverb->m_nRoomLpfFbk); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 827 | |
| 828 | if (param == REVERB_PARAM_ROOM_LEVEL) { |
| 829 | break; |
| 830 | } |
| 831 | pValue16 = &pProperties->roomHFLevel; |
| 832 | /* FALL THROUGH */ |
| 833 | |
| 834 | case REVERB_PARAM_ROOM_HF_LEVEL: |
| 835 | // The ratio between linear gain at 0Hz and at 5000Hz for the room low pass is: |
| 836 | // (1 + a1) / sqrt(a1^2 + 2*C*a1 + 1) where: |
| 837 | // - a1 is minus the LP feedback gain: -pReverb->m_nRoomLpfFbk |
| 838 | // - C is cos(2piWT) @ 5000Hz: pReverb->m_nCosWT_5KHz |
| 839 | |
| 840 | temp = MULT_EG1_EG1(pReverb->m_nRoomLpfFbk, pReverb->m_nRoomLpfFbk); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 841 | ALOGV("get REVERB_PARAM_ROOM_HF_LEVEL, a1^2 %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 842 | temp2 = MULT_EG1_EG1(pReverb->m_nRoomLpfFbk, pReverb->m_nCosWT_5KHz) |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 843 | << 1; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 844 | ALOGV("get REVERB_PARAM_ROOM_HF_LEVEL, 2 Cos a1 %d", temp2); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 845 | temp = 32767 + temp - temp2; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 846 | ALOGV("get REVERB_PARAM_ROOM_HF_LEVEL, a1^2 + 2 Cos a1 + 1 %d", temp); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 847 | temp = Effects_Sqrt(temp) * 181; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 848 | ALOGV("get REVERB_PARAM_ROOM_HF_LEVEL, SQRT(a1^2 + 2 Cos a1 + 1) %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 849 | temp = ((32767 - pReverb->m_nRoomLpfFbk) << 15) / temp; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 850 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 851 | ALOGV("get REVERB_PARAM_ROOM_HF_LEVEL, gain %d, m_nRoomLpfFwd %d, m_nRoomLpfFbk %d", temp, pReverb->m_nRoomLpfFwd, pReverb->m_nRoomLpfFbk); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 852 | |
| 853 | *pValue16 = Effects_Linear16ToMillibels(temp); |
| 854 | |
| 855 | if (param == REVERB_PARAM_ROOM_HF_LEVEL) { |
| 856 | break; |
| 857 | } |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 858 | pValue32 = (int32_t *)&pProperties->decayTime; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 859 | /* FALL THROUGH */ |
| 860 | |
| 861 | case REVERB_PARAM_DECAY_TIME: |
| 862 | // Calculate reverb feedback path gain |
| 863 | temp = (pReverb->m_nRvbLpfFwd << 15) / (32767 - pReverb->m_nRvbLpfFbk); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 864 | temp = Effects_Linear16ToMillibels(temp); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 865 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 866 | // Calculate decay time: g = -6000 d/DT , g gain in millibels, d reverb delay, DT decay time |
| 867 | temp = (-6000 * pReverb->m_nLateDelay) / temp; |
| 868 | |
| 869 | // Convert samples to ms |
| 870 | *pValue32 = (temp * 1000) / pReverb->m_nSamplingRate; |
| 871 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 872 | ALOGV("get REVERB_PARAM_DECAY_TIME, samples %d, ms %d", temp, *pValue32); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 873 | |
| 874 | if (param == REVERB_PARAM_DECAY_TIME) { |
| 875 | break; |
| 876 | } |
| 877 | pValue16 = &pProperties->decayHFRatio; |
| 878 | /* FALL THROUGH */ |
| 879 | |
| 880 | case REVERB_PARAM_DECAY_HF_RATIO: |
| 881 | // If r is the decay HF ratio (r = REVERB_PARAM_DECAY_HF_RATIO/1000) we have: |
| 882 | // DT_5000Hz = DT_0Hz * r |
| 883 | // and G_5000Hz = -6000 * d / DT_5000Hz and G_0Hz = -6000 * d / DT_0Hz in millibels so : |
| 884 | // r = G_0Hz/G_5000Hz in millibels |
| 885 | // The linear gain at 5000Hz is b0 / sqrt(a1^2 + 2*C*a1 + 1) where: |
| 886 | // - a1 is minus the LP feedback gain: -pReverb->m_nRvbLpfFbk |
| 887 | // - b0 is the LP forward gain: pReverb->m_nRvbLpfFwd |
| 888 | // - C is cos(2piWT) @ 5000Hz: pReverb->m_nCosWT_5KHz |
| 889 | if (pReverb->m_nRvbLpfFbk == 0) { |
| 890 | *pValue16 = 1000; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 891 | ALOGV("get REVERB_PARAM_DECAY_HF_RATIO, pReverb->m_nRvbLpfFbk == 0, ratio %d", *pValue16); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 892 | } else { |
| 893 | temp = MULT_EG1_EG1(pReverb->m_nRvbLpfFbk, pReverb->m_nRvbLpfFbk); |
| 894 | temp2 = MULT_EG1_EG1(pReverb->m_nRvbLpfFbk, pReverb->m_nCosWT_5KHz) |
| 895 | << 1; |
| 896 | temp = 32767 + temp - temp2; |
| 897 | temp = Effects_Sqrt(temp) * 181; |
| 898 | temp = (pReverb->m_nRvbLpfFwd << 15) / temp; |
| 899 | // The linear gain at 0Hz is b0 / (a1 + 1) |
| 900 | temp2 = (pReverb->m_nRvbLpfFwd << 15) / (32767 |
| 901 | - pReverb->m_nRvbLpfFbk); |
| 902 | |
| 903 | temp = Effects_Linear16ToMillibels(temp); |
| 904 | temp2 = Effects_Linear16ToMillibels(temp2); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 905 | ALOGV("get REVERB_PARAM_DECAY_HF_RATIO, gain 5KHz %d mB, gain DC %d mB", temp, temp2); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 906 | |
| 907 | if (temp == 0) |
| 908 | temp = 1; |
| 909 | temp = (int16_t) ((1000 * temp2) / temp); |
| 910 | if (temp > 1000) |
| 911 | temp = 1000; |
| 912 | |
| 913 | *pValue16 = temp; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 914 | ALOGV("get REVERB_PARAM_DECAY_HF_RATIO, ratio %d", *pValue16); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 915 | } |
| 916 | |
| 917 | if (param == REVERB_PARAM_DECAY_HF_RATIO) { |
| 918 | break; |
| 919 | } |
| 920 | pValue16 = &pProperties->reflectionsLevel; |
| 921 | /* FALL THROUGH */ |
| 922 | |
| 923 | case REVERB_PARAM_REFLECTIONS_LEVEL: |
| 924 | *pValue16 = Effects_Linear16ToMillibels(pReverb->m_nEarlyGain); |
| 925 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 926 | ALOGV("get REVERB_PARAM_REFLECTIONS_LEVEL, %d", *pValue16); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 927 | if (param == REVERB_PARAM_REFLECTIONS_LEVEL) { |
| 928 | break; |
| 929 | } |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 930 | pValue32 = (int32_t *)&pProperties->reflectionsDelay; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 931 | /* FALL THROUGH */ |
| 932 | |
| 933 | case REVERB_PARAM_REFLECTIONS_DELAY: |
| 934 | // convert samples to ms |
| 935 | *pValue32 = (pReverb->m_nEarlyDelay * 1000) / pReverb->m_nSamplingRate; |
| 936 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 937 | ALOGV("get REVERB_PARAM_REFLECTIONS_DELAY, samples %d, ms %d", pReverb->m_nEarlyDelay, *pValue32); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 938 | |
| 939 | if (param == REVERB_PARAM_REFLECTIONS_DELAY) { |
| 940 | break; |
| 941 | } |
| 942 | pValue16 = &pProperties->reverbLevel; |
| 943 | /* FALL THROUGH */ |
| 944 | |
| 945 | case REVERB_PARAM_REVERB_LEVEL: |
| 946 | // Convert linear gain to millibels |
| 947 | *pValue16 = Effects_Linear16ToMillibels(pReverb->m_nLateGain << 2); |
| 948 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 949 | ALOGV("get REVERB_PARAM_REVERB_LEVEL %d", *pValue16); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 950 | |
| 951 | if (param == REVERB_PARAM_REVERB_LEVEL) { |
| 952 | break; |
| 953 | } |
Eric Laurent | 3d5188b | 2011-12-16 15:30:36 -0800 | [diff] [blame] | 954 | pValue32 = (int32_t *)&pProperties->reverbDelay; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 955 | /* FALL THROUGH */ |
| 956 | |
| 957 | case REVERB_PARAM_REVERB_DELAY: |
| 958 | // convert samples to ms |
| 959 | *pValue32 = (pReverb->m_nLateDelay * 1000) / pReverb->m_nSamplingRate; |
| 960 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 961 | ALOGV("get REVERB_PARAM_REVERB_DELAY, samples %d, ms %d", pReverb->m_nLateDelay, *pValue32); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 962 | |
| 963 | if (param == REVERB_PARAM_REVERB_DELAY) { |
| 964 | break; |
| 965 | } |
| 966 | pValue16 = &pProperties->diffusion; |
| 967 | /* FALL THROUGH */ |
| 968 | |
| 969 | case REVERB_PARAM_DIFFUSION: |
| 970 | temp = (int16_t) ((1000 * (pReverb->m_sAp0.m_nApGain - AP0_GAIN_BASE)) |
| 971 | / AP0_GAIN_RANGE); |
| 972 | |
| 973 | if (temp < 0) |
| 974 | temp = 0; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 975 | if (temp > 1000) |
| 976 | temp = 1000; |
| 977 | |
| 978 | *pValue16 = temp; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 979 | ALOGV("get REVERB_PARAM_DIFFUSION, %d, AP0 gain %d", *pValue16, pReverb->m_sAp0.m_nApGain); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 980 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 981 | if (param == REVERB_PARAM_DIFFUSION) { |
| 982 | break; |
| 983 | } |
| 984 | pValue16 = &pProperties->density; |
| 985 | /* FALL THROUGH */ |
| 986 | |
| 987 | case REVERB_PARAM_DENSITY: |
| 988 | // Calculate AP delay in time units |
| 989 | temp = ((pReverb->m_sAp0.m_zApOut - pReverb->m_sAp0.m_zApIn) << 16) |
| 990 | / pReverb->m_nSamplingRate; |
| 991 | |
| 992 | temp = (int16_t) ((1000 * (temp - AP0_TIME_BASE)) / AP0_TIME_RANGE); |
| 993 | |
| 994 | if (temp < 0) |
| 995 | temp = 0; |
| 996 | if (temp > 1000) |
| 997 | temp = 1000; |
| 998 | |
| 999 | *pValue16 = temp; |
| 1000 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1001 | ALOGV("get REVERB_PARAM_DENSITY, %d, AP0 delay smps %d", *pValue16, pReverb->m_sAp0.m_zApOut - pReverb->m_sAp0.m_zApIn); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1002 | break; |
| 1003 | |
| 1004 | default: |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1005 | break; |
| 1006 | } |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1007 | } |
| 1008 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1009 | *pSize = size; |
| 1010 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1011 | ALOGV("Reverb_getParameter, context %p, param %d, value %d", |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1012 | pReverb, param, *(int *)pValue); |
| 1013 | |
| 1014 | return 0; |
| 1015 | } /* end Reverb_getParameter */ |
| 1016 | |
| 1017 | /*---------------------------------------------------------------------------- |
| 1018 | * Reverb_setParameter() |
| 1019 | *---------------------------------------------------------------------------- |
| 1020 | * Purpose: |
| 1021 | * Set a Reverb parameter |
| 1022 | * |
| 1023 | * Inputs: |
| 1024 | * pReverb - handle to instance data |
| 1025 | * param - parameter |
| 1026 | * pValue - pointer to parameter value |
| 1027 | * size - value size |
| 1028 | * |
| 1029 | * Outputs: |
| 1030 | * |
| 1031 | * |
| 1032 | * Side Effects: |
| 1033 | * |
| 1034 | *---------------------------------------------------------------------------- |
| 1035 | */ |
Ashok Bhat | b302bd5 | 2014-02-18 11:40:00 +0000 | [diff] [blame] | 1036 | int Reverb_setParameter(reverb_object_t *pReverb, int32_t param, uint32_t size, |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1037 | void *pValue) { |
| 1038 | int32_t value32; |
| 1039 | int16_t value16; |
Eric Laurent | 23e1de7 | 2010-07-23 00:19:11 -0700 | [diff] [blame] | 1040 | t_reverb_settings *pProperties; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1041 | int32_t i; |
| 1042 | int32_t temp; |
| 1043 | int32_t temp2; |
| 1044 | reverb_preset_t *pPreset; |
| 1045 | int maxSamples; |
| 1046 | int32_t averageDelay; |
Ashok Bhat | b302bd5 | 2014-02-18 11:40:00 +0000 | [diff] [blame] | 1047 | uint32_t paramSize; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1048 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1049 | ALOGV("Reverb_setParameter, context %p, param %d, value16 %d, value32 %d", |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1050 | pReverb, param, *(int16_t *)pValue, *(int32_t *)pValue); |
| 1051 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1052 | if (pReverb->m_Preset) { |
| 1053 | if (param != REVERB_PARAM_PRESET || size != sizeof(int16_t)) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1054 | return -EINVAL; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1055 | } |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1056 | value16 = *(int16_t *)pValue; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1057 | ALOGV("set REVERB_PARAM_PRESET, preset %d", value16); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1058 | if (value16 < REVERB_PRESET_NONE || value16 > REVERB_PRESET_PLATE) { |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1059 | return -EINVAL; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1060 | } |
| 1061 | // REVERB_PRESET_NONE is mapped to bypass |
| 1062 | if (value16 == REVERB_PRESET_NONE) { |
| 1063 | pReverb->m_bBypass = 1; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1064 | } else { |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1065 | pReverb->m_bBypass = 0; |
| 1066 | pReverb->m_nNextRoom = value16 - 1; |
| 1067 | } |
| 1068 | } else { |
| 1069 | switch (param) { |
| 1070 | case REVERB_PARAM_ROOM_LEVEL: |
| 1071 | case REVERB_PARAM_ROOM_HF_LEVEL: |
| 1072 | case REVERB_PARAM_DECAY_HF_RATIO: |
| 1073 | case REVERB_PARAM_REFLECTIONS_LEVEL: |
| 1074 | case REVERB_PARAM_REVERB_LEVEL: |
| 1075 | case REVERB_PARAM_DIFFUSION: |
| 1076 | case REVERB_PARAM_DENSITY: |
| 1077 | paramSize = sizeof(int16_t); |
| 1078 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1079 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1080 | case REVERB_PARAM_BYPASS: |
| 1081 | case REVERB_PARAM_DECAY_TIME: |
| 1082 | case REVERB_PARAM_REFLECTIONS_DELAY: |
| 1083 | case REVERB_PARAM_REVERB_DELAY: |
| 1084 | paramSize = sizeof(int32_t); |
| 1085 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1086 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1087 | case REVERB_PARAM_PROPERTIES: |
Eric Laurent | 23e1de7 | 2010-07-23 00:19:11 -0700 | [diff] [blame] | 1088 | paramSize = sizeof(t_reverb_settings); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1089 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1090 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1091 | default: |
| 1092 | return -EINVAL; |
| 1093 | } |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1094 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1095 | if (size != paramSize) { |
| 1096 | return -EINVAL; |
| 1097 | } |
| 1098 | |
| 1099 | if (paramSize == sizeof(int16_t)) { |
| 1100 | value16 = *(int16_t *) pValue; |
| 1101 | } else if (paramSize == sizeof(int32_t)) { |
| 1102 | value32 = *(int32_t *) pValue; |
| 1103 | } else { |
Eric Laurent | 23e1de7 | 2010-07-23 00:19:11 -0700 | [diff] [blame] | 1104 | pProperties = (t_reverb_settings *) pValue; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1105 | } |
| 1106 | |
| 1107 | pPreset = &pReverb->m_sPreset.m_sPreset[pReverb->m_nNextRoom]; |
| 1108 | |
| 1109 | switch (param) { |
| 1110 | case REVERB_PARAM_BYPASS: |
| 1111 | pReverb->m_bBypass = (uint16_t)value32; |
| 1112 | break; |
| 1113 | |
| 1114 | case REVERB_PARAM_PROPERTIES: |
| 1115 | value16 = pProperties->roomLevel; |
| 1116 | /* FALL THROUGH */ |
| 1117 | |
| 1118 | case REVERB_PARAM_ROOM_LEVEL: |
| 1119 | // Convert millibels to linear 16 bit signed => m_nRoomLpfFwd |
| 1120 | if (value16 > 0) |
| 1121 | return -EINVAL; |
| 1122 | |
| 1123 | temp = Effects_MillibelsToLinear16(value16); |
| 1124 | |
| 1125 | pReverb->m_nRoomLpfFwd |
| 1126 | = MULT_EG1_EG1(temp, (32767 - pReverb->m_nRoomLpfFbk)); |
| 1127 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1128 | ALOGV("REVERB_PARAM_ROOM_LEVEL, gain %d, new m_nRoomLpfFwd %d, m_nRoomLpfFbk %d", temp, pReverb->m_nRoomLpfFwd, pReverb->m_nRoomLpfFbk); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1129 | if (param == REVERB_PARAM_ROOM_LEVEL) |
| 1130 | break; |
| 1131 | value16 = pProperties->roomHFLevel; |
| 1132 | /* FALL THROUGH */ |
| 1133 | |
| 1134 | case REVERB_PARAM_ROOM_HF_LEVEL: |
| 1135 | |
| 1136 | // Limit to 0 , -40dB range because of low pass implementation |
| 1137 | if (value16 > 0 || value16 < -4000) |
| 1138 | return -EINVAL; |
| 1139 | // Convert attenuation @ 5000H expressed in millibels to => m_nRoomLpfFbk |
| 1140 | // m_nRoomLpfFbk is -a1 where a1 is the solution of: |
| 1141 | // a1^2 + 2*(C-dG^2)/(1-dG^2)*a1 + 1 = 0 where: |
| 1142 | // - C is cos(2*pi*5000/Fs) (pReverb->m_nCosWT_5KHz) |
| 1143 | // - dG is G0/Gf (G0 is the linear gain at DC and Gf is the wanted gain at 5000Hz) |
| 1144 | |
| 1145 | // Save current DC gain m_nRoomLpfFwd / (32767 - m_nRoomLpfFbk) to keep it unchanged |
| 1146 | // while changing HF level |
| 1147 | temp2 = (pReverb->m_nRoomLpfFwd << 15) / (32767 |
| 1148 | - pReverb->m_nRoomLpfFbk); |
| 1149 | if (value16 == 0) { |
| 1150 | pReverb->m_nRoomLpfFbk = 0; |
| 1151 | } else { |
| 1152 | int32_t dG2, b, delta; |
| 1153 | |
| 1154 | // dG^2 |
| 1155 | temp = Effects_MillibelsToLinear16(value16); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1156 | ALOGV("REVERB_PARAM_ROOM_HF_LEVEL, HF gain %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1157 | temp = (1 << 30) / temp; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1158 | ALOGV("REVERB_PARAM_ROOM_HF_LEVEL, 1/ HF gain %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1159 | dG2 = (int32_t) (((int64_t) temp * (int64_t) temp) >> 15); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1160 | ALOGV("REVERB_PARAM_ROOM_HF_LEVEL, 1/ HF gain ^ 2 %d", dG2); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1161 | // b = 2*(C-dG^2)/(1-dG^2) |
| 1162 | b = (int32_t) ((((int64_t) 1 << (15 + 1)) |
| 1163 | * ((int64_t) pReverb->m_nCosWT_5KHz - (int64_t) dG2)) |
| 1164 | / ((int64_t) 32767 - (int64_t) dG2)); |
| 1165 | |
| 1166 | // delta = b^2 - 4 |
| 1167 | delta = (int32_t) ((((int64_t) b * (int64_t) b) >> 15) - (1 << (15 |
| 1168 | + 2))); |
| 1169 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1170 | ALOGV_IF(delta > (1<<30), " delta overflow %d", delta); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1171 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1172 | ALOGV("REVERB_PARAM_ROOM_HF_LEVEL, dG2 %d, b %d, delta %d, m_nCosWT_5KHz %d", dG2, b, delta, pReverb->m_nCosWT_5KHz); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1173 | // m_nRoomLpfFbk = -a1 = - (- b + sqrt(delta)) / 2 |
| 1174 | pReverb->m_nRoomLpfFbk = (b - Effects_Sqrt(delta) * 181) >> 1; |
| 1175 | } |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1176 | ALOGV("REVERB_PARAM_ROOM_HF_LEVEL, olg DC gain %d new m_nRoomLpfFbk %d, old m_nRoomLpfFwd %d", |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1177 | temp2, pReverb->m_nRoomLpfFbk, pReverb->m_nRoomLpfFwd); |
| 1178 | |
| 1179 | pReverb->m_nRoomLpfFwd |
| 1180 | = MULT_EG1_EG1(temp2, (32767 - pReverb->m_nRoomLpfFbk)); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1181 | ALOGV("REVERB_PARAM_ROOM_HF_LEVEL, new m_nRoomLpfFwd %d", pReverb->m_nRoomLpfFwd); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1182 | |
| 1183 | if (param == REVERB_PARAM_ROOM_HF_LEVEL) |
| 1184 | break; |
| 1185 | value32 = pProperties->decayTime; |
| 1186 | /* FALL THROUGH */ |
| 1187 | |
| 1188 | case REVERB_PARAM_DECAY_TIME: |
| 1189 | |
| 1190 | // Convert milliseconds to => m_nRvbLpfFwd (function of m_nRvbLpfFbk) |
| 1191 | // convert ms to samples |
| 1192 | value32 = (value32 * pReverb->m_nSamplingRate) / 1000; |
| 1193 | |
| 1194 | // calculate valid decay time range as a function of current reverb delay and |
| 1195 | // max feed back gain. Min value <=> -40dB in one pass, Max value <=> feedback gain = -1 dB |
| 1196 | // Calculate attenuation for each round in late reverb given a total attenuation of -6000 millibels. |
| 1197 | // g = -6000 d/DT , g gain in millibels, d reverb delay, DT decay time |
| 1198 | averageDelay = pReverb->m_nLateDelay - pReverb->m_nMaxExcursion; |
| 1199 | averageDelay += ((pReverb->m_sAp0.m_zApOut - pReverb->m_sAp0.m_zApIn) |
| 1200 | + (pReverb->m_sAp1.m_zApOut - pReverb->m_sAp1.m_zApIn)) >> 1; |
| 1201 | |
| 1202 | temp = (-6000 * averageDelay) / value32; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1203 | ALOGV("REVERB_PARAM_DECAY_TIME, delay smps %d, DT smps %d, gain mB %d",averageDelay, value32, temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1204 | if (temp < -4000 || temp > -100) |
| 1205 | return -EINVAL; |
| 1206 | |
| 1207 | // calculate low pass gain by adding reverb input attenuation (pReverb->m_nLateGain) and substrating output |
| 1208 | // xfade and sum gain (max +9dB) |
| 1209 | temp -= Effects_Linear16ToMillibels(pReverb->m_nLateGain) + 900; |
| 1210 | temp = Effects_MillibelsToLinear16(temp); |
| 1211 | |
| 1212 | // DC gain (temp) = b0 / (1 + a1) = pReverb->m_nRvbLpfFwd / (32767 - pReverb->m_nRvbLpfFbk) |
| 1213 | pReverb->m_nRvbLpfFwd |
| 1214 | = MULT_EG1_EG1(temp, (32767 - pReverb->m_nRvbLpfFbk)); |
| 1215 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1216 | ALOGV("REVERB_PARAM_DECAY_TIME, gain %d, new m_nRvbLpfFwd %d, old m_nRvbLpfFbk %d, reverb gain %d", temp, pReverb->m_nRvbLpfFwd, pReverb->m_nRvbLpfFbk, Effects_Linear16ToMillibels(pReverb->m_nLateGain)); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1217 | |
| 1218 | if (param == REVERB_PARAM_DECAY_TIME) |
| 1219 | break; |
| 1220 | value16 = pProperties->decayHFRatio; |
| 1221 | /* FALL THROUGH */ |
| 1222 | |
| 1223 | case REVERB_PARAM_DECAY_HF_RATIO: |
| 1224 | |
| 1225 | // We limit max value to 1000 because reverb filter is lowpass only |
| 1226 | if (value16 < 100 || value16 > 1000) |
| 1227 | return -EINVAL; |
| 1228 | // Convert per mille to => m_nLpfFwd, m_nLpfFbk |
| 1229 | |
| 1230 | // Save current DC gain m_nRoomLpfFwd / (32767 - m_nRoomLpfFbk) to keep it unchanged |
| 1231 | // while changing HF level |
| 1232 | temp2 = (pReverb->m_nRvbLpfFwd << 15) / (32767 - pReverb->m_nRvbLpfFbk); |
| 1233 | |
| 1234 | if (value16 == 1000) { |
| 1235 | pReverb->m_nRvbLpfFbk = 0; |
| 1236 | } else { |
| 1237 | int32_t dG2, b, delta; |
| 1238 | |
| 1239 | temp = Effects_Linear16ToMillibels(temp2); |
| 1240 | // G_5000Hz = G_DC * (1000/REVERB_PARAM_DECAY_HF_RATIO) in millibels |
| 1241 | |
| 1242 | value32 = ((int32_t) 1000 << 15) / (int32_t) value16; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1243 | ALOGV("REVERB_PARAM_DECAY_HF_RATIO, DC gain %d, DC gain mB %d, 1000/R %d", temp2, temp, value32); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1244 | |
| 1245 | temp = (int32_t) (((int64_t) temp * (int64_t) value32) >> 15); |
| 1246 | |
| 1247 | if (temp < -4000) { |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1248 | ALOGV("REVERB_PARAM_DECAY_HF_RATIO HF gain overflow %d mB", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1249 | temp = -4000; |
| 1250 | } |
| 1251 | |
| 1252 | temp = Effects_MillibelsToLinear16(temp); |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1253 | ALOGV("REVERB_PARAM_DECAY_HF_RATIO, HF gain %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1254 | // dG^2 |
| 1255 | temp = (temp2 << 15) / temp; |
| 1256 | dG2 = (int32_t) (((int64_t) temp * (int64_t) temp) >> 15); |
| 1257 | |
| 1258 | // b = 2*(C-dG^2)/(1-dG^2) |
| 1259 | b = (int32_t) ((((int64_t) 1 << (15 + 1)) |
| 1260 | * ((int64_t) pReverb->m_nCosWT_5KHz - (int64_t) dG2)) |
| 1261 | / ((int64_t) 32767 - (int64_t) dG2)); |
| 1262 | |
| 1263 | // delta = b^2 - 4 |
| 1264 | delta = (int32_t) ((((int64_t) b * (int64_t) b) >> 15) - (1 << (15 |
| 1265 | + 2))); |
| 1266 | |
| 1267 | // m_nRoomLpfFbk = -a1 = - (- b + sqrt(delta)) / 2 |
| 1268 | pReverb->m_nRvbLpfFbk = (b - Effects_Sqrt(delta) * 181) >> 1; |
| 1269 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1270 | ALOGV("REVERB_PARAM_DECAY_HF_RATIO, dG2 %d, b %d, delta %d", dG2, b, delta); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1271 | |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1272 | } |
| 1273 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1274 | ALOGV("REVERB_PARAM_DECAY_HF_RATIO, gain %d, m_nRvbLpfFbk %d, m_nRvbLpfFwd %d", temp2, pReverb->m_nRvbLpfFbk, pReverb->m_nRvbLpfFwd); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1275 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1276 | pReverb->m_nRvbLpfFwd |
| 1277 | = MULT_EG1_EG1(temp2, (32767 - pReverb->m_nRvbLpfFbk)); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1278 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1279 | if (param == REVERB_PARAM_DECAY_HF_RATIO) |
| 1280 | break; |
| 1281 | value16 = pProperties->reflectionsLevel; |
| 1282 | /* FALL THROUGH */ |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1283 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1284 | case REVERB_PARAM_REFLECTIONS_LEVEL: |
| 1285 | // We limit max value to 0 because gain is limited to 0dB |
| 1286 | if (value16 > 0 || value16 < -6000) |
| 1287 | return -EINVAL; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1288 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1289 | // Convert millibels to linear 16 bit signed and recompute m_sEarlyL.m_nGain[i] and m_sEarlyR.m_nGain[i]. |
| 1290 | value16 = Effects_MillibelsToLinear16(value16); |
| 1291 | for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) { |
| 1292 | pReverb->m_sEarlyL.m_nGain[i] |
| 1293 | = MULT_EG1_EG1(pPreset->m_sEarlyL.m_nGain[i],value16); |
| 1294 | pReverb->m_sEarlyR.m_nGain[i] |
| 1295 | = MULT_EG1_EG1(pPreset->m_sEarlyR.m_nGain[i],value16); |
| 1296 | } |
| 1297 | pReverb->m_nEarlyGain = value16; |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1298 | ALOGV("REVERB_PARAM_REFLECTIONS_LEVEL, m_nEarlyGain %d", pReverb->m_nEarlyGain); |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1299 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1300 | if (param == REVERB_PARAM_REFLECTIONS_LEVEL) |
| 1301 | break; |
| 1302 | value32 = pProperties->reflectionsDelay; |
| 1303 | /* FALL THROUGH */ |
| 1304 | |
| 1305 | case REVERB_PARAM_REFLECTIONS_DELAY: |
| 1306 | // We limit max value MAX_EARLY_TIME |
| 1307 | // convert ms to time units |
| 1308 | temp = (value32 * 65536) / 1000; |
| 1309 | if (temp < 0 || temp > MAX_EARLY_TIME) |
| 1310 | return -EINVAL; |
| 1311 | |
| 1312 | maxSamples = (int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate) |
| 1313 | >> 16; |
| 1314 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1315 | for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) { |
| 1316 | temp2 = temp + (((int32_t) pPreset->m_sEarlyL.m_zDelay[i] |
| 1317 | * pReverb->m_nSamplingRate) >> 16); |
| 1318 | if (temp2 > maxSamples) |
| 1319 | temp2 = maxSamples; |
| 1320 | pReverb->m_sEarlyL.m_zDelay[i] = pReverb->m_nEarly0in + temp2; |
| 1321 | temp2 = temp + (((int32_t) pPreset->m_sEarlyR.m_zDelay[i] |
| 1322 | * pReverb->m_nSamplingRate) >> 16); |
| 1323 | if (temp2 > maxSamples) |
| 1324 | temp2 = maxSamples; |
| 1325 | pReverb->m_sEarlyR.m_zDelay[i] = pReverb->m_nEarly1in + temp2; |
| 1326 | } |
| 1327 | pReverb->m_nEarlyDelay = temp; |
| 1328 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1329 | ALOGV("REVERB_PARAM_REFLECTIONS_DELAY, m_nEarlyDelay smps %d max smp delay %d", pReverb->m_nEarlyDelay, maxSamples); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1330 | |
| 1331 | // Convert milliseconds to sample count => m_nEarlyDelay |
| 1332 | if (param == REVERB_PARAM_REFLECTIONS_DELAY) |
| 1333 | break; |
| 1334 | value16 = pProperties->reverbLevel; |
| 1335 | /* FALL THROUGH */ |
| 1336 | |
| 1337 | case REVERB_PARAM_REVERB_LEVEL: |
| 1338 | // We limit max value to 0 because gain is limited to 0dB |
| 1339 | if (value16 > 0 || value16 < -6000) |
| 1340 | return -EINVAL; |
| 1341 | // Convert millibels to linear 16 bits (gange 0 - 8191) => m_nLateGain. |
| 1342 | pReverb->m_nLateGain = Effects_MillibelsToLinear16(value16) >> 2; |
| 1343 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1344 | ALOGV("REVERB_PARAM_REVERB_LEVEL, m_nLateGain %d", pReverb->m_nLateGain); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1345 | |
| 1346 | if (param == REVERB_PARAM_REVERB_LEVEL) |
| 1347 | break; |
| 1348 | value32 = pProperties->reverbDelay; |
| 1349 | /* FALL THROUGH */ |
| 1350 | |
| 1351 | case REVERB_PARAM_REVERB_DELAY: |
| 1352 | // We limit max value to MAX_DELAY_TIME |
| 1353 | // convert ms to time units |
| 1354 | temp = (value32 * 65536) / 1000; |
| 1355 | if (temp < 0 || temp > MAX_DELAY_TIME) |
| 1356 | return -EINVAL; |
| 1357 | |
| 1358 | maxSamples = (int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate) |
| 1359 | >> 16; |
| 1360 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1361 | if ((temp + pReverb->m_nMaxExcursion) > maxSamples) { |
| 1362 | temp = maxSamples - pReverb->m_nMaxExcursion; |
| 1363 | } |
| 1364 | if (temp < pReverb->m_nMaxExcursion) { |
| 1365 | temp = pReverb->m_nMaxExcursion; |
| 1366 | } |
| 1367 | |
| 1368 | temp -= pReverb->m_nLateDelay; |
| 1369 | pReverb->m_nDelay0Out += temp; |
| 1370 | pReverb->m_nDelay1Out += temp; |
| 1371 | pReverb->m_nLateDelay += temp; |
| 1372 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1373 | ALOGV("REVERB_PARAM_REVERB_DELAY, m_nLateDelay smps %d max smp delay %d", pReverb->m_nLateDelay, maxSamples); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1374 | |
| 1375 | // Convert milliseconds to sample count => m_nDelay1Out + m_nMaxExcursion |
| 1376 | if (param == REVERB_PARAM_REVERB_DELAY) |
| 1377 | break; |
| 1378 | |
| 1379 | value16 = pProperties->diffusion; |
| 1380 | /* FALL THROUGH */ |
| 1381 | |
| 1382 | case REVERB_PARAM_DIFFUSION: |
| 1383 | if (value16 < 0 || value16 > 1000) |
| 1384 | return -EINVAL; |
| 1385 | |
| 1386 | // Convert per mille to m_sAp0.m_nApGain, m_sAp1.m_nApGain |
| 1387 | pReverb->m_sAp0.m_nApGain = AP0_GAIN_BASE + ((int32_t) value16 |
| 1388 | * AP0_GAIN_RANGE) / 1000; |
| 1389 | pReverb->m_sAp1.m_nApGain = AP1_GAIN_BASE + ((int32_t) value16 |
| 1390 | * AP1_GAIN_RANGE) / 1000; |
| 1391 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1392 | ALOGV("REVERB_PARAM_DIFFUSION, m_sAp0.m_nApGain %d m_sAp1.m_nApGain %d", pReverb->m_sAp0.m_nApGain, pReverb->m_sAp1.m_nApGain); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1393 | |
| 1394 | if (param == REVERB_PARAM_DIFFUSION) |
| 1395 | break; |
| 1396 | |
| 1397 | value16 = pProperties->density; |
| 1398 | /* FALL THROUGH */ |
| 1399 | |
| 1400 | case REVERB_PARAM_DENSITY: |
| 1401 | if (value16 < 0 || value16 > 1000) |
| 1402 | return -EINVAL; |
| 1403 | |
| 1404 | // Convert per mille to m_sAp0.m_zApOut, m_sAp1.m_zApOut |
| 1405 | maxSamples = (int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16; |
| 1406 | |
| 1407 | temp = AP0_TIME_BASE + ((int32_t) value16 * AP0_TIME_RANGE) / 1000; |
| 1408 | /*lint -e{702} shift for performance */ |
| 1409 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1410 | if (temp > maxSamples) |
| 1411 | temp = maxSamples; |
| 1412 | pReverb->m_sAp0.m_zApOut = (uint16_t) (pReverb->m_sAp0.m_zApIn + temp); |
| 1413 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1414 | ALOGV("REVERB_PARAM_DENSITY, Ap0 delay smps %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1415 | |
| 1416 | temp = AP1_TIME_BASE + ((int32_t) value16 * AP1_TIME_RANGE) / 1000; |
| 1417 | /*lint -e{702} shift for performance */ |
| 1418 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1419 | if (temp > maxSamples) |
| 1420 | temp = maxSamples; |
| 1421 | pReverb->m_sAp1.m_zApOut = (uint16_t) (pReverb->m_sAp1.m_zApIn + temp); |
| 1422 | |
Steve Block | 3856b09 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 1423 | ALOGV("Ap1 delay smps %d", temp); |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1424 | |
| 1425 | break; |
| 1426 | |
| 1427 | default: |
| 1428 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1429 | } |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1430 | } |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 1431 | |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1432 | return 0; |
| 1433 | } /* end Reverb_setParameter */ |
| 1434 | |
| 1435 | /*---------------------------------------------------------------------------- |
| 1436 | * ReverbUpdateXfade |
| 1437 | *---------------------------------------------------------------------------- |
| 1438 | * Purpose: |
| 1439 | * Update the xfade parameters as required |
| 1440 | * |
| 1441 | * Inputs: |
| 1442 | * nNumSamplesToAdd - number of samples to write to buffer |
| 1443 | * |
| 1444 | * Outputs: |
| 1445 | * |
| 1446 | * |
| 1447 | * Side Effects: |
| 1448 | * - xfade parameters will be changed |
| 1449 | * |
| 1450 | *---------------------------------------------------------------------------- |
| 1451 | */ |
| 1452 | static int ReverbUpdateXfade(reverb_object_t *pReverb, int nNumSamplesToAdd) { |
| 1453 | uint16_t nOffset; |
| 1454 | int16_t tempCos; |
| 1455 | int16_t tempSin; |
| 1456 | |
| 1457 | if (pReverb->m_nXfadeCounter >= pReverb->m_nXfadeInterval) { |
| 1458 | /* update interval has elapsed, so reset counter */ |
| 1459 | pReverb->m_nXfadeCounter = 0; |
| 1460 | |
| 1461 | // Pin the sin,cos values to min / max values to ensure that the |
| 1462 | // modulated taps' coefs are zero (thus no clicks) |
| 1463 | if (pReverb->m_nPhaseIncrement > 0) { |
| 1464 | // if phase increment > 0, then sin -> 1, cos -> 0 |
| 1465 | pReverb->m_nSin = 32767; |
| 1466 | pReverb->m_nCos = 0; |
| 1467 | |
| 1468 | // reset the phase to match the sin, cos values |
| 1469 | pReverb->m_nPhase = 32767; |
| 1470 | |
| 1471 | // modulate the cross taps because their tap coefs are zero |
| 1472 | nOffset = ReverbCalculateNoise(pReverb); |
| 1473 | |
| 1474 | pReverb->m_zD1Cross = pReverb->m_nDelay1Out |
| 1475 | - pReverb->m_nMaxExcursion + nOffset; |
| 1476 | |
| 1477 | nOffset = ReverbCalculateNoise(pReverb); |
| 1478 | |
| 1479 | pReverb->m_zD0Cross = pReverb->m_nDelay0Out |
| 1480 | - pReverb->m_nMaxExcursion - nOffset; |
| 1481 | } else { |
| 1482 | // if phase increment < 0, then sin -> 0, cos -> 1 |
| 1483 | pReverb->m_nSin = 0; |
| 1484 | pReverb->m_nCos = 32767; |
| 1485 | |
| 1486 | // reset the phase to match the sin, cos values |
| 1487 | pReverb->m_nPhase = -32768; |
| 1488 | |
| 1489 | // modulate the self taps because their tap coefs are zero |
| 1490 | nOffset = ReverbCalculateNoise(pReverb); |
| 1491 | |
| 1492 | pReverb->m_zD0Self = pReverb->m_nDelay0Out |
| 1493 | - pReverb->m_nMaxExcursion - nOffset; |
| 1494 | |
| 1495 | nOffset = ReverbCalculateNoise(pReverb); |
| 1496 | |
| 1497 | pReverb->m_zD1Self = pReverb->m_nDelay1Out |
| 1498 | - pReverb->m_nMaxExcursion + nOffset; |
| 1499 | |
| 1500 | } // end if-else (pReverb->m_nPhaseIncrement > 0) |
| 1501 | |
| 1502 | // Reverse the direction of the sin,cos so that the |
| 1503 | // tap whose coef was previously increasing now decreases |
| 1504 | // and vice versa |
| 1505 | pReverb->m_nPhaseIncrement = -pReverb->m_nPhaseIncrement; |
| 1506 | |
| 1507 | } // end if counter >= update interval |
| 1508 | |
| 1509 | //compute what phase will be next time |
| 1510 | pReverb->m_nPhase += pReverb->m_nPhaseIncrement; |
| 1511 | |
| 1512 | //calculate what the new sin and cos need to reach by the next update |
| 1513 | ReverbCalculateSinCos(pReverb->m_nPhase, &tempSin, &tempCos); |
| 1514 | |
| 1515 | //calculate the per-sample increment required to get there by the next update |
| 1516 | /*lint -e{702} shift for performance */ |
| 1517 | pReverb->m_nSinIncrement = (tempSin - pReverb->m_nSin) |
| 1518 | >> pReverb->m_nUpdatePeriodInBits; |
| 1519 | |
| 1520 | /*lint -e{702} shift for performance */ |
| 1521 | pReverb->m_nCosIncrement = (tempCos - pReverb->m_nCos) |
| 1522 | >> pReverb->m_nUpdatePeriodInBits; |
| 1523 | |
| 1524 | /* increment update counter */ |
| 1525 | pReverb->m_nXfadeCounter += (uint16_t) nNumSamplesToAdd; |
| 1526 | |
| 1527 | return 0; |
| 1528 | |
| 1529 | } /* end ReverbUpdateXfade */ |
| 1530 | |
| 1531 | /*---------------------------------------------------------------------------- |
| 1532 | * ReverbCalculateNoise |
| 1533 | *---------------------------------------------------------------------------- |
| 1534 | * Purpose: |
| 1535 | * Calculate a noise sample and limit its value |
| 1536 | * |
| 1537 | * Inputs: |
| 1538 | * nMaxExcursion - noise value is limited to this value |
| 1539 | * pnNoise - return new noise sample in this (not limited) |
| 1540 | * |
| 1541 | * Outputs: |
| 1542 | * new limited noise value |
| 1543 | * |
| 1544 | * Side Effects: |
| 1545 | * - *pnNoise noise value is updated |
| 1546 | * |
| 1547 | *---------------------------------------------------------------------------- |
| 1548 | */ |
| 1549 | static uint16_t ReverbCalculateNoise(reverb_object_t *pReverb) { |
| 1550 | int16_t nNoise = pReverb->m_nNoise; |
| 1551 | |
| 1552 | // calculate new noise value |
| 1553 | if (pReverb->m_bUseNoise) { |
| 1554 | nNoise = (int16_t) (nNoise * 5 + 1); |
| 1555 | } else { |
| 1556 | nNoise = 0; |
| 1557 | } |
| 1558 | |
| 1559 | pReverb->m_nNoise = nNoise; |
| 1560 | // return the limited noise value |
| 1561 | return (pReverb->m_nMaxExcursion & nNoise); |
| 1562 | |
| 1563 | } /* end ReverbCalculateNoise */ |
| 1564 | |
| 1565 | /*---------------------------------------------------------------------------- |
| 1566 | * ReverbCalculateSinCos |
| 1567 | *---------------------------------------------------------------------------- |
| 1568 | * Purpose: |
| 1569 | * Calculate a new sin and cosine value based on the given phase |
| 1570 | * |
| 1571 | * Inputs: |
| 1572 | * nPhase - phase angle |
| 1573 | * pnSin - input old value, output new value |
| 1574 | * pnCos - input old value, output new value |
| 1575 | * |
| 1576 | * Outputs: |
| 1577 | * |
| 1578 | * Side Effects: |
| 1579 | * - *pnSin, *pnCos are updated |
| 1580 | * |
| 1581 | *---------------------------------------------------------------------------- |
| 1582 | */ |
| 1583 | static int ReverbCalculateSinCos(int16_t nPhase, int16_t *pnSin, int16_t *pnCos) { |
| 1584 | int32_t nTemp; |
| 1585 | int32_t nNetAngle; |
| 1586 | |
| 1587 | // -1 <= nPhase < 1 |
| 1588 | // However, for the calculation, we need a value |
| 1589 | // that ranges from -1/2 to +1/2, so divide the phase by 2 |
| 1590 | /*lint -e{702} shift for performance */ |
| 1591 | nNetAngle = nPhase >> 1; |
| 1592 | |
| 1593 | /* |
| 1594 | Implement the following |
| 1595 | sin(x) = (2-4*c)*x^2 + c + x |
| 1596 | cos(x) = (2-4*c)*x^2 + c - x |
| 1597 | |
| 1598 | where c = 1/sqrt(2) |
| 1599 | using the a0 + x*(a1 + x*a2) approach |
| 1600 | */ |
| 1601 | |
| 1602 | /* limit the input "angle" to be between -0.5 and +0.5 */ |
| 1603 | if (nNetAngle > EG1_HALF) { |
| 1604 | nNetAngle = EG1_HALF; |
| 1605 | } else if (nNetAngle < EG1_MINUS_HALF) { |
| 1606 | nNetAngle = EG1_MINUS_HALF; |
| 1607 | } |
| 1608 | |
| 1609 | /* calculate sin */ |
| 1610 | nTemp = EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle); |
| 1611 | nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle); |
| 1612 | *pnSin = (int16_t) SATURATE_EG1(nTemp); |
| 1613 | |
| 1614 | /* calculate cos */ |
| 1615 | nTemp = -EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle); |
| 1616 | nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle); |
| 1617 | *pnCos = (int16_t) SATURATE_EG1(nTemp); |
| 1618 | |
| 1619 | return 0; |
| 1620 | } /* end ReverbCalculateSinCos */ |
| 1621 | |
| 1622 | /*---------------------------------------------------------------------------- |
| 1623 | * Reverb |
| 1624 | *---------------------------------------------------------------------------- |
| 1625 | * Purpose: |
| 1626 | * apply reverb to the given signal |
| 1627 | * |
| 1628 | * Inputs: |
| 1629 | * nNu |
| 1630 | * pnSin - input old value, output new value |
| 1631 | * pnCos - input old value, output new value |
| 1632 | * |
| 1633 | * Outputs: |
| 1634 | * number of samples actually reverberated |
| 1635 | * |
| 1636 | * Side Effects: |
| 1637 | * |
| 1638 | *---------------------------------------------------------------------------- |
| 1639 | */ |
| 1640 | static int Reverb(reverb_object_t *pReverb, int nNumSamplesToAdd, |
| 1641 | short *pOutputBuffer, short *pInputBuffer) { |
| 1642 | int32_t i; |
| 1643 | int32_t nDelayOut0; |
| 1644 | int32_t nDelayOut1; |
| 1645 | uint16_t nBase; |
| 1646 | |
| 1647 | uint32_t nAddr; |
| 1648 | int32_t nTemp1; |
| 1649 | int32_t nTemp2; |
| 1650 | int32_t nApIn; |
| 1651 | int32_t nApOut; |
| 1652 | |
| 1653 | int32_t j; |
| 1654 | int32_t nEarlyOut; |
| 1655 | |
| 1656 | int32_t tempValue; |
| 1657 | |
| 1658 | // get the base address |
| 1659 | nBase = pReverb->m_nBaseIndex; |
| 1660 | |
| 1661 | for (i = 0; i < nNumSamplesToAdd; i++) { |
| 1662 | // ********** Left Allpass - start |
| 1663 | nApIn = *pInputBuffer; |
| 1664 | if (!pReverb->m_Aux) { |
| 1665 | pInputBuffer++; |
| 1666 | } |
| 1667 | // store to early delay line |
| 1668 | nAddr = CIRCULAR(nBase, pReverb->m_nEarly0in, pReverb->m_nBufferMask); |
| 1669 | pReverb->m_nDelayLine[nAddr] = (short) nApIn; |
| 1670 | |
| 1671 | // left input = (left dry * m_nLateGain) + right feedback from previous period |
| 1672 | |
| 1673 | nApIn = SATURATE(nApIn + pReverb->m_nRevFbkR); |
| 1674 | nApIn = MULT_EG1_EG1(nApIn, pReverb->m_nLateGain); |
| 1675 | |
| 1676 | // fetch allpass delay line out |
| 1677 | //nAddr = CIRCULAR(nBase, psAp0->m_zApOut, pReverb->m_nBufferMask); |
| 1678 | nAddr |
| 1679 | = CIRCULAR(nBase, pReverb->m_sAp0.m_zApOut, pReverb->m_nBufferMask); |
| 1680 | nDelayOut0 = pReverb->m_nDelayLine[nAddr]; |
| 1681 | |
| 1682 | // calculate allpass feedforward; subtract the feedforward result |
| 1683 | nTemp1 = MULT_EG1_EG1(nApIn, pReverb->m_sAp0.m_nApGain); |
| 1684 | nApOut = SATURATE(nDelayOut0 - nTemp1); // allpass output |
| 1685 | |
| 1686 | // calculate allpass feedback; add the feedback result |
| 1687 | nTemp1 = MULT_EG1_EG1(nApOut, pReverb->m_sAp0.m_nApGain); |
| 1688 | nTemp1 = SATURATE(nApIn + nTemp1); |
| 1689 | |
| 1690 | // inject into allpass delay |
| 1691 | nAddr |
| 1692 | = CIRCULAR(nBase, pReverb->m_sAp0.m_zApIn, pReverb->m_nBufferMask); |
| 1693 | pReverb->m_nDelayLine[nAddr] = (short) nTemp1; |
| 1694 | |
| 1695 | // inject allpass output into delay line |
| 1696 | nAddr = CIRCULAR(nBase, pReverb->m_zD0In, pReverb->m_nBufferMask); |
| 1697 | pReverb->m_nDelayLine[nAddr] = (short) nApOut; |
| 1698 | |
| 1699 | // ********** Left Allpass - end |
| 1700 | |
| 1701 | // ********** Right Allpass - start |
| 1702 | nApIn = (*pInputBuffer++); |
| 1703 | // store to early delay line |
| 1704 | nAddr = CIRCULAR(nBase, pReverb->m_nEarly1in, pReverb->m_nBufferMask); |
| 1705 | pReverb->m_nDelayLine[nAddr] = (short) nApIn; |
| 1706 | |
| 1707 | // right input = (right dry * m_nLateGain) + left feedback from previous period |
| 1708 | /*lint -e{702} use shift for performance */ |
| 1709 | nApIn = SATURATE(nApIn + pReverb->m_nRevFbkL); |
| 1710 | nApIn = MULT_EG1_EG1(nApIn, pReverb->m_nLateGain); |
| 1711 | |
| 1712 | // fetch allpass delay line out |
| 1713 | nAddr |
| 1714 | = CIRCULAR(nBase, pReverb->m_sAp1.m_zApOut, pReverb->m_nBufferMask); |
| 1715 | nDelayOut1 = pReverb->m_nDelayLine[nAddr]; |
| 1716 | |
| 1717 | // calculate allpass feedforward; subtract the feedforward result |
| 1718 | nTemp1 = MULT_EG1_EG1(nApIn, pReverb->m_sAp1.m_nApGain); |
| 1719 | nApOut = SATURATE(nDelayOut1 - nTemp1); // allpass output |
| 1720 | |
| 1721 | // calculate allpass feedback; add the feedback result |
| 1722 | nTemp1 = MULT_EG1_EG1(nApOut, pReverb->m_sAp1.m_nApGain); |
| 1723 | nTemp1 = SATURATE(nApIn + nTemp1); |
| 1724 | |
| 1725 | // inject into allpass delay |
| 1726 | nAddr |
| 1727 | = CIRCULAR(nBase, pReverb->m_sAp1.m_zApIn, pReverb->m_nBufferMask); |
| 1728 | pReverb->m_nDelayLine[nAddr] = (short) nTemp1; |
| 1729 | |
| 1730 | // inject allpass output into delay line |
| 1731 | nAddr = CIRCULAR(nBase, pReverb->m_zD1In, pReverb->m_nBufferMask); |
| 1732 | pReverb->m_nDelayLine[nAddr] = (short) nApOut; |
| 1733 | |
| 1734 | // ********** Right Allpass - end |
| 1735 | |
| 1736 | // ********** D0 output - start |
| 1737 | // fetch delay line self out |
| 1738 | nAddr = CIRCULAR(nBase, pReverb->m_zD0Self, pReverb->m_nBufferMask); |
| 1739 | nDelayOut0 = pReverb->m_nDelayLine[nAddr]; |
| 1740 | |
| 1741 | // calculate delay line self out |
| 1742 | nTemp1 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nSin); |
| 1743 | |
| 1744 | // fetch delay line cross out |
| 1745 | nAddr = CIRCULAR(nBase, pReverb->m_zD1Cross, pReverb->m_nBufferMask); |
| 1746 | nDelayOut0 = pReverb->m_nDelayLine[nAddr]; |
| 1747 | |
| 1748 | // calculate delay line self out |
| 1749 | nTemp2 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nCos); |
| 1750 | |
| 1751 | // calculate unfiltered delay out |
| 1752 | nDelayOut0 = SATURATE(nTemp1 + nTemp2); |
| 1753 | |
| 1754 | // ********** D0 output - end |
| 1755 | |
| 1756 | // ********** D1 output - start |
| 1757 | // fetch delay line self out |
| 1758 | nAddr = CIRCULAR(nBase, pReverb->m_zD1Self, pReverb->m_nBufferMask); |
| 1759 | nDelayOut1 = pReverb->m_nDelayLine[nAddr]; |
| 1760 | |
| 1761 | // calculate delay line self out |
| 1762 | nTemp1 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nSin); |
| 1763 | |
| 1764 | // fetch delay line cross out |
| 1765 | nAddr = CIRCULAR(nBase, pReverb->m_zD0Cross, pReverb->m_nBufferMask); |
| 1766 | nDelayOut1 = pReverb->m_nDelayLine[nAddr]; |
| 1767 | |
| 1768 | // calculate delay line self out |
| 1769 | nTemp2 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nCos); |
| 1770 | |
| 1771 | // calculate unfiltered delay out |
| 1772 | nDelayOut1 = SATURATE(nTemp1 + nTemp2); |
| 1773 | |
| 1774 | // ********** D1 output - end |
| 1775 | |
| 1776 | // ********** mixer and feedback - start |
| 1777 | // sum is fedback to right input (R + L) |
| 1778 | nDelayOut0 = (short) SATURATE(nDelayOut0 + nDelayOut1); |
| 1779 | |
| 1780 | // difference is feedback to left input (R - L) |
| 1781 | /*lint -e{685} lint complains that it can't saturate negative */ |
| 1782 | nDelayOut1 = (short) SATURATE(nDelayOut1 - nDelayOut0); |
| 1783 | |
| 1784 | // ********** mixer and feedback - end |
| 1785 | |
| 1786 | // calculate lowpass filter (mixer scale factor included in LPF feedforward) |
| 1787 | nTemp1 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nRvbLpfFwd); |
| 1788 | |
| 1789 | nTemp2 = MULT_EG1_EG1(pReverb->m_nRevFbkL, pReverb->m_nRvbLpfFbk); |
| 1790 | |
| 1791 | // calculate filtered delay out and simultaneously update LPF state variable |
| 1792 | // filtered delay output is stored in m_nRevFbkL |
| 1793 | pReverb->m_nRevFbkL = (short) SATURATE(nTemp1 + nTemp2); |
| 1794 | |
| 1795 | // calculate lowpass filter (mixer scale factor included in LPF feedforward) |
| 1796 | nTemp1 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nRvbLpfFwd); |
| 1797 | |
| 1798 | nTemp2 = MULT_EG1_EG1(pReverb->m_nRevFbkR, pReverb->m_nRvbLpfFbk); |
| 1799 | |
| 1800 | // calculate filtered delay out and simultaneously update LPF state variable |
| 1801 | // filtered delay output is stored in m_nRevFbkR |
| 1802 | pReverb->m_nRevFbkR = (short) SATURATE(nTemp1 + nTemp2); |
| 1803 | |
| 1804 | // ********** start early reflection generator, left |
| 1805 | //psEarly = &(pReverb->m_sEarlyL); |
| 1806 | |
| 1807 | |
| 1808 | for (j = 0; j < REVERB_MAX_NUM_REFLECTIONS; j++) { |
| 1809 | // fetch delay line out |
| 1810 | //nAddr = CIRCULAR(nBase, psEarly->m_zDelay[j], pReverb->m_nBufferMask); |
| 1811 | nAddr |
| 1812 | = CIRCULAR(nBase, pReverb->m_sEarlyL.m_zDelay[j], pReverb->m_nBufferMask); |
| 1813 | |
| 1814 | nTemp1 = pReverb->m_nDelayLine[nAddr]; |
| 1815 | |
| 1816 | // calculate reflection |
| 1817 | //nTemp1 = MULT_EG1_EG1(nDelayOut0, psEarly->m_nGain[j]); |
| 1818 | nTemp1 = MULT_EG1_EG1(nTemp1, pReverb->m_sEarlyL.m_nGain[j]); |
| 1819 | |
| 1820 | nDelayOut0 = SATURATE(nDelayOut0 + nTemp1); |
| 1821 | |
| 1822 | } // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++) |
| 1823 | |
| 1824 | // apply lowpass to early reflections and reverb output |
| 1825 | //nTemp1 = MULT_EG1_EG1(nEarlyOut, psEarly->m_nRvbLpfFwd); |
| 1826 | nTemp1 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nRoomLpfFwd); |
| 1827 | |
| 1828 | //nTemp2 = MULT_EG1_EG1(psEarly->m_zLpf, psEarly->m_nLpfFbk); |
| 1829 | nTemp2 = MULT_EG1_EG1(pReverb->m_zOutLpfL, pReverb->m_nRoomLpfFbk); |
| 1830 | |
| 1831 | // calculate filtered out and simultaneously update LPF state variable |
| 1832 | // filtered output is stored in m_zOutLpfL |
| 1833 | pReverb->m_zOutLpfL = (short) SATURATE(nTemp1 + nTemp2); |
| 1834 | |
| 1835 | //sum with output buffer |
| 1836 | tempValue = *pOutputBuffer; |
| 1837 | *pOutputBuffer++ = (short) SATURATE(tempValue+pReverb->m_zOutLpfL); |
| 1838 | |
| 1839 | // ********** end early reflection generator, left |
| 1840 | |
| 1841 | // ********** start early reflection generator, right |
| 1842 | //psEarly = &(pReverb->m_sEarlyR); |
| 1843 | |
| 1844 | for (j = 0; j < REVERB_MAX_NUM_REFLECTIONS; j++) { |
| 1845 | // fetch delay line out |
| 1846 | nAddr |
| 1847 | = CIRCULAR(nBase, pReverb->m_sEarlyR.m_zDelay[j], pReverb->m_nBufferMask); |
| 1848 | nTemp1 = pReverb->m_nDelayLine[nAddr]; |
| 1849 | |
| 1850 | // calculate reflection |
| 1851 | nTemp1 = MULT_EG1_EG1(nTemp1, pReverb->m_sEarlyR.m_nGain[j]); |
| 1852 | |
| 1853 | nDelayOut1 = SATURATE(nDelayOut1 + nTemp1); |
| 1854 | |
| 1855 | } // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++) |
| 1856 | |
| 1857 | // apply lowpass to early reflections |
| 1858 | nTemp1 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nRoomLpfFwd); |
| 1859 | |
| 1860 | nTemp2 = MULT_EG1_EG1(pReverb->m_zOutLpfR, pReverb->m_nRoomLpfFbk); |
| 1861 | |
| 1862 | // calculate filtered out and simultaneously update LPF state variable |
| 1863 | // filtered output is stored in m_zOutLpfR |
| 1864 | pReverb->m_zOutLpfR = (short) SATURATE(nTemp1 + nTemp2); |
| 1865 | |
| 1866 | //sum with output buffer |
| 1867 | tempValue = *pOutputBuffer; |
| 1868 | *pOutputBuffer++ = (short) SATURATE(tempValue + pReverb->m_zOutLpfR); |
| 1869 | |
| 1870 | // ********** end early reflection generator, right |
| 1871 | |
| 1872 | // decrement base addr for next sample period |
| 1873 | nBase--; |
| 1874 | |
| 1875 | pReverb->m_nSin += pReverb->m_nSinIncrement; |
| 1876 | pReverb->m_nCos += pReverb->m_nCosIncrement; |
| 1877 | |
| 1878 | } // end for (i=0; i < nNumSamplesToAdd; i++) |
| 1879 | |
| 1880 | // store the most up to date version |
| 1881 | pReverb->m_nBaseIndex = nBase; |
| 1882 | |
| 1883 | return 0; |
| 1884 | } /* end Reverb */ |
| 1885 | |
| 1886 | /*---------------------------------------------------------------------------- |
| 1887 | * ReverbUpdateRoom |
| 1888 | *---------------------------------------------------------------------------- |
| 1889 | * Purpose: |
| 1890 | * Update the room's preset parameters as required |
| 1891 | * |
| 1892 | * Inputs: |
| 1893 | * |
| 1894 | * Outputs: |
| 1895 | * |
| 1896 | * |
| 1897 | * Side Effects: |
| 1898 | * - reverb paramters (fbk, fwd, etc) will be changed |
| 1899 | * - m_nCurrentRoom := m_nNextRoom |
| 1900 | *---------------------------------------------------------------------------- |
| 1901 | */ |
| 1902 | static int ReverbUpdateRoom(reverb_object_t *pReverb, bool fullUpdate) { |
| 1903 | int temp; |
| 1904 | int i; |
| 1905 | int maxSamples; |
| 1906 | int earlyDelay; |
| 1907 | int earlyGain; |
| 1908 | |
| 1909 | reverb_preset_t *pPreset = |
| 1910 | &pReverb->m_sPreset.m_sPreset[pReverb->m_nNextRoom]; |
| 1911 | |
| 1912 | if (fullUpdate) { |
| 1913 | pReverb->m_nRvbLpfFwd = pPreset->m_nRvbLpfFwd; |
| 1914 | pReverb->m_nRvbLpfFbk = pPreset->m_nRvbLpfFbk; |
| 1915 | |
| 1916 | pReverb->m_nEarlyGain = pPreset->m_nEarlyGain; |
| 1917 | //stored as time based, convert to sample based |
| 1918 | pReverb->m_nLateGain = pPreset->m_nLateGain; |
| 1919 | pReverb->m_nRoomLpfFbk = pPreset->m_nRoomLpfFbk; |
| 1920 | pReverb->m_nRoomLpfFwd = pPreset->m_nRoomLpfFwd; |
| 1921 | |
| 1922 | // set the early reflections gains |
| 1923 | earlyGain = pPreset->m_nEarlyGain; |
| 1924 | for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) { |
| 1925 | pReverb->m_sEarlyL.m_nGain[i] |
| 1926 | = MULT_EG1_EG1(pPreset->m_sEarlyL.m_nGain[i],earlyGain); |
| 1927 | pReverb->m_sEarlyR.m_nGain[i] |
| 1928 | = MULT_EG1_EG1(pPreset->m_sEarlyR.m_nGain[i],earlyGain); |
| 1929 | } |
| 1930 | |
| 1931 | pReverb->m_nMaxExcursion = pPreset->m_nMaxExcursion; |
| 1932 | |
| 1933 | pReverb->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain; |
| 1934 | pReverb->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain; |
| 1935 | |
| 1936 | // set the early reflections delay |
| 1937 | earlyDelay = ((int) pPreset->m_nEarlyDelay * pReverb->m_nSamplingRate) |
| 1938 | >> 16; |
| 1939 | pReverb->m_nEarlyDelay = earlyDelay; |
| 1940 | maxSamples = (int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate) |
| 1941 | >> 16; |
| 1942 | for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) { |
| 1943 | //stored as time based, convert to sample based |
| 1944 | temp = earlyDelay + (((int) pPreset->m_sEarlyL.m_zDelay[i] |
| 1945 | * pReverb->m_nSamplingRate) >> 16); |
| 1946 | if (temp > maxSamples) |
| 1947 | temp = maxSamples; |
| 1948 | pReverb->m_sEarlyL.m_zDelay[i] = pReverb->m_nEarly0in + temp; |
| 1949 | //stored as time based, convert to sample based |
| 1950 | temp = earlyDelay + (((int) pPreset->m_sEarlyR.m_zDelay[i] |
| 1951 | * pReverb->m_nSamplingRate) >> 16); |
| 1952 | if (temp > maxSamples) |
| 1953 | temp = maxSamples; |
| 1954 | pReverb->m_sEarlyR.m_zDelay[i] = pReverb->m_nEarly1in + temp; |
| 1955 | } |
| 1956 | |
| 1957 | maxSamples = (int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate) |
| 1958 | >> 16; |
| 1959 | //stored as time based, convert to sample based |
| 1960 | /*lint -e{702} shift for performance */ |
| 1961 | temp = (pPreset->m_nLateDelay * pReverb->m_nSamplingRate) >> 16; |
| 1962 | if ((temp + pReverb->m_nMaxExcursion) > maxSamples) { |
| 1963 | temp = maxSamples - pReverb->m_nMaxExcursion; |
| 1964 | } |
| 1965 | temp -= pReverb->m_nLateDelay; |
| 1966 | pReverb->m_nDelay0Out += temp; |
| 1967 | pReverb->m_nDelay1Out += temp; |
| 1968 | pReverb->m_nLateDelay += temp; |
| 1969 | |
| 1970 | maxSamples = (int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16; |
| 1971 | //stored as time based, convert to absolute sample value |
| 1972 | temp = pPreset->m_nAp0_ApOut; |
| 1973 | /*lint -e{702} shift for performance */ |
| 1974 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1975 | if (temp > maxSamples) |
| 1976 | temp = maxSamples; |
| 1977 | pReverb->m_sAp0.m_zApOut = (uint16_t) (pReverb->m_sAp0.m_zApIn + temp); |
| 1978 | |
| 1979 | //stored as time based, convert to absolute sample value |
| 1980 | temp = pPreset->m_nAp1_ApOut; |
| 1981 | /*lint -e{702} shift for performance */ |
| 1982 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1983 | if (temp > maxSamples) |
| 1984 | temp = maxSamples; |
| 1985 | pReverb->m_sAp1.m_zApOut = (uint16_t) (pReverb->m_sAp1.m_zApIn + temp); |
| 1986 | //gpsReverbObject->m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut; |
| 1987 | } |
| 1988 | |
| 1989 | //stored as time based, convert to sample based |
| 1990 | temp = pPreset->m_nXfadeInterval; |
| 1991 | /*lint -e{702} shift for performance */ |
| 1992 | temp = (temp * pReverb->m_nSamplingRate) >> 16; |
| 1993 | pReverb->m_nXfadeInterval = (uint16_t) temp; |
| 1994 | //gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval; |
| 1995 | pReverb->m_nXfadeCounter = pReverb->m_nXfadeInterval + 1; // force update on first iteration |
| 1996 | |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 1997 | pReverb->m_nCurrentRoom = pReverb->m_nNextRoom; |
| 1998 | |
| 1999 | return 0; |
| 2000 | |
| 2001 | } /* end ReverbUpdateRoom */ |
| 2002 | |
| 2003 | /*---------------------------------------------------------------------------- |
| 2004 | * ReverbReadInPresets() |
| 2005 | *---------------------------------------------------------------------------- |
| 2006 | * Purpose: sets global reverb preset bank to defaults |
| 2007 | * |
| 2008 | * Inputs: |
| 2009 | * |
| 2010 | * Outputs: |
| 2011 | * |
| 2012 | *---------------------------------------------------------------------------- |
| 2013 | */ |
| 2014 | static int ReverbReadInPresets(reverb_object_t *pReverb) { |
| 2015 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 2016 | int preset; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 2017 | |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 2018 | // this is for test only. OpenSL ES presets are mapped to 4 presets. |
| 2019 | // REVERB_PRESET_NONE is mapped to bypass |
| 2020 | for (preset = 0; preset < REVERB_NUM_PRESETS; preset++) { |
| 2021 | reverb_preset_t *pPreset = &pReverb->m_sPreset.m_sPreset[preset]; |
| 2022 | switch (preset + 1) { |
| 2023 | case REVERB_PRESET_PLATE: |
| 2024 | case REVERB_PRESET_SMALLROOM: |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 2025 | pPreset->m_nRvbLpfFbk = 5077; |
| 2026 | pPreset->m_nRvbLpfFwd = 11076; |
| 2027 | pPreset->m_nEarlyGain = 27690; |
| 2028 | pPreset->m_nEarlyDelay = 1311; |
| 2029 | pPreset->m_nLateGain = 8191; |
| 2030 | pPreset->m_nLateDelay = 3932; |
| 2031 | pPreset->m_nRoomLpfFbk = 3692; |
| 2032 | pPreset->m_nRoomLpfFwd = 20474; |
| 2033 | pPreset->m_sEarlyL.m_zDelay[0] = 1376; |
| 2034 | pPreset->m_sEarlyL.m_nGain[0] = 22152; |
| 2035 | pPreset->m_sEarlyL.m_zDelay[1] = 1462; |
| 2036 | pPreset->m_sEarlyL.m_nGain[1] = 17537; |
| 2037 | pPreset->m_sEarlyL.m_zDelay[2] = 0; |
| 2038 | pPreset->m_sEarlyL.m_nGain[2] = 14768; |
| 2039 | pPreset->m_sEarlyL.m_zDelay[3] = 1835; |
| 2040 | pPreset->m_sEarlyL.m_nGain[3] = 14307; |
| 2041 | pPreset->m_sEarlyL.m_zDelay[4] = 0; |
| 2042 | pPreset->m_sEarlyL.m_nGain[4] = 13384; |
| 2043 | pPreset->m_sEarlyR.m_zDelay[0] = 721; |
| 2044 | pPreset->m_sEarlyR.m_nGain[0] = 20306; |
| 2045 | pPreset->m_sEarlyR.m_zDelay[1] = 2621; |
| 2046 | pPreset->m_sEarlyR.m_nGain[1] = 17537; |
| 2047 | pPreset->m_sEarlyR.m_zDelay[2] = 0; |
| 2048 | pPreset->m_sEarlyR.m_nGain[2] = 14768; |
| 2049 | pPreset->m_sEarlyR.m_zDelay[3] = 0; |
| 2050 | pPreset->m_sEarlyR.m_nGain[3] = 16153; |
| 2051 | pPreset->m_sEarlyR.m_zDelay[4] = 0; |
| 2052 | pPreset->m_sEarlyR.m_nGain[4] = 13384; |
| 2053 | pPreset->m_nMaxExcursion = 127; |
| 2054 | pPreset->m_nXfadeInterval = 6470; //6483; |
| 2055 | pPreset->m_nAp0_ApGain = 14768; |
| 2056 | pPreset->m_nAp0_ApOut = 792; |
| 2057 | pPreset->m_nAp1_ApGain = 14777; |
| 2058 | pPreset->m_nAp1_ApOut = 1191; |
| 2059 | pPreset->m_rfu4 = 0; |
| 2060 | pPreset->m_rfu5 = 0; |
| 2061 | pPreset->m_rfu6 = 0; |
| 2062 | pPreset->m_rfu7 = 0; |
| 2063 | pPreset->m_rfu8 = 0; |
| 2064 | pPreset->m_rfu9 = 0; |
| 2065 | pPreset->m_rfu10 = 0; |
Eric Laurent | cb28102 | 2010-07-08 15:32:51 -0700 | [diff] [blame] | 2066 | break; |
| 2067 | case REVERB_PRESET_MEDIUMROOM: |
| 2068 | case REVERB_PRESET_LARGEROOM: |
| 2069 | pPreset->m_nRvbLpfFbk = 5077; |
| 2070 | pPreset->m_nRvbLpfFwd = 12922; |
| 2071 | pPreset->m_nEarlyGain = 27690; |
| 2072 | pPreset->m_nEarlyDelay = 1311; |
| 2073 | pPreset->m_nLateGain = 8191; |
| 2074 | pPreset->m_nLateDelay = 3932; |
| 2075 | pPreset->m_nRoomLpfFbk = 3692; |
| 2076 | pPreset->m_nRoomLpfFwd = 21703; |
| 2077 | pPreset->m_sEarlyL.m_zDelay[0] = 1376; |
| 2078 | pPreset->m_sEarlyL.m_nGain[0] = 22152; |
| 2079 | pPreset->m_sEarlyL.m_zDelay[1] = 1462; |
| 2080 | pPreset->m_sEarlyL.m_nGain[1] = 17537; |
| 2081 | pPreset->m_sEarlyL.m_zDelay[2] = 0; |
| 2082 | pPreset->m_sEarlyL.m_nGain[2] = 14768; |
| 2083 | pPreset->m_sEarlyL.m_zDelay[3] = 1835; |
| 2084 | pPreset->m_sEarlyL.m_nGain[3] = 14307; |
| 2085 | pPreset->m_sEarlyL.m_zDelay[4] = 0; |
| 2086 | pPreset->m_sEarlyL.m_nGain[4] = 13384; |
| 2087 | pPreset->m_sEarlyR.m_zDelay[0] = 721; |
| 2088 | pPreset->m_sEarlyR.m_nGain[0] = 20306; |
| 2089 | pPreset->m_sEarlyR.m_zDelay[1] = 2621; |
| 2090 | pPreset->m_sEarlyR.m_nGain[1] = 17537; |
| 2091 | pPreset->m_sEarlyR.m_zDelay[2] = 0; |
| 2092 | pPreset->m_sEarlyR.m_nGain[2] = 14768; |
| 2093 | pPreset->m_sEarlyR.m_zDelay[3] = 0; |
| 2094 | pPreset->m_sEarlyR.m_nGain[3] = 16153; |
| 2095 | pPreset->m_sEarlyR.m_zDelay[4] = 0; |
| 2096 | pPreset->m_sEarlyR.m_nGain[4] = 13384; |
| 2097 | pPreset->m_nMaxExcursion = 127; |
| 2098 | pPreset->m_nXfadeInterval = 6449; |
| 2099 | pPreset->m_nAp0_ApGain = 15691; |
| 2100 | pPreset->m_nAp0_ApOut = 774; |
| 2101 | pPreset->m_nAp1_ApGain = 16317; |
| 2102 | pPreset->m_nAp1_ApOut = 1155; |
| 2103 | pPreset->m_rfu4 = 0; |
| 2104 | pPreset->m_rfu5 = 0; |
| 2105 | pPreset->m_rfu6 = 0; |
| 2106 | pPreset->m_rfu7 = 0; |
| 2107 | pPreset->m_rfu8 = 0; |
| 2108 | pPreset->m_rfu9 = 0; |
| 2109 | pPreset->m_rfu10 = 0; |
| 2110 | break; |
| 2111 | case REVERB_PRESET_MEDIUMHALL: |
| 2112 | pPreset->m_nRvbLpfFbk = 6461; |
| 2113 | pPreset->m_nRvbLpfFwd = 14307; |
| 2114 | pPreset->m_nEarlyGain = 27690; |
| 2115 | pPreset->m_nEarlyDelay = 1311; |
| 2116 | pPreset->m_nLateGain = 8191; |
| 2117 | pPreset->m_nLateDelay = 3932; |
| 2118 | pPreset->m_nRoomLpfFbk = 3692; |
| 2119 | pPreset->m_nRoomLpfFwd = 24569; |
| 2120 | pPreset->m_sEarlyL.m_zDelay[0] = 1376; |
| 2121 | pPreset->m_sEarlyL.m_nGain[0] = 22152; |
| 2122 | pPreset->m_sEarlyL.m_zDelay[1] = 1462; |
| 2123 | pPreset->m_sEarlyL.m_nGain[1] = 17537; |
| 2124 | pPreset->m_sEarlyL.m_zDelay[2] = 0; |
| 2125 | pPreset->m_sEarlyL.m_nGain[2] = 14768; |
| 2126 | pPreset->m_sEarlyL.m_zDelay[3] = 1835; |
| 2127 | pPreset->m_sEarlyL.m_nGain[3] = 14307; |
| 2128 | pPreset->m_sEarlyL.m_zDelay[4] = 0; |
| 2129 | pPreset->m_sEarlyL.m_nGain[4] = 13384; |
| 2130 | pPreset->m_sEarlyR.m_zDelay[0] = 721; |
| 2131 | pPreset->m_sEarlyR.m_nGain[0] = 20306; |
| 2132 | pPreset->m_sEarlyR.m_zDelay[1] = 2621; |
| 2133 | pPreset->m_sEarlyR.m_nGain[1] = 17537; |
| 2134 | pPreset->m_sEarlyR.m_zDelay[2] = 0; |
| 2135 | pPreset->m_sEarlyR.m_nGain[2] = 14768; |
| 2136 | pPreset->m_sEarlyR.m_zDelay[3] = 0; |
| 2137 | pPreset->m_sEarlyR.m_nGain[3] = 16153; |
| 2138 | pPreset->m_sEarlyR.m_zDelay[4] = 0; |
| 2139 | pPreset->m_sEarlyR.m_nGain[4] = 13384; |
| 2140 | pPreset->m_nMaxExcursion = 127; |
| 2141 | pPreset->m_nXfadeInterval = 6391; |
| 2142 | pPreset->m_nAp0_ApGain = 15230; |
| 2143 | pPreset->m_nAp0_ApOut = 708; |
| 2144 | pPreset->m_nAp1_ApGain = 15547; |
| 2145 | pPreset->m_nAp1_ApOut = 1023; |
| 2146 | pPreset->m_rfu4 = 0; |
| 2147 | pPreset->m_rfu5 = 0; |
| 2148 | pPreset->m_rfu6 = 0; |
| 2149 | pPreset->m_rfu7 = 0; |
| 2150 | pPreset->m_rfu8 = 0; |
| 2151 | pPreset->m_rfu9 = 0; |
| 2152 | pPreset->m_rfu10 = 0; |
| 2153 | break; |
| 2154 | case REVERB_PRESET_LARGEHALL: |
| 2155 | pPreset->m_nRvbLpfFbk = 8307; |
| 2156 | pPreset->m_nRvbLpfFwd = 14768; |
| 2157 | pPreset->m_nEarlyGain = 27690; |
| 2158 | pPreset->m_nEarlyDelay = 1311; |
| 2159 | pPreset->m_nLateGain = 8191; |
| 2160 | pPreset->m_nLateDelay = 3932; |
| 2161 | pPreset->m_nRoomLpfFbk = 3692; |
| 2162 | pPreset->m_nRoomLpfFwd = 24569; |
| 2163 | pPreset->m_sEarlyL.m_zDelay[0] = 1376; |
| 2164 | pPreset->m_sEarlyL.m_nGain[0] = 22152; |
| 2165 | pPreset->m_sEarlyL.m_zDelay[1] = 2163; |
| 2166 | pPreset->m_sEarlyL.m_nGain[1] = 17537; |
| 2167 | pPreset->m_sEarlyL.m_zDelay[2] = 0; |
| 2168 | pPreset->m_sEarlyL.m_nGain[2] = 14768; |
| 2169 | pPreset->m_sEarlyL.m_zDelay[3] = 1835; |
| 2170 | pPreset->m_sEarlyL.m_nGain[3] = 14307; |
| 2171 | pPreset->m_sEarlyL.m_zDelay[4] = 0; |
| 2172 | pPreset->m_sEarlyL.m_nGain[4] = 13384; |
| 2173 | pPreset->m_sEarlyR.m_zDelay[0] = 721; |
| 2174 | pPreset->m_sEarlyR.m_nGain[0] = 20306; |
| 2175 | pPreset->m_sEarlyR.m_zDelay[1] = 2621; |
| 2176 | pPreset->m_sEarlyR.m_nGain[1] = 17537; |
| 2177 | pPreset->m_sEarlyR.m_zDelay[2] = 0; |
| 2178 | pPreset->m_sEarlyR.m_nGain[2] = 14768; |
| 2179 | pPreset->m_sEarlyR.m_zDelay[3] = 0; |
| 2180 | pPreset->m_sEarlyR.m_nGain[3] = 16153; |
| 2181 | pPreset->m_sEarlyR.m_zDelay[4] = 0; |
| 2182 | pPreset->m_sEarlyR.m_nGain[4] = 13384; |
| 2183 | pPreset->m_nMaxExcursion = 127; |
| 2184 | pPreset->m_nXfadeInterval = 6388; |
| 2185 | pPreset->m_nAp0_ApGain = 15691; |
| 2186 | pPreset->m_nAp0_ApOut = 711; |
| 2187 | pPreset->m_nAp1_ApGain = 16317; |
| 2188 | pPreset->m_nAp1_ApOut = 1029; |
| 2189 | pPreset->m_rfu4 = 0; |
| 2190 | pPreset->m_rfu5 = 0; |
| 2191 | pPreset->m_rfu6 = 0; |
| 2192 | pPreset->m_rfu7 = 0; |
| 2193 | pPreset->m_rfu8 = 0; |
| 2194 | pPreset->m_rfu9 = 0; |
| 2195 | pPreset->m_rfu10 = 0; |
| 2196 | break; |
Eric Laurent | 135ad07 | 2010-05-21 06:05:13 -0700 | [diff] [blame] | 2197 | } |
| 2198 | } |
| 2199 | |
| 2200 | return 0; |
| 2201 | } |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 2202 | |
| 2203 | audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = { |
| 2204 | .tag = AUDIO_EFFECT_LIBRARY_TAG, |
| 2205 | .version = EFFECT_LIBRARY_API_VERSION, |
| 2206 | .name = "Test Equalizer Library", |
| 2207 | .implementor = "The Android Open Source Project", |
Eric Laurent | e1315cf | 2011-05-17 19:16:02 -0700 | [diff] [blame] | 2208 | .create_effect = EffectCreate, |
| 2209 | .release_effect = EffectRelease, |
| 2210 | .get_descriptor = EffectGetDescriptor, |
| 2211 | }; |