1 /*
2 * Copyright (C) 2010-2010 NXP Software
3 * Copyright (C) 2009 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #define LOG_TAG "Reverb"
19 #define ARRAY_SIZE(array) (sizeof (array) / sizeof (array)[0])
20 //#define LOG_NDEBUG 0
21
22 #include <assert.h>
23 #include <inttypes.h>
24 #include <new>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include <log/log.h>
29
30 #include "EffectReverb.h"
31 // from Reverb/lib
32 #include "LVREV.h"
33
34 // effect_handle_t interface implementation for reverb
35 extern "C" const struct effect_interface_s gReverbInterface;
36
37 #define LVM_ERROR_CHECK(LvmStatus, callingFunc, calledFunc){\
38 if ((LvmStatus) == LVREV_NULLADDRESS){\
39 ALOGV("\tLVREV_ERROR : Parameter error - "\
40 "null pointer returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\
41 }\
42 if ((LvmStatus) == LVREV_INVALIDNUMSAMPLES){\
43 ALOGV("\tLVREV_ERROR : Parameter error - "\
44 "bad number of samples returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\
45 }\
46 if ((LvmStatus) == LVREV_OUTOFRANGE){\
47 ALOGV("\tLVREV_ERROR : Parameter error - "\
48 "out of range returned by %s in %s\n", callingFunc, calledFunc);\
49 }\
50 }
51
52 // Namespaces
53 namespace android {
54 namespace {
55
56 /************************************************************************************/
57 /* */
58 /* Preset definitions */
59 /* */
60 /************************************************************************************/
61
62 const static t_reverb_settings sReverbPresets[] = {
63 // REVERB_PRESET_NONE: values are unused
64 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
65 // REVERB_PRESET_SMALLROOM
66 {-400, -600, 1100, 830, -400, 5, 500, 10, 1000, 1000},
67 // REVERB_PRESET_MEDIUMROOM
68 {-400, -600, 1300, 830, -1000, 20, -200, 20, 1000, 1000},
69 // REVERB_PRESET_LARGEROOM
70 {-400, -600, 1500, 830, -1600, 5, -1000, 40, 1000, 1000},
71 // REVERB_PRESET_MEDIUMHALL
72 {-400, -600, 1800, 700, -1300, 15, -800, 30, 1000, 1000},
73 // REVERB_PRESET_LARGEHALL
74 {-400, -600, 1800, 700, -2000, 30, -1400, 60, 1000, 1000},
75 // REVERB_PRESET_PLATE
76 {-400, -200, 1300, 900, 0, 2, 0, 10, 1000, 750},
77 };
78
79
80 // NXP SW auxiliary environmental reverb
81 const effect_descriptor_t gAuxEnvReverbDescriptor = {
82 { 0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, { 0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e } },
83 { 0x4a387fc0, 0x8ab3, 0x11df, 0x8bad, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } },
84 EFFECT_CONTROL_API_VERSION,
85 EFFECT_FLAG_TYPE_AUXILIARY,
86 LVREV_CUP_LOAD_ARM9E,
87 LVREV_MEM_USAGE,
88 "Auxiliary Environmental Reverb",
89 "NXP Software Ltd.",
90 };
91
92 // NXP SW insert environmental reverb
93 static const effect_descriptor_t gInsertEnvReverbDescriptor = {
94 {0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}},
95 {0xc7a511a0, 0xa3bb, 0x11df, 0x860e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
96 EFFECT_CONTROL_API_VERSION,
97 EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST | EFFECT_FLAG_VOLUME_CTRL,
98 LVREV_CUP_LOAD_ARM9E,
99 LVREV_MEM_USAGE,
100 "Insert Environmental Reverb",
101 "NXP Software Ltd.",
102 };
103
104 // NXP SW auxiliary preset reverb
105 static const effect_descriptor_t gAuxPresetReverbDescriptor = {
106 {0x47382d60, 0xddd8, 0x11db, 0xbf3a, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
107 {0xf29a1400, 0xa3bb, 0x11df, 0x8ddc, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
108 EFFECT_CONTROL_API_VERSION,
109 EFFECT_FLAG_TYPE_AUXILIARY,
110 LVREV_CUP_LOAD_ARM9E,
111 LVREV_MEM_USAGE,
112 "Auxiliary Preset Reverb",
113 "NXP Software Ltd.",
114 };
115
116 // NXP SW insert preset reverb
117 static const effect_descriptor_t gInsertPresetReverbDescriptor = {
118 {0x47382d60, 0xddd8, 0x11db, 0xbf3a, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
119 {0x172cdf00, 0xa3bc, 0x11df, 0xa72f, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
120 EFFECT_CONTROL_API_VERSION,
121 EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST | EFFECT_FLAG_VOLUME_CTRL,
122 LVREV_CUP_LOAD_ARM9E,
123 LVREV_MEM_USAGE,
124 "Insert Preset Reverb",
125 "NXP Software Ltd.",
126 };
127
128 // gDescriptors contains pointers to all defined effect descriptor in this library
129 static const effect_descriptor_t * const gDescriptors[] = {
130 &gAuxEnvReverbDescriptor,
131 &gInsertEnvReverbDescriptor,
132 &gAuxPresetReverbDescriptor,
133 &gInsertPresetReverbDescriptor
134 };
135
136 struct ReverbContext{
137 const struct effect_interface_s *itfe;
138 effect_config_t config;
139 LVREV_Handle_t hInstance;
140 int16_t SavedRoomLevel;
141 int16_t SavedHfLevel;
142 int16_t SavedDecayTime;
143 int16_t SavedDecayHfRatio;
144 int16_t SavedReverbLevel;
145 int16_t SavedDiffusion;
146 int16_t SavedDensity;
147 bool bEnabled;
148 #ifdef LVM_PCM
149 FILE *PcmInPtr;
150 FILE *PcmOutPtr;
151 #endif
152 LVM_Fs_en SampleRate;
153 LVM_INT32 *InFrames32;
154 LVM_INT32 *OutFrames32;
155 bool auxiliary;
156 bool preset;
157 uint16_t curPreset;
158 uint16_t nextPreset;
159 int SamplesToExitCount;
160 LVM_INT16 leftVolume;
161 LVM_INT16 rightVolume;
162 LVM_INT16 prevLeftVolume;
163 LVM_INT16 prevRightVolume;
164 int volumeMode;
165 };
166
167 enum {
168 REVERB_VOLUME_OFF,
169 REVERB_VOLUME_FLAT,
170 REVERB_VOLUME_RAMP,
171 };
172
173 #define REVERB_DEFAULT_PRESET REVERB_PRESET_NONE
174
175
176 #define REVERB_SEND_LEVEL (0x0C00) // 0.75 in 4.12 format
177 #define REVERB_UNIT_VOLUME (0x1000) // 1.0 in 4.12 format
178
179 //--- local function prototypes
180 int Reverb_init (ReverbContext *pContext);
181 void Reverb_free (ReverbContext *pContext);
182 int Reverb_setConfig (ReverbContext *pContext, effect_config_t *pConfig);
183 void Reverb_getConfig (ReverbContext *pContext, effect_config_t *pConfig);
184 int Reverb_setParameter (ReverbContext *pContext, void *pParam, void *pValue, int vsize);
185 int Reverb_getParameter (ReverbContext *pContext,
186 void *pParam,
187 uint32_t *pValueSize,
188 void *pValue);
189 int Reverb_LoadPreset (ReverbContext *pContext);
190 int Reverb_paramValueSize (int32_t param);
191
192 /* Effect Library Interface Implementation */
193
EffectCreate(const effect_uuid_t * uuid,int32_t sessionId __unused,int32_t ioId __unused,effect_handle_t * pHandle)194 extern "C" int EffectCreate(const effect_uuid_t *uuid,
195 int32_t sessionId __unused,
196 int32_t ioId __unused,
197 effect_handle_t *pHandle){
198 int ret;
199 int i;
200 int length = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);
201 const effect_descriptor_t *desc;
202
203 ALOGV("\t\nEffectCreate start");
204
205 if (pHandle == NULL || uuid == NULL){
206 ALOGV("\tLVM_ERROR : EffectCreate() called with NULL pointer");
207 return -EINVAL;
208 }
209
210 for (i = 0; i < length; i++) {
211 desc = gDescriptors[i];
212 if (memcmp(uuid, &desc->uuid, sizeof(effect_uuid_t))
213 == 0) {
214 ALOGV("\tEffectCreate - UUID matched Reverb type %d, UUID = %x", i, desc->uuid.timeLow);
215 break;
216 }
217 }
218
219 if (i == length) {
220 return -ENOENT;
221 }
222
223 ReverbContext *pContext = new ReverbContext;
224
225 pContext->itfe = &gReverbInterface;
226 pContext->hInstance = NULL;
227
228 pContext->auxiliary = false;
229 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY){
230 pContext->auxiliary = true;
231 ALOGV("\tEffectCreate - AUX");
232 }else{
233 ALOGV("\tEffectCreate - INS");
234 }
235
236 pContext->preset = false;
237 if (memcmp(&desc->type, SL_IID_PRESETREVERB, sizeof(effect_uuid_t)) == 0) {
238 pContext->preset = true;
239 // force reloading preset at first call to process()
240 pContext->curPreset = REVERB_PRESET_LAST + 1;
241 pContext->nextPreset = REVERB_DEFAULT_PRESET;
242 ALOGV("\tEffectCreate - PRESET");
243 }else{
244 ALOGV("\tEffectCreate - ENVIRONMENTAL");
245 }
246
247 ALOGV("\tEffectCreate - Calling Reverb_init");
248 ret = Reverb_init(pContext);
249
250 if (ret < 0){
251 ALOGV("\tLVM_ERROR : EffectCreate() init failed");
252 delete pContext;
253 return ret;
254 }
255
256 *pHandle = (effect_handle_t)pContext;
257
258 #ifdef LVM_PCM
259 pContext->PcmInPtr = NULL;
260 pContext->PcmOutPtr = NULL;
261
262 pContext->PcmInPtr = fopen("/data/tmp/reverb_pcm_in.pcm", "w");
263 pContext->PcmOutPtr = fopen("/data/tmp/reverb_pcm_out.pcm", "w");
264
265 if((pContext->PcmInPtr == NULL)||
266 (pContext->PcmOutPtr == NULL)){
267 return -EINVAL;
268 }
269 #endif
270
271
272 // Allocate memory for reverb process (*2 is for STEREO)
273 pContext->InFrames32 = (LVM_INT32 *)malloc(LVREV_MAX_FRAME_SIZE * sizeof(LVM_INT32) * 2);
274 pContext->OutFrames32 = (LVM_INT32 *)malloc(LVREV_MAX_FRAME_SIZE * sizeof(LVM_INT32) * 2);
275
276 ALOGV("\tEffectCreate %p, size %zu", pContext, sizeof(ReverbContext));
277 ALOGV("\tEffectCreate end\n");
278 return 0;
279 } /* end EffectCreate */
280
EffectRelease(effect_handle_t handle)281 extern "C" int EffectRelease(effect_handle_t handle){
282 ReverbContext * pContext = (ReverbContext *)handle;
283
284 ALOGV("\tEffectRelease %p", handle);
285 if (pContext == NULL){
286 ALOGV("\tLVM_ERROR : EffectRelease called with NULL pointer");
287 return -EINVAL;
288 }
289
290 #ifdef LVM_PCM
291 fclose(pContext->PcmInPtr);
292 fclose(pContext->PcmOutPtr);
293 #endif
294 free(pContext->InFrames32);
295 free(pContext->OutFrames32);
296 Reverb_free(pContext);
297 delete pContext;
298 return 0;
299 } /* end EffectRelease */
300
EffectGetDescriptor(const effect_uuid_t * uuid,effect_descriptor_t * pDescriptor)301 extern "C" int EffectGetDescriptor(const effect_uuid_t *uuid,
302 effect_descriptor_t *pDescriptor) {
303 int i;
304 int length = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);
305
306 if (pDescriptor == NULL || uuid == NULL){
307 ALOGV("EffectGetDescriptor() called with NULL pointer");
308 return -EINVAL;
309 }
310
311 for (i = 0; i < length; i++) {
312 if (memcmp(uuid, &gDescriptors[i]->uuid, sizeof(effect_uuid_t)) == 0) {
313 *pDescriptor = *gDescriptors[i];
314 ALOGV("EffectGetDescriptor - UUID matched Reverb type %d, UUID = %x",
315 i, gDescriptors[i]->uuid.timeLow);
316 return 0;
317 }
318 }
319
320 return -EINVAL;
321 } /* end EffectGetDescriptor */
322
323 /* local functions */
324 #define CHECK_ARG(cond) { \
325 if (!(cond)) { \
326 ALOGV("\tLVM_ERROR : Invalid argument: "#cond); \
327 return -EINVAL; \
328 } \
329 }
330
331 #if 0
332 //----------------------------------------------------------------------------
333 // MonoTo2I_32()
334 //----------------------------------------------------------------------------
335 // Purpose:
336 // Convert MONO to STEREO
337 //
338 //----------------------------------------------------------------------------
339
340 void MonoTo2I_32( const LVM_INT32 *src,
341 LVM_INT32 *dst,
342 LVM_INT16 n)
343 {
344 LVM_INT16 ii;
345 src += (n-1);
346 dst += ((n*2)-1);
347
348 for (ii = n; ii != 0; ii--)
349 {
350 *dst = *src;
351 dst--;
352
353 *dst = *src;
354 dst--;
355 src--;
356 }
357
358 return;
359 }
360
361 //----------------------------------------------------------------------------
362 // From2iToMono_32()
363 //----------------------------------------------------------------------------
364 // Purpose:
365 // Convert STEREO to MONO
366 //
367 //----------------------------------------------------------------------------
368
369 void From2iToMono_32( const LVM_INT32 *src,
370 LVM_INT32 *dst,
371 LVM_INT16 n)
372 {
373 LVM_INT16 ii;
374 LVM_INT32 Temp;
375
376 for (ii = n; ii != 0; ii--)
377 {
378 Temp = (*src>>1);
379 src++;
380
381 Temp +=(*src>>1);
382 src++;
383
384 *dst = Temp;
385 dst++;
386 }
387
388 return;
389 }
390 #endif
391
clamp16(int32_t sample)392 static inline int16_t clamp16(int32_t sample)
393 {
394 if ((sample>>15) ^ (sample>>31))
395 sample = 0x7FFF ^ (sample>>31);
396 return sample;
397 }
398
399 //----------------------------------------------------------------------------
400 // process()
401 //----------------------------------------------------------------------------
402 // Purpose:
403 // Apply the Reverb
404 //
405 // Inputs:
406 // pIn: pointer to stereo/mono 16 bit input data
407 // pOut: pointer to stereo 16 bit output data
408 // frameCount: Frames to process
409 // pContext: effect engine context
410 // strength strength to be applied
411 //
412 // Outputs:
413 // pOut: pointer to updated stereo 16 bit output data
414 //
415 //----------------------------------------------------------------------------
416
process(LVM_INT16 * pIn,LVM_INT16 * pOut,int frameCount,ReverbContext * pContext)417 int process( LVM_INT16 *pIn,
418 LVM_INT16 *pOut,
419 int frameCount,
420 ReverbContext *pContext){
421
422 LVM_INT16 samplesPerFrame = 1;
423 LVREV_ReturnStatus_en LvmStatus = LVREV_SUCCESS; /* Function call status */
424 LVM_INT16 *OutFrames16;
425
426
427 // Check that the input is either mono or stereo
428 if (pContext->config.inputCfg.channels == AUDIO_CHANNEL_OUT_STEREO) {
429 samplesPerFrame = 2;
430 } else if (pContext->config.inputCfg.channels != AUDIO_CHANNEL_OUT_MONO) {
431 ALOGV("\tLVREV_ERROR : process invalid PCM format");
432 return -EINVAL;
433 }
434
435 OutFrames16 = (LVM_INT16 *)pContext->OutFrames32;
436
437 // Check for NULL pointers
438 if((pContext->InFrames32 == NULL)||(pContext->OutFrames32 == NULL)){
439 ALOGV("\tLVREV_ERROR : process failed to allocate memory for temporary buffers ");
440 return -EINVAL;
441 }
442
443 #ifdef LVM_PCM
444 fwrite(pIn, frameCount*sizeof(LVM_INT16)*samplesPerFrame, 1, pContext->PcmInPtr);
445 fflush(pContext->PcmInPtr);
446 #endif
447
448 if (pContext->preset && pContext->nextPreset != pContext->curPreset) {
449 Reverb_LoadPreset(pContext);
450 }
451
452
453
454 // Convert to Input 32 bits
455 if (pContext->auxiliary) {
456 for(int i=0; i<frameCount*samplesPerFrame; i++){
457 pContext->InFrames32[i] = (LVM_INT32)pIn[i]<<8;
458 }
459 } else {
460 // insert reverb input is always stereo
461 for (int i = 0; i < frameCount; i++) {
462 pContext->InFrames32[2*i] = (pIn[2*i] * REVERB_SEND_LEVEL) >> 4; // <<8 + >>12
463 pContext->InFrames32[2*i+1] = (pIn[2*i+1] * REVERB_SEND_LEVEL) >> 4; // <<8 + >>12
464 }
465 }
466
467 if (pContext->preset && pContext->curPreset == REVERB_PRESET_NONE) {
468 memset(pContext->OutFrames32, 0, frameCount * sizeof(LVM_INT32) * 2); //always stereo here
469 } else {
470 if(pContext->bEnabled == LVM_FALSE && pContext->SamplesToExitCount > 0) {
471 memset(pContext->InFrames32,0,frameCount * sizeof(LVM_INT32) * samplesPerFrame);
472 ALOGV("\tZeroing %d samples per frame at the end of call", samplesPerFrame);
473 }
474
475 /* Process the samples, producing a stereo output */
476 LvmStatus = LVREV_Process(pContext->hInstance, /* Instance handle */
477 pContext->InFrames32, /* Input buffer */
478 pContext->OutFrames32, /* Output buffer */
479 frameCount); /* Number of samples to read */
480 }
481
482 LVM_ERROR_CHECK(LvmStatus, "LVREV_Process", "process")
483 if(LvmStatus != LVREV_SUCCESS) return -EINVAL;
484
485 // Convert to 16 bits
486 if (pContext->auxiliary) {
487 for (int i=0; i < frameCount*2; i++) { //always stereo here
488 OutFrames16[i] = clamp16(pContext->OutFrames32[i]>>8);
489 }
490 } else {
491 for (int i=0; i < frameCount*2; i++) { //always stereo here
492 OutFrames16[i] = clamp16((pContext->OutFrames32[i]>>8) + (LVM_INT32)pIn[i]);
493 }
494
495 // apply volume with ramp if needed
496 if ((pContext->leftVolume != pContext->prevLeftVolume ||
497 pContext->rightVolume != pContext->prevRightVolume) &&
498 pContext->volumeMode == REVERB_VOLUME_RAMP) {
499 LVM_INT32 vl = (LVM_INT32)pContext->prevLeftVolume << 16;
500 LVM_INT32 incl = (((LVM_INT32)pContext->leftVolume << 16) - vl) / frameCount;
501 LVM_INT32 vr = (LVM_INT32)pContext->prevRightVolume << 16;
502 LVM_INT32 incr = (((LVM_INT32)pContext->rightVolume << 16) - vr) / frameCount;
503
504 for (int i = 0; i < frameCount; i++) {
505 OutFrames16[2*i] =
506 clamp16((LVM_INT32)((vl >> 16) * OutFrames16[2*i]) >> 12);
507 OutFrames16[2*i+1] =
508 clamp16((LVM_INT32)((vr >> 16) * OutFrames16[2*i+1]) >> 12);
509
510 vl += incl;
511 vr += incr;
512 }
513
514 pContext->prevLeftVolume = pContext->leftVolume;
515 pContext->prevRightVolume = pContext->rightVolume;
516 } else if (pContext->volumeMode != REVERB_VOLUME_OFF) {
517 if (pContext->leftVolume != REVERB_UNIT_VOLUME ||
518 pContext->rightVolume != REVERB_UNIT_VOLUME) {
519 for (int i = 0; i < frameCount; i++) {
520 OutFrames16[2*i] =
521 clamp16((LVM_INT32)(pContext->leftVolume * OutFrames16[2*i]) >> 12);
522 OutFrames16[2*i+1] =
523 clamp16((LVM_INT32)(pContext->rightVolume * OutFrames16[2*i+1]) >> 12);
524 }
525 }
526 pContext->prevLeftVolume = pContext->leftVolume;
527 pContext->prevRightVolume = pContext->rightVolume;
528 pContext->volumeMode = REVERB_VOLUME_RAMP;
529 }
530 }
531
532 #ifdef LVM_PCM
533 fwrite(OutFrames16, frameCount*sizeof(LVM_INT16)*2, 1, pContext->PcmOutPtr);
534 fflush(pContext->PcmOutPtr);
535 #endif
536
537 // Accumulate if required
538 if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE){
539 //ALOGV("\tBuffer access is ACCUMULATE");
540 for (int i=0; i<frameCount*2; i++){ //always stereo here
541 pOut[i] = clamp16((int32_t)pOut[i] + (int32_t)OutFrames16[i]);
542 }
543 }else{
544 //ALOGV("\tBuffer access is WRITE");
545 memcpy(pOut, OutFrames16, frameCount*sizeof(LVM_INT16)*2);
546 }
547
548 return 0;
549 } /* end process */
550
551 //----------------------------------------------------------------------------
552 // Reverb_free()
553 //----------------------------------------------------------------------------
554 // Purpose: Free all memory associated with the Bundle.
555 //
556 // Inputs:
557 // pContext: effect engine context
558 //
559 // Outputs:
560 //
561 //----------------------------------------------------------------------------
562
Reverb_free(ReverbContext * pContext)563 void Reverb_free(ReverbContext *pContext){
564
565 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
566 LVREV_MemoryTable_st MemTab;
567
568 /* Free the algorithm memory */
569 LvmStatus = LVREV_GetMemoryTable(pContext->hInstance,
570 &MemTab,
571 LVM_NULL);
572
573 LVM_ERROR_CHECK(LvmStatus, "LVM_GetMemoryTable", "Reverb_free")
574
575 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){
576 if (MemTab.Region[i].Size != 0){
577 if (MemTab.Region[i].pBaseAddress != NULL){
578 ALOGV("\tfree() - START freeing %" PRIu32 " bytes for region %u at %p\n",
579 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
580
581 free(MemTab.Region[i].pBaseAddress);
582
583 ALOGV("\tfree() - END freeing %" PRIu32 " bytes for region %u at %p\n",
584 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
585 }else{
586 ALOGV("\tLVM_ERROR : free() - trying to free with NULL pointer %" PRIu32 " bytes "
587 "for region %u at %p ERROR\n",
588 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
589 }
590 }
591 }
592 } /* end Reverb_free */
593
594 //----------------------------------------------------------------------------
595 // Reverb_setConfig()
596 //----------------------------------------------------------------------------
597 // Purpose: Set input and output audio configuration.
598 //
599 // Inputs:
600 // pContext: effect engine context
601 // pConfig: pointer to effect_config_t structure holding input and output
602 // configuration parameters
603 //
604 // Outputs:
605 //
606 //----------------------------------------------------------------------------
607
Reverb_setConfig(ReverbContext * pContext,effect_config_t * pConfig)608 int Reverb_setConfig(ReverbContext *pContext, effect_config_t *pConfig){
609 LVM_Fs_en SampleRate;
610 //ALOGV("\tReverb_setConfig start");
611
612 CHECK_ARG(pContext != NULL);
613 CHECK_ARG(pConfig != NULL);
614
615 CHECK_ARG(pConfig->inputCfg.samplingRate == pConfig->outputCfg.samplingRate);
616 CHECK_ARG(pConfig->inputCfg.format == pConfig->outputCfg.format);
617 CHECK_ARG((pContext->auxiliary && pConfig->inputCfg.channels == AUDIO_CHANNEL_OUT_MONO) ||
618 ((!pContext->auxiliary) && pConfig->inputCfg.channels == AUDIO_CHANNEL_OUT_STEREO));
619 CHECK_ARG(pConfig->outputCfg.channels == AUDIO_CHANNEL_OUT_STEREO);
620 CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE
621 || pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
622 CHECK_ARG(pConfig->inputCfg.format == AUDIO_FORMAT_PCM_16_BIT);
623
624 //ALOGV("\tReverb_setConfig calling memcpy");
625 pContext->config = *pConfig;
626
627
628 switch (pConfig->inputCfg.samplingRate) {
629 case 8000:
630 SampleRate = LVM_FS_8000;
631 break;
632 case 16000:
633 SampleRate = LVM_FS_16000;
634 break;
635 case 22050:
636 SampleRate = LVM_FS_22050;
637 break;
638 case 32000:
639 SampleRate = LVM_FS_32000;
640 break;
641 case 44100:
642 SampleRate = LVM_FS_44100;
643 break;
644 case 48000:
645 SampleRate = LVM_FS_48000;
646 break;
647 default:
648 ALOGV("\rReverb_setConfig invalid sampling rate %d", pConfig->inputCfg.samplingRate);
649 return -EINVAL;
650 }
651
652 if (pContext->SampleRate != SampleRate) {
653
654 LVREV_ControlParams_st ActiveParams;
655 LVREV_ReturnStatus_en LvmStatus = LVREV_SUCCESS;
656
657 //ALOGV("\tReverb_setConfig change sampling rate to %d", SampleRate);
658
659 /* Get the current settings */
660 LvmStatus = LVREV_GetControlParameters(pContext->hInstance,
661 &ActiveParams);
662
663 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "Reverb_setConfig")
664 if(LvmStatus != LVREV_SUCCESS) return -EINVAL;
665
666 ActiveParams.SampleRate = SampleRate;
667
668 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
669
670 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "Reverb_setConfig")
671 if(LvmStatus != LVREV_SUCCESS) return -EINVAL;
672 //ALOGV("\tReverb_setConfig Succesfully called LVREV_SetControlParameters\n");
673 pContext->SampleRate = SampleRate;
674 }else{
675 //ALOGV("\tReverb_setConfig keep sampling rate at %d", SampleRate);
676 }
677
678 //ALOGV("\tReverb_setConfig End");
679 return 0;
680 } /* end Reverb_setConfig */
681
682 //----------------------------------------------------------------------------
683 // Reverb_getConfig()
684 //----------------------------------------------------------------------------
685 // Purpose: Get input and output audio configuration.
686 //
687 // Inputs:
688 // pContext: effect engine context
689 // pConfig: pointer to effect_config_t structure holding input and output
690 // configuration parameters
691 //
692 // Outputs:
693 //
694 //----------------------------------------------------------------------------
695
Reverb_getConfig(ReverbContext * pContext,effect_config_t * pConfig)696 void Reverb_getConfig(ReverbContext *pContext, effect_config_t *pConfig)
697 {
698 *pConfig = pContext->config;
699 } /* end Reverb_getConfig */
700
701 //----------------------------------------------------------------------------
702 // Reverb_init()
703 //----------------------------------------------------------------------------
704 // Purpose: Initialize engine with default configuration
705 //
706 // Inputs:
707 // pContext: effect engine context
708 //
709 // Outputs:
710 //
711 //----------------------------------------------------------------------------
712
Reverb_init(ReverbContext * pContext)713 int Reverb_init(ReverbContext *pContext){
714 ALOGV("\tReverb_init start");
715
716 CHECK_ARG(pContext != NULL);
717
718 if (pContext->hInstance != NULL){
719 Reverb_free(pContext);
720 }
721
722 pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
723 if (pContext->auxiliary) {
724 pContext->config.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
725 } else {
726 pContext->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
727 }
728
729 pContext->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
730 pContext->config.inputCfg.samplingRate = 44100;
731 pContext->config.inputCfg.bufferProvider.getBuffer = NULL;
732 pContext->config.inputCfg.bufferProvider.releaseBuffer = NULL;
733 pContext->config.inputCfg.bufferProvider.cookie = NULL;
734 pContext->config.inputCfg.mask = EFFECT_CONFIG_ALL;
735 pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
736 pContext->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
737 pContext->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
738 pContext->config.outputCfg.samplingRate = 44100;
739 pContext->config.outputCfg.bufferProvider.getBuffer = NULL;
740 pContext->config.outputCfg.bufferProvider.releaseBuffer = NULL;
741 pContext->config.outputCfg.bufferProvider.cookie = NULL;
742 pContext->config.outputCfg.mask = EFFECT_CONFIG_ALL;
743
744 pContext->leftVolume = REVERB_UNIT_VOLUME;
745 pContext->rightVolume = REVERB_UNIT_VOLUME;
746 pContext->prevLeftVolume = REVERB_UNIT_VOLUME;
747 pContext->prevRightVolume = REVERB_UNIT_VOLUME;
748 pContext->volumeMode = REVERB_VOLUME_FLAT;
749
750 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
751 LVREV_ControlParams_st params; /* Control Parameters */
752 LVREV_InstanceParams_st InstParams; /* Instance parameters */
753 LVREV_MemoryTable_st MemTab; /* Memory allocation table */
754 bool bMallocFailure = LVM_FALSE;
755
756 /* Set the capabilities */
757 InstParams.MaxBlockSize = MAX_CALL_SIZE;
758 InstParams.SourceFormat = LVM_STEREO; // Max format, could be mono during process
759 InstParams.NumDelays = LVREV_DELAYLINES_4;
760
761 /* Allocate memory, forcing alignment */
762 LvmStatus = LVREV_GetMemoryTable(LVM_NULL,
763 &MemTab,
764 &InstParams);
765
766 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetMemoryTable", "Reverb_init")
767 if(LvmStatus != LVREV_SUCCESS) return -EINVAL;
768
769 ALOGV("\tCreateInstance Succesfully called LVM_GetMemoryTable\n");
770
771 /* Allocate memory */
772 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){
773 if (MemTab.Region[i].Size != 0){
774 MemTab.Region[i].pBaseAddress = malloc(MemTab.Region[i].Size);
775
776 if (MemTab.Region[i].pBaseAddress == LVM_NULL){
777 ALOGV("\tLVREV_ERROR :Reverb_init CreateInstance Failed to allocate %" PRIu32
778 " bytes for region %u\n", MemTab.Region[i].Size, i );
779 bMallocFailure = LVM_TRUE;
780 }else{
781 ALOGV("\tReverb_init CreateInstance allocate %" PRIu32
782 " bytes for region %u at %p\n",
783 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
784 }
785 }
786 }
787
788 /* If one or more of the memory regions failed to allocate, free the regions that were
789 * succesfully allocated and return with an error
790 */
791 if(bMallocFailure == LVM_TRUE){
792 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){
793 if (MemTab.Region[i].pBaseAddress == LVM_NULL){
794 ALOGV("\tLVM_ERROR :Reverb_init CreateInstance Failed to allocate %" PRIu32
795 " bytes for region %u - Not freeing\n", MemTab.Region[i].Size, i );
796 }else{
797 ALOGV("\tLVM_ERROR :Reverb_init CreateInstance Failed: but allocated %" PRIu32
798 " bytes for region %u at %p- free\n",
799 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
800 free(MemTab.Region[i].pBaseAddress);
801 }
802 }
803 return -EINVAL;
804 }
805 ALOGV("\tReverb_init CreateInstance Succesfully malloc'd memory\n");
806
807 /* Initialise */
808 pContext->hInstance = LVM_NULL;
809
810 /* Init sets the instance handle */
811 LvmStatus = LVREV_GetInstanceHandle(&pContext->hInstance,
812 &MemTab,
813 &InstParams);
814
815 LVM_ERROR_CHECK(LvmStatus, "LVM_GetInstanceHandle", "Reverb_init")
816 if(LvmStatus != LVREV_SUCCESS) return -EINVAL;
817
818 ALOGV("\tReverb_init CreateInstance Succesfully called LVM_GetInstanceHandle\n");
819
820 /* Set the initial process parameters */
821 /* General parameters */
822 params.OperatingMode = LVM_MODE_ON;
823 params.SampleRate = LVM_FS_44100;
824 pContext->SampleRate = LVM_FS_44100;
825
826 if(pContext->config.inputCfg.channels == AUDIO_CHANNEL_OUT_MONO){
827 params.SourceFormat = LVM_MONO;
828 } else {
829 params.SourceFormat = LVM_STEREO;
830 }
831
832 /* Reverb parameters */
833 params.Level = 0;
834 params.LPF = 23999;
835 params.HPF = 50;
836 params.T60 = 1490;
837 params.Density = 100;
838 params.Damping = 21;
839 params.RoomSize = 100;
840
841 pContext->SamplesToExitCount = (params.T60 * pContext->config.inputCfg.samplingRate)/1000;
842
843 /* Saved strength is used to return the exact strength that was used in the set to the get
844 * because we map the original strength range of 0:1000 to 1:15, and this will avoid
845 * quantisation like effect when returning
846 */
847 pContext->SavedRoomLevel = -6000;
848 pContext->SavedHfLevel = 0;
849 pContext->bEnabled = LVM_FALSE;
850 pContext->SavedDecayTime = params.T60;
851 pContext->SavedDecayHfRatio = params.Damping*20;
852 pContext->SavedDensity = params.RoomSize*10;
853 pContext->SavedDiffusion = params.Density*10;
854 pContext->SavedReverbLevel = -6000;
855
856 /* Activate the initial settings */
857 LvmStatus = LVREV_SetControlParameters(pContext->hInstance,
858 ¶ms);
859
860 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "Reverb_init")
861 if(LvmStatus != LVREV_SUCCESS) return -EINVAL;
862
863 ALOGV("\tReverb_init CreateInstance Succesfully called LVREV_SetControlParameters\n");
864 ALOGV("\tReverb_init End");
865 return 0;
866 } /* end Reverb_init */
867
868 //----------------------------------------------------------------------------
869 // ReverbConvertLevel()
870 //----------------------------------------------------------------------------
871 // Purpose:
872 // Convert level from OpenSL ES format to LVM format
873 //
874 // Inputs:
875 // level level to be applied
876 //
877 //----------------------------------------------------------------------------
878
ReverbConvertLevel(int16_t level)879 int16_t ReverbConvertLevel(int16_t level){
880 static int16_t LevelArray[101] =
881 {
882 -12000, -4000, -3398, -3046, -2796, -2603, -2444, -2310, -2194, -2092,
883 -2000, -1918, -1842, -1773, -1708, -1648, -1592, -1540, -1490, -1443,
884 -1398, -1356, -1316, -1277, -1240, -1205, -1171, -1138, -1106, -1076,
885 -1046, -1018, -990, -963, -938, -912, -888, -864, -841, -818,
886 -796, -775, -754, -734, -714, -694, -675, -656, -638, -620,
887 -603, -585, -568, -552, -536, -520, -504, -489, -474, -459,
888 -444, -430, -416, -402, -388, -375, -361, -348, -335, -323,
889 -310, -298, -286, -274, -262, -250, -239, -228, -216, -205,
890 -194, -184, -173, -162, -152, -142, -132, -121, -112, -102,
891 -92, -82, -73, -64, -54, -45, -36, -27, -18, -9,
892 0
893 };
894 int16_t i;
895
896 for(i = 0; i < 101; i++)
897 {
898 if(level <= LevelArray[i])
899 break;
900 }
901 return i;
902 }
903
904 //----------------------------------------------------------------------------
905 // ReverbConvertHFLevel()
906 //----------------------------------------------------------------------------
907 // Purpose:
908 // Convert level from OpenSL ES format to LVM format
909 //
910 // Inputs:
911 // level level to be applied
912 //
913 //----------------------------------------------------------------------------
914
ReverbConvertHfLevel(int16_t Hflevel)915 int16_t ReverbConvertHfLevel(int16_t Hflevel){
916 int16_t i;
917
918 static LPFPair_t LPFArray[97] =
919 { // Limit range to 50 for LVREV parameter range
920 {-10000, 50}, { -5000, 50 }, { -4000, 50}, { -3000, 158}, { -2000, 502},
921 {-1000, 1666},{ -900, 1897}, { -800, 2169}, { -700, 2496}, { -600, 2895},
922 {-500, 3400}, { -400, 4066}, { -300, 5011}, { -200, 6537}, { -100, 9826},
923 {-99, 9881 }, { -98, 9937 }, { -97, 9994 }, { -96, 10052}, { -95, 10111},
924 {-94, 10171}, { -93, 10231}, { -92, 10293}, { -91, 10356}, { -90, 10419},
925 {-89, 10484}, { -88, 10549}, { -87, 10616}, { -86, 10684}, { -85, 10753},
926 {-84, 10823}, { -83, 10895}, { -82, 10968}, { -81, 11042}, { -80, 11117},
927 {-79, 11194}, { -78, 11272}, { -77, 11352}, { -76, 11433}, { -75, 11516},
928 {-74, 11600}, { -73, 11686}, { -72, 11774}, { -71, 11864}, { -70, 11955},
929 {-69, 12049}, { -68, 12144}, { -67, 12242}, { -66, 12341}, { -65, 12443},
930 {-64, 12548}, { -63, 12654}, { -62, 12763}, { -61, 12875}, { -60, 12990},
931 {-59, 13107}, { -58, 13227}, { -57, 13351}, { -56, 13477}, { -55, 13607},
932 {-54, 13741}, { -53, 13878}, { -52, 14019}, { -51, 14164}, { -50, 14313},
933 {-49, 14467}, { -48, 14626}, { -47, 14789}, { -46, 14958}, { -45, 15132},
934 {-44, 15312}, { -43, 15498}, { -42, 15691}, { -41, 15890}, { -40, 16097},
935 {-39, 16311}, { -38, 16534}, { -37, 16766}, { -36, 17007}, { -35, 17259},
936 {-34, 17521}, { -33, 17795}, { -32, 18081}, { -31, 18381}, { -30, 18696},
937 {-29, 19027}, { -28, 19375}, { -27, 19742}, { -26, 20129}, { -25, 20540},
938 {-24, 20976}, { -23, 21439}, { -22, 21934}, { -21, 22463}, { -20, 23031},
939 {-19, 23643}, { -18, 23999}
940 };
941
942 for(i = 0; i < 96; i++)
943 {
944 if(Hflevel <= LPFArray[i].Room_HF)
945 break;
946 }
947 return LPFArray[i].LPF;
948 }
949
950 //----------------------------------------------------------------------------
951 // ReverbSetRoomHfLevel()
952 //----------------------------------------------------------------------------
953 // Purpose:
954 // Apply the HF level to the Reverb. Must first be converted to LVM format
955 //
956 // Inputs:
957 // pContext: effect engine context
958 // level level to be applied
959 //
960 //----------------------------------------------------------------------------
961
ReverbSetRoomHfLevel(ReverbContext * pContext,int16_t level)962 void ReverbSetRoomHfLevel(ReverbContext *pContext, int16_t level){
963 //ALOGV("\tReverbSetRoomHfLevel start (%d)", level);
964
965 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
966 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
967
968 /* Get the current settings */
969 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
970 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetRoomHfLevel")
971 //ALOGV("\tReverbSetRoomHfLevel Succesfully returned from LVM_GetControlParameters\n");
972 //ALOGV("\tReverbSetRoomHfLevel() just Got -> %d\n", ActiveParams.LPF);
973
974 ActiveParams.LPF = ReverbConvertHfLevel(level);
975
976 /* Activate the initial settings */
977 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
978 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetRoomHfLevel")
979 //ALOGV("\tReverbSetRoomhfLevel() just Set -> %d\n", ActiveParams.LPF);
980 pContext->SavedHfLevel = level;
981 //ALOGV("\tReverbSetHfRoomLevel end.. saving %d", pContext->SavedHfLevel);
982 return;
983 }
984
985 //----------------------------------------------------------------------------
986 // ReverbGetRoomHfLevel()
987 //----------------------------------------------------------------------------
988 // Purpose:
989 // Get the level applied to the Revervb. Must first be converted to LVM format
990 //
991 // Inputs:
992 // pContext: effect engine context
993 //
994 //----------------------------------------------------------------------------
995
ReverbGetRoomHfLevel(ReverbContext * pContext)996 int16_t ReverbGetRoomHfLevel(ReverbContext *pContext){
997 int16_t level;
998 //ALOGV("\tReverbGetRoomHfLevel start, saved level is %d", pContext->SavedHfLevel);
999
1000 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1001 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1002
1003 /* Get the current settings */
1004 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1005 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetRoomHfLevel")
1006 //ALOGV("\tReverbGetRoomHfLevel Succesfully returned from LVM_GetControlParameters\n");
1007 //ALOGV("\tReverbGetRoomHfLevel() just Got -> %d\n", ActiveParams.LPF);
1008
1009 level = ReverbConvertHfLevel(pContext->SavedHfLevel);
1010
1011 //ALOGV("\tReverbGetRoomHfLevel() ActiveParams.LPFL %d, pContext->SavedHfLevel: %d, "
1012 // "converted level: %d\n", ActiveParams.LPF, pContext->SavedHfLevel, level);
1013
1014 if(ActiveParams.LPF != level){
1015 ALOGV("\tLVM_ERROR : (ignore at start up) ReverbGetRoomHfLevel() has wrong level -> %d %d\n",
1016 ActiveParams.Level, level);
1017 }
1018
1019 //ALOGV("\tReverbGetRoomHfLevel end");
1020 return pContext->SavedHfLevel;
1021 }
1022
1023 //----------------------------------------------------------------------------
1024 // ReverbSetReverbLevel()
1025 //----------------------------------------------------------------------------
1026 // Purpose:
1027 // Apply the level to the Reverb. Must first be converted to LVM format
1028 //
1029 // Inputs:
1030 // pContext: effect engine context
1031 // level level to be applied
1032 //
1033 //----------------------------------------------------------------------------
1034
ReverbSetReverbLevel(ReverbContext * pContext,int16_t level)1035 void ReverbSetReverbLevel(ReverbContext *pContext, int16_t level){
1036 //ALOGV("\n\tReverbSetReverbLevel start (%d)", level);
1037
1038 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1039 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1040 LVM_INT32 CombinedLevel; // Sum of room and reverb level controls
1041
1042 /* Get the current settings */
1043 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1044 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetReverbLevel")
1045 //ALOGV("\tReverbSetReverbLevel Succesfully returned from LVM_GetControlParameters\n");
1046 //ALOGV("\tReverbSetReverbLevel just Got -> %d\n", ActiveParams.Level);
1047
1048 // needs to subtract max levels for both RoomLevel and ReverbLevel
1049 CombinedLevel = (level + pContext->SavedRoomLevel)-LVREV_MAX_REVERB_LEVEL;
1050 //ALOGV("\tReverbSetReverbLevel() CombinedLevel is %d = %d + %d\n",
1051 // CombinedLevel, level, pContext->SavedRoomLevel);
1052
1053 ActiveParams.Level = ReverbConvertLevel(CombinedLevel);
1054
1055 //ALOGV("\tReverbSetReverbLevel() Trying to set -> %d\n", ActiveParams.Level);
1056
1057 /* Activate the initial settings */
1058 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
1059 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetReverbLevel")
1060 //ALOGV("\tReverbSetReverbLevel() just Set -> %d\n", ActiveParams.Level);
1061
1062 pContext->SavedReverbLevel = level;
1063 //ALOGV("\tReverbSetReverbLevel end pContext->SavedReverbLevel is %d\n\n",
1064 // pContext->SavedReverbLevel);
1065 return;
1066 }
1067
1068 //----------------------------------------------------------------------------
1069 // ReverbGetReverbLevel()
1070 //----------------------------------------------------------------------------
1071 // Purpose:
1072 // Get the level applied to the Revervb. Must first be converted to LVM format
1073 //
1074 // Inputs:
1075 // pContext: effect engine context
1076 //
1077 //----------------------------------------------------------------------------
1078
ReverbGetReverbLevel(ReverbContext * pContext)1079 int16_t ReverbGetReverbLevel(ReverbContext *pContext){
1080 int16_t level;
1081 //ALOGV("\tReverbGetReverbLevel start");
1082
1083 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1084 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1085 LVM_INT32 CombinedLevel; // Sum of room and reverb level controls
1086
1087 /* Get the current settings */
1088 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1089 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetReverbLevel")
1090 //ALOGV("\tReverbGetReverbLevel Succesfully returned from LVM_GetControlParameters\n");
1091 //ALOGV("\tReverbGetReverbLevel() just Got -> %d\n", ActiveParams.Level);
1092
1093 // needs to subtract max levels for both RoomLevel and ReverbLevel
1094 CombinedLevel = (pContext->SavedReverbLevel + pContext->SavedRoomLevel)-LVREV_MAX_REVERB_LEVEL;
1095
1096 //ALOGV("\tReverbGetReverbLevel() CombinedLevel is %d = %d + %d\n",
1097 //CombinedLevel, pContext->SavedReverbLevel, pContext->SavedRoomLevel);
1098 level = ReverbConvertLevel(CombinedLevel);
1099
1100 //ALOGV("\tReverbGetReverbLevel(): ActiveParams.Level: %d, pContext->SavedReverbLevel: %d, "
1101 //"pContext->SavedRoomLevel: %d, CombinedLevel: %d, converted level: %d\n",
1102 //ActiveParams.Level, pContext->SavedReverbLevel,pContext->SavedRoomLevel, CombinedLevel,level);
1103
1104 if(ActiveParams.Level != level){
1105 ALOGV("\tLVM_ERROR : (ignore at start up) ReverbGetReverbLevel() has wrong level -> %d %d\n",
1106 ActiveParams.Level, level);
1107 }
1108
1109 //ALOGV("\tReverbGetReverbLevel end\n");
1110
1111 return pContext->SavedReverbLevel;
1112 }
1113
1114 //----------------------------------------------------------------------------
1115 // ReverbSetRoomLevel()
1116 //----------------------------------------------------------------------------
1117 // Purpose:
1118 // Apply the level to the Reverb. Must first be converted to LVM format
1119 //
1120 // Inputs:
1121 // pContext: effect engine context
1122 // level level to be applied
1123 //
1124 //----------------------------------------------------------------------------
1125
ReverbSetRoomLevel(ReverbContext * pContext,int16_t level)1126 void ReverbSetRoomLevel(ReverbContext *pContext, int16_t level){
1127 //ALOGV("\tReverbSetRoomLevel start (%d)", level);
1128
1129 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1130 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1131 LVM_INT32 CombinedLevel; // Sum of room and reverb level controls
1132
1133 /* Get the current settings */
1134 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1135 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetRoomLevel")
1136 //ALOGV("\tReverbSetRoomLevel Succesfully returned from LVM_GetControlParameters\n");
1137 //ALOGV("\tReverbSetRoomLevel() just Got -> %d\n", ActiveParams.Level);
1138
1139 // needs to subtract max levels for both RoomLevel and ReverbLevel
1140 CombinedLevel = (level + pContext->SavedReverbLevel)-LVREV_MAX_REVERB_LEVEL;
1141 ActiveParams.Level = ReverbConvertLevel(CombinedLevel);
1142
1143 /* Activate the initial settings */
1144 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
1145 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetRoomLevel")
1146 //ALOGV("\tReverbSetRoomLevel() just Set -> %d\n", ActiveParams.Level);
1147
1148 pContext->SavedRoomLevel = level;
1149 //ALOGV("\tReverbSetRoomLevel end");
1150 return;
1151 }
1152
1153 //----------------------------------------------------------------------------
1154 // ReverbGetRoomLevel()
1155 //----------------------------------------------------------------------------
1156 // Purpose:
1157 // Get the level applied to the Revervb. Must first be converted to LVM format
1158 //
1159 // Inputs:
1160 // pContext: effect engine context
1161 //
1162 //----------------------------------------------------------------------------
1163
ReverbGetRoomLevel(ReverbContext * pContext)1164 int16_t ReverbGetRoomLevel(ReverbContext *pContext){
1165 int16_t level;
1166 //ALOGV("\tReverbGetRoomLevel start");
1167
1168 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1169 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1170 LVM_INT32 CombinedLevel; // Sum of room and reverb level controls
1171
1172 /* Get the current settings */
1173 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1174 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetRoomLevel")
1175 //ALOGV("\tReverbGetRoomLevel Succesfully returned from LVM_GetControlParameters\n");
1176 //ALOGV("\tReverbGetRoomLevel() just Got -> %d\n", ActiveParams.Level);
1177
1178 // needs to subtract max levels for both RoomLevel and ReverbLevel
1179 CombinedLevel = (pContext->SavedRoomLevel + pContext->SavedReverbLevel-LVREV_MAX_REVERB_LEVEL);
1180 level = ReverbConvertLevel(CombinedLevel);
1181
1182 //ALOGV("\tReverbGetRoomLevel, Level = %d, pContext->SavedRoomLevel = %d, "
1183 // "pContext->SavedReverbLevel = %d, CombinedLevel = %d, level = %d",
1184 // ActiveParams.Level, pContext->SavedRoomLevel,
1185 // pContext->SavedReverbLevel, CombinedLevel, level);
1186
1187 if(ActiveParams.Level != level){
1188 ALOGV("\tLVM_ERROR : (ignore at start up) ReverbGetRoomLevel() has wrong level -> %d %d\n",
1189 ActiveParams.Level, level);
1190 }
1191
1192 //ALOGV("\tReverbGetRoomLevel end");
1193 return pContext->SavedRoomLevel;
1194 }
1195
1196 //----------------------------------------------------------------------------
1197 // ReverbSetDecayTime()
1198 //----------------------------------------------------------------------------
1199 // Purpose:
1200 // Apply the decay time to the Reverb.
1201 //
1202 // Inputs:
1203 // pContext: effect engine context
1204 // time decay to be applied
1205 //
1206 //----------------------------------------------------------------------------
1207
ReverbSetDecayTime(ReverbContext * pContext,uint32_t time)1208 void ReverbSetDecayTime(ReverbContext *pContext, uint32_t time){
1209 //ALOGV("\tReverbSetDecayTime start (%d)", time);
1210
1211 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1212 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1213
1214 /* Get the current settings */
1215 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1216 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetDecayTime")
1217 //ALOGV("\tReverbSetDecayTime Succesfully returned from LVM_GetControlParameters\n");
1218 //ALOGV("\tReverbSetDecayTime() just Got -> %d\n", ActiveParams.T60);
1219
1220 if (time <= LVREV_MAX_T60) {
1221 ActiveParams.T60 = (LVM_UINT16)time;
1222 }
1223 else {
1224 ActiveParams.T60 = LVREV_MAX_T60;
1225 }
1226
1227 /* Activate the initial settings */
1228 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
1229 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetDecayTime")
1230 //ALOGV("\tReverbSetDecayTime() just Set -> %d\n", ActiveParams.T60);
1231
1232 pContext->SamplesToExitCount = (ActiveParams.T60 * pContext->config.inputCfg.samplingRate)/1000;
1233 //ALOGV("\tReverbSetDecayTime() just Set SamplesToExitCount-> %d\n",pContext->SamplesToExitCount);
1234 pContext->SavedDecayTime = (int16_t)time;
1235 //ALOGV("\tReverbSetDecayTime end");
1236 return;
1237 }
1238
1239 //----------------------------------------------------------------------------
1240 // ReverbGetDecayTime()
1241 //----------------------------------------------------------------------------
1242 // Purpose:
1243 // Get the decay time applied to the Revervb.
1244 //
1245 // Inputs:
1246 // pContext: effect engine context
1247 //
1248 //----------------------------------------------------------------------------
1249
ReverbGetDecayTime(ReverbContext * pContext)1250 uint32_t ReverbGetDecayTime(ReverbContext *pContext){
1251 //ALOGV("\tReverbGetDecayTime start");
1252
1253 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1254 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1255
1256 /* Get the current settings */
1257 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1258 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetDecayTime")
1259 //ALOGV("\tReverbGetDecayTime Succesfully returned from LVM_GetControlParameters\n");
1260 //ALOGV("\tReverbGetDecayTime() just Got -> %d\n", ActiveParams.T60);
1261
1262 if(ActiveParams.T60 != pContext->SavedDecayTime){
1263 // This will fail if the decay time is set to more than 7000
1264 ALOGV("\tLVM_ERROR : ReverbGetDecayTime() has wrong level -> %d %d\n",
1265 ActiveParams.T60, pContext->SavedDecayTime);
1266 }
1267
1268 //ALOGV("\tReverbGetDecayTime end");
1269 return (uint32_t)ActiveParams.T60;
1270 }
1271
1272 //----------------------------------------------------------------------------
1273 // ReverbSetDecayHfRatio()
1274 //----------------------------------------------------------------------------
1275 // Purpose:
1276 // Apply the HF decay ratio to the Reverb.
1277 //
1278 // Inputs:
1279 // pContext: effect engine context
1280 // ratio ratio to be applied
1281 //
1282 //----------------------------------------------------------------------------
1283
ReverbSetDecayHfRatio(ReverbContext * pContext,int16_t ratio)1284 void ReverbSetDecayHfRatio(ReverbContext *pContext, int16_t ratio){
1285 //ALOGV("\tReverbSetDecayHfRatioe start (%d)", ratio);
1286
1287 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1288 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1289
1290 /* Get the current settings */
1291 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1292 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetDecayHfRatio")
1293 //ALOGV("\tReverbSetDecayHfRatio Succesfully returned from LVM_GetControlParameters\n");
1294 //ALOGV("\tReverbSetDecayHfRatio() just Got -> %d\n", ActiveParams.Damping);
1295
1296 ActiveParams.Damping = (LVM_INT16)(ratio/20);
1297
1298 /* Activate the initial settings */
1299 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
1300 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetDecayHfRatio")
1301 //ALOGV("\tReverbSetDecayHfRatio() just Set -> %d\n", ActiveParams.Damping);
1302
1303 pContext->SavedDecayHfRatio = ratio;
1304 //ALOGV("\tReverbSetDecayHfRatio end");
1305 return;
1306 }
1307
1308 //----------------------------------------------------------------------------
1309 // ReverbGetDecayHfRatio()
1310 //----------------------------------------------------------------------------
1311 // Purpose:
1312 // Get the HF decay ratio applied to the Revervb.
1313 //
1314 // Inputs:
1315 // pContext: effect engine context
1316 //
1317 //----------------------------------------------------------------------------
1318
ReverbGetDecayHfRatio(ReverbContext * pContext)1319 int32_t ReverbGetDecayHfRatio(ReverbContext *pContext){
1320 //ALOGV("\tReverbGetDecayHfRatio start");
1321
1322 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1323 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1324
1325 /* Get the current settings */
1326 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1327 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetDecayHfRatio")
1328 //ALOGV("\tReverbGetDecayHfRatio Succesfully returned from LVM_GetControlParameters\n");
1329 //ALOGV("\tReverbGetDecayHfRatio() just Got -> %d\n", ActiveParams.Damping);
1330
1331 if(ActiveParams.Damping != (LVM_INT16)(pContext->SavedDecayHfRatio / 20)){
1332 ALOGV("\tLVM_ERROR : ReverbGetDecayHfRatio() has wrong level -> %d %d\n",
1333 ActiveParams.Damping, pContext->SavedDecayHfRatio);
1334 }
1335
1336 //ALOGV("\tReverbGetDecayHfRatio end");
1337 return pContext->SavedDecayHfRatio;
1338 }
1339
1340 //----------------------------------------------------------------------------
1341 // ReverbSetDiffusion()
1342 //----------------------------------------------------------------------------
1343 // Purpose:
1344 // Apply the diffusion to the Reverb.
1345 //
1346 // Inputs:
1347 // pContext: effect engine context
1348 // level decay to be applied
1349 //
1350 //----------------------------------------------------------------------------
1351
ReverbSetDiffusion(ReverbContext * pContext,int16_t level)1352 void ReverbSetDiffusion(ReverbContext *pContext, int16_t level){
1353 //ALOGV("\tReverbSetDiffusion start (%d)", level);
1354
1355 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1356 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1357
1358 /* Get the current settings */
1359 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1360 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetDiffusion")
1361 //ALOGV("\tReverbSetDiffusion Succesfully returned from LVM_GetControlParameters\n");
1362 //ALOGV("\tReverbSetDiffusion() just Got -> %d\n", ActiveParams.Density);
1363
1364 ActiveParams.Density = (LVM_INT16)(level/10);
1365
1366 /* Activate the initial settings */
1367 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
1368 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetDiffusion")
1369 //ALOGV("\tReverbSetDiffusion() just Set -> %d\n", ActiveParams.Density);
1370
1371 pContext->SavedDiffusion = level;
1372 //ALOGV("\tReverbSetDiffusion end");
1373 return;
1374 }
1375
1376 //----------------------------------------------------------------------------
1377 // ReverbGetDiffusion()
1378 //----------------------------------------------------------------------------
1379 // Purpose:
1380 // Get the decay time applied to the Revervb.
1381 //
1382 // Inputs:
1383 // pContext: effect engine context
1384 //
1385 //----------------------------------------------------------------------------
1386
ReverbGetDiffusion(ReverbContext * pContext)1387 int32_t ReverbGetDiffusion(ReverbContext *pContext){
1388 //ALOGV("\tReverbGetDiffusion start");
1389
1390 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1391 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1392 LVM_INT16 Temp;
1393
1394 /* Get the current settings */
1395 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1396 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetDiffusion")
1397 //ALOGV("\tReverbGetDiffusion Succesfully returned from LVM_GetControlParameters\n");
1398 //ALOGV("\tReverbGetDiffusion just Got -> %d\n", ActiveParams.Density);
1399
1400 Temp = (LVM_INT16)(pContext->SavedDiffusion/10);
1401
1402 if(ActiveParams.Density != Temp){
1403 ALOGV("\tLVM_ERROR : ReverbGetDiffusion invalid value %d %d", Temp, ActiveParams.Density);
1404 }
1405
1406 //ALOGV("\tReverbGetDiffusion end");
1407 return pContext->SavedDiffusion;
1408 }
1409
1410 //----------------------------------------------------------------------------
1411 // ReverbSetDensity()
1412 //----------------------------------------------------------------------------
1413 // Purpose:
1414 // Apply the density level the Reverb.
1415 //
1416 // Inputs:
1417 // pContext: effect engine context
1418 // level decay to be applied
1419 //
1420 //----------------------------------------------------------------------------
1421
ReverbSetDensity(ReverbContext * pContext,int16_t level)1422 void ReverbSetDensity(ReverbContext *pContext, int16_t level){
1423 //ALOGV("\tReverbSetDensity start (%d)", level);
1424
1425 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1426 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1427
1428 /* Get the current settings */
1429 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1430 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbSetDensity")
1431 //ALOGV("\tReverbSetDensity Succesfully returned from LVM_GetControlParameters\n");
1432 //ALOGV("\tReverbSetDensity just Got -> %d\n", ActiveParams.RoomSize);
1433
1434 ActiveParams.RoomSize = (LVM_INT16)(((level * 99) / 1000) + 1);
1435
1436 /* Activate the initial settings */
1437 LvmStatus = LVREV_SetControlParameters(pContext->hInstance, &ActiveParams);
1438 LVM_ERROR_CHECK(LvmStatus, "LVREV_SetControlParameters", "ReverbSetDensity")
1439 //ALOGV("\tReverbSetDensity just Set -> %d\n", ActiveParams.RoomSize);
1440
1441 pContext->SavedDensity = level;
1442 //ALOGV("\tReverbSetDensity end");
1443 return;
1444 }
1445
1446 //----------------------------------------------------------------------------
1447 // ReverbGetDensity()
1448 //----------------------------------------------------------------------------
1449 // Purpose:
1450 // Get the density level applied to the Revervb.
1451 //
1452 // Inputs:
1453 // pContext: effect engine context
1454 //
1455 //----------------------------------------------------------------------------
1456
ReverbGetDensity(ReverbContext * pContext)1457 int32_t ReverbGetDensity(ReverbContext *pContext){
1458 //ALOGV("\tReverbGetDensity start");
1459
1460 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1461 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1462 LVM_INT16 Temp;
1463 /* Get the current settings */
1464 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
1465 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "ReverbGetDensity")
1466 //ALOGV("\tReverbGetDensity Succesfully returned from LVM_GetControlParameters\n");
1467 //ALOGV("\tReverbGetDensity() just Got -> %d\n", ActiveParams.RoomSize);
1468
1469
1470 Temp = (LVM_INT16)(((pContext->SavedDensity * 99) / 1000) + 1);
1471
1472 if(Temp != ActiveParams.RoomSize){
1473 ALOGV("\tLVM_ERROR : ReverbGetDensity invalid value %d %d", Temp, ActiveParams.RoomSize);
1474 }
1475
1476 //ALOGV("\tReverbGetDensity end");
1477 return pContext->SavedDensity;
1478 }
1479
1480 //----------------------------------------------------------------------------
1481 // Reverb_LoadPreset()
1482 //----------------------------------------------------------------------------
1483 // Purpose:
1484 // Load a the next preset
1485 //
1486 // Inputs:
1487 // pContext - handle to instance data
1488 //
1489 // Outputs:
1490 //
1491 // Side Effects:
1492 //
1493 //----------------------------------------------------------------------------
Reverb_LoadPreset(ReverbContext * pContext)1494 int Reverb_LoadPreset(ReverbContext *pContext)
1495 {
1496 //TODO: add reflections delay, level and reverb delay when early reflections are
1497 // implemented
1498 pContext->curPreset = pContext->nextPreset;
1499
1500 if (pContext->curPreset != REVERB_PRESET_NONE) {
1501 const t_reverb_settings *preset = &sReverbPresets[pContext->curPreset];
1502 ReverbSetRoomLevel(pContext, preset->roomLevel);
1503 ReverbSetRoomHfLevel(pContext, preset->roomHFLevel);
1504 ReverbSetDecayTime(pContext, preset->decayTime);
1505 ReverbSetDecayHfRatio(pContext, preset->decayHFRatio);
1506 //reflectionsLevel
1507 //reflectionsDelay
1508 ReverbSetReverbLevel(pContext, preset->reverbLevel);
1509 // reverbDelay
1510 ReverbSetDiffusion(pContext, preset->diffusion);
1511 ReverbSetDensity(pContext, preset->density);
1512 }
1513
1514 return 0;
1515 }
1516
1517
1518 //----------------------------------------------------------------------------
1519 // Reverb_getParameter()
1520 //----------------------------------------------------------------------------
1521 // Purpose:
1522 // Get a Reverb parameter
1523 //
1524 // Inputs:
1525 // pContext - handle to instance data
1526 // pParam - pointer to parameter
1527 // pValue - pointer to variable to hold retrieved value
1528 // pValueSize - pointer to value size: maximum size as input
1529 //
1530 // Outputs:
1531 // *pValue updated with parameter value
1532 // *pValueSize updated with actual value size
1533 //
1534 //
1535 // Side Effects:
1536 //
1537 //----------------------------------------------------------------------------
1538
Reverb_getParameter(ReverbContext * pContext,void * pParam,uint32_t * pValueSize,void * pValue)1539 int Reverb_getParameter(ReverbContext *pContext,
1540 void *pParam,
1541 uint32_t *pValueSize,
1542 void *pValue){
1543 int status = 0;
1544 int32_t *pParamTemp = (int32_t *)pParam;
1545 int32_t param = *pParamTemp++;
1546 t_reverb_settings *pProperties;
1547
1548 //ALOGV("\tReverb_getParameter start");
1549 if (pContext->preset) {
1550 if (param != REVERB_PARAM_PRESET || *pValueSize < sizeof(uint16_t)) {
1551 return -EINVAL;
1552 }
1553
1554 *(uint16_t *)pValue = pContext->nextPreset;
1555 ALOGV("get REVERB_PARAM_PRESET, preset %d", pContext->nextPreset);
1556 return 0;
1557 }
1558
1559 switch (param){
1560 case REVERB_PARAM_ROOM_LEVEL:
1561 if (*pValueSize != sizeof(int16_t)){
1562 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize1 %d", *pValueSize);
1563 return -EINVAL;
1564 }
1565 *pValueSize = sizeof(int16_t);
1566 break;
1567 case REVERB_PARAM_ROOM_HF_LEVEL:
1568 if (*pValueSize != sizeof(int16_t)){
1569 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize12 %d", *pValueSize);
1570 return -EINVAL;
1571 }
1572 *pValueSize = sizeof(int16_t);
1573 break;
1574 case REVERB_PARAM_DECAY_TIME:
1575 if (*pValueSize != sizeof(uint32_t)){
1576 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize3 %d", *pValueSize);
1577 return -EINVAL;
1578 }
1579 *pValueSize = sizeof(uint32_t);
1580 break;
1581 case REVERB_PARAM_DECAY_HF_RATIO:
1582 if (*pValueSize != sizeof(int16_t)){
1583 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize4 %d", *pValueSize);
1584 return -EINVAL;
1585 }
1586 *pValueSize = sizeof(int16_t);
1587 break;
1588 case REVERB_PARAM_REFLECTIONS_LEVEL:
1589 if (*pValueSize != sizeof(int16_t)){
1590 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize5 %d", *pValueSize);
1591 return -EINVAL;
1592 }
1593 *pValueSize = sizeof(int16_t);
1594 break;
1595 case REVERB_PARAM_REFLECTIONS_DELAY:
1596 if (*pValueSize != sizeof(uint32_t)){
1597 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize6 %d", *pValueSize);
1598 return -EINVAL;
1599 }
1600 *pValueSize = sizeof(uint32_t);
1601 break;
1602 case REVERB_PARAM_REVERB_LEVEL:
1603 if (*pValueSize != sizeof(int16_t)){
1604 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize7 %d", *pValueSize);
1605 return -EINVAL;
1606 }
1607 *pValueSize = sizeof(int16_t);
1608 break;
1609 case REVERB_PARAM_REVERB_DELAY:
1610 if (*pValueSize != sizeof(uint32_t)){
1611 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize8 %d", *pValueSize);
1612 return -EINVAL;
1613 }
1614 *pValueSize = sizeof(uint32_t);
1615 break;
1616 case REVERB_PARAM_DIFFUSION:
1617 if (*pValueSize != sizeof(int16_t)){
1618 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize9 %d", *pValueSize);
1619 return -EINVAL;
1620 }
1621 *pValueSize = sizeof(int16_t);
1622 break;
1623 case REVERB_PARAM_DENSITY:
1624 if (*pValueSize != sizeof(int16_t)){
1625 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize10 %d", *pValueSize);
1626 return -EINVAL;
1627 }
1628 *pValueSize = sizeof(int16_t);
1629 break;
1630 case REVERB_PARAM_PROPERTIES:
1631 if (*pValueSize != sizeof(t_reverb_settings)){
1632 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid pValueSize11 %d", *pValueSize);
1633 return -EINVAL;
1634 }
1635 *pValueSize = sizeof(t_reverb_settings);
1636 break;
1637
1638 default:
1639 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid param %d", param);
1640 return -EINVAL;
1641 }
1642
1643 pProperties = (t_reverb_settings *) pValue;
1644
1645 switch (param){
1646 case REVERB_PARAM_PROPERTIES:
1647 pProperties->roomLevel = ReverbGetRoomLevel(pContext);
1648 pProperties->roomHFLevel = ReverbGetRoomHfLevel(pContext);
1649 pProperties->decayTime = ReverbGetDecayTime(pContext);
1650 pProperties->decayHFRatio = ReverbGetDecayHfRatio(pContext);
1651 pProperties->reflectionsLevel = 0;
1652 pProperties->reflectionsDelay = 0;
1653 pProperties->reverbDelay = 0;
1654 pProperties->reverbLevel = ReverbGetReverbLevel(pContext);
1655 pProperties->diffusion = ReverbGetDiffusion(pContext);
1656 pProperties->density = ReverbGetDensity(pContext);
1657
1658 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is roomLevel %d",
1659 pProperties->roomLevel);
1660 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is roomHFLevel %d",
1661 pProperties->roomHFLevel);
1662 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is decayTime %d",
1663 pProperties->decayTime);
1664 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is decayHFRatio %d",
1665 pProperties->decayHFRatio);
1666 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is reflectionsLevel %d",
1667 pProperties->reflectionsLevel);
1668 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is reflectionsDelay %d",
1669 pProperties->reflectionsDelay);
1670 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is reverbDelay %d",
1671 pProperties->reverbDelay);
1672 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is reverbLevel %d",
1673 pProperties->reverbLevel);
1674 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is diffusion %d",
1675 pProperties->diffusion);
1676 ALOGV("\tReverb_getParameter() REVERB_PARAM_PROPERTIES Value is density %d",
1677 pProperties->density);
1678 break;
1679
1680 case REVERB_PARAM_ROOM_LEVEL:
1681 *(int16_t *)pValue = ReverbGetRoomLevel(pContext);
1682
1683 //ALOGV("\tReverb_getParameter() REVERB_PARAM_ROOM_LEVEL Value is %d",
1684 // *(int16_t *)pValue);
1685 break;
1686 case REVERB_PARAM_ROOM_HF_LEVEL:
1687 *(int16_t *)pValue = ReverbGetRoomHfLevel(pContext);
1688
1689 //ALOGV("\tReverb_getParameter() REVERB_PARAM_ROOM_HF_LEVEL Value is %d",
1690 // *(int16_t *)pValue);
1691 break;
1692 case REVERB_PARAM_DECAY_TIME:
1693 *(uint32_t *)pValue = ReverbGetDecayTime(pContext);
1694
1695 //ALOGV("\tReverb_getParameter() REVERB_PARAM_DECAY_TIME Value is %d",
1696 // *(int32_t *)pValue);
1697 break;
1698 case REVERB_PARAM_DECAY_HF_RATIO:
1699 *(int16_t *)pValue = ReverbGetDecayHfRatio(pContext);
1700
1701 //ALOGV("\tReverb_getParameter() REVERB_PARAM_DECAY_HF_RATION Value is %d",
1702 // *(int16_t *)pValue);
1703 break;
1704 case REVERB_PARAM_REVERB_LEVEL:
1705 *(int16_t *)pValue = ReverbGetReverbLevel(pContext);
1706
1707 //ALOGV("\tReverb_getParameter() REVERB_PARAM_REVERB_LEVEL Value is %d",
1708 // *(int16_t *)pValue);
1709 break;
1710 case REVERB_PARAM_DIFFUSION:
1711 *(int16_t *)pValue = ReverbGetDiffusion(pContext);
1712
1713 //ALOGV("\tReverb_getParameter() REVERB_PARAM_DECAY_DIFFUSION Value is %d",
1714 // *(int16_t *)pValue);
1715 break;
1716 case REVERB_PARAM_DENSITY:
1717 *(uint16_t *)pValue = 0;
1718 *(int16_t *)pValue = ReverbGetDensity(pContext);
1719 //ALOGV("\tReverb_getParameter() REVERB_PARAM_DENSITY Value is %d",
1720 // *(uint32_t *)pValue);
1721 break;
1722 case REVERB_PARAM_REFLECTIONS_LEVEL:
1723 *(uint16_t *)pValue = 0;
1724 case REVERB_PARAM_REFLECTIONS_DELAY:
1725 *(uint32_t *)pValue = 0;
1726 case REVERB_PARAM_REVERB_DELAY:
1727 *(uint32_t *)pValue = 0;
1728 break;
1729
1730 default:
1731 ALOGV("\tLVM_ERROR : Reverb_getParameter() invalid param %d", param);
1732 status = -EINVAL;
1733 break;
1734 }
1735
1736 //ALOGV("\tReverb_getParameter end");
1737 return status;
1738 } /* end Reverb_getParameter */
1739
1740 //----------------------------------------------------------------------------
1741 // Reverb_setParameter()
1742 //----------------------------------------------------------------------------
1743 // Purpose:
1744 // Set a Reverb parameter
1745 //
1746 // Inputs:
1747 // pContext - handle to instance data
1748 // pParam - pointer to parameter
1749 // pValue - pointer to value
1750 // vsize - value size
1751 //
1752 // Outputs:
1753 //
1754 //----------------------------------------------------------------------------
1755
Reverb_setParameter(ReverbContext * pContext,void * pParam,void * pValue,int vsize)1756 int Reverb_setParameter (ReverbContext *pContext, void *pParam, void *pValue, int vsize){
1757 int status = 0;
1758 int16_t level;
1759 int16_t ratio;
1760 uint32_t time;
1761 t_reverb_settings *pProperties;
1762 int32_t *pParamTemp = (int32_t *)pParam;
1763 int32_t param = *pParamTemp++;
1764
1765 //ALOGV("\tReverb_setParameter start");
1766 if (pContext->preset) {
1767 if (param != REVERB_PARAM_PRESET) {
1768 return -EINVAL;
1769 }
1770
1771 uint16_t preset = *(uint16_t *)pValue;
1772 ALOGV("set REVERB_PARAM_PRESET, preset %d", preset);
1773 if (preset > REVERB_PRESET_LAST) {
1774 return -EINVAL;
1775 }
1776 pContext->nextPreset = preset;
1777 return 0;
1778 }
1779
1780 if (vsize < Reverb_paramValueSize(param)) {
1781 android_errorWriteLog(0x534e4554, "63526567");
1782 return -EINVAL;
1783 }
1784
1785 switch (param){
1786 case REVERB_PARAM_PROPERTIES:
1787 ALOGV("\tReverb_setParameter() REVERB_PARAM_PROPERTIES");
1788 pProperties = (t_reverb_settings *) pValue;
1789 ReverbSetRoomLevel(pContext, pProperties->roomLevel);
1790 ReverbSetRoomHfLevel(pContext, pProperties->roomHFLevel);
1791 ReverbSetDecayTime(pContext, pProperties->decayTime);
1792 ReverbSetDecayHfRatio(pContext, pProperties->decayHFRatio);
1793 ReverbSetReverbLevel(pContext, pProperties->reverbLevel);
1794 ReverbSetDiffusion(pContext, pProperties->diffusion);
1795 ReverbSetDensity(pContext, pProperties->density);
1796 break;
1797 case REVERB_PARAM_ROOM_LEVEL:
1798 level = *(int16_t *)pValue;
1799 //ALOGV("\tReverb_setParameter() REVERB_PARAM_ROOM_LEVEL value is %d", level);
1800 //ALOGV("\tReverb_setParameter() Calling ReverbSetRoomLevel");
1801 ReverbSetRoomLevel(pContext, level);
1802 //ALOGV("\tReverb_setParameter() Called ReverbSetRoomLevel");
1803 break;
1804 case REVERB_PARAM_ROOM_HF_LEVEL:
1805 level = *(int16_t *)pValue;
1806 //ALOGV("\tReverb_setParameter() REVERB_PARAM_ROOM_HF_LEVEL value is %d", level);
1807 //ALOGV("\tReverb_setParameter() Calling ReverbSetRoomHfLevel");
1808 ReverbSetRoomHfLevel(pContext, level);
1809 //ALOGV("\tReverb_setParameter() Called ReverbSetRoomHfLevel");
1810 break;
1811 case REVERB_PARAM_DECAY_TIME:
1812 time = *(uint32_t *)pValue;
1813 //ALOGV("\tReverb_setParameter() REVERB_PARAM_DECAY_TIME value is %d", time);
1814 //ALOGV("\tReverb_setParameter() Calling ReverbSetDecayTime");
1815 ReverbSetDecayTime(pContext, time);
1816 //ALOGV("\tReverb_setParameter() Called ReverbSetDecayTime");
1817 break;
1818 case REVERB_PARAM_DECAY_HF_RATIO:
1819 ratio = *(int16_t *)pValue;
1820 //ALOGV("\tReverb_setParameter() REVERB_PARAM_DECAY_HF_RATIO value is %d", ratio);
1821 //ALOGV("\tReverb_setParameter() Calling ReverbSetDecayHfRatio");
1822 ReverbSetDecayHfRatio(pContext, ratio);
1823 //ALOGV("\tReverb_setParameter() Called ReverbSetDecayHfRatio");
1824 break;
1825 case REVERB_PARAM_REVERB_LEVEL:
1826 level = *(int16_t *)pValue;
1827 //ALOGV("\tReverb_setParameter() REVERB_PARAM_REVERB_LEVEL value is %d", level);
1828 //ALOGV("\tReverb_setParameter() Calling ReverbSetReverbLevel");
1829 ReverbSetReverbLevel(pContext, level);
1830 //ALOGV("\tReverb_setParameter() Called ReverbSetReverbLevel");
1831 break;
1832 case REVERB_PARAM_DIFFUSION:
1833 ratio = *(int16_t *)pValue;
1834 //ALOGV("\tReverb_setParameter() REVERB_PARAM_DECAY_DIFFUSION value is %d", ratio);
1835 //ALOGV("\tReverb_setParameter() Calling ReverbSetDiffusion");
1836 ReverbSetDiffusion(pContext, ratio);
1837 //ALOGV("\tReverb_setParameter() Called ReverbSetDiffusion");
1838 break;
1839 case REVERB_PARAM_DENSITY:
1840 ratio = *(int16_t *)pValue;
1841 //ALOGV("\tReverb_setParameter() REVERB_PARAM_DECAY_DENSITY value is %d", ratio);
1842 //ALOGV("\tReverb_setParameter() Calling ReverbSetDensity");
1843 ReverbSetDensity(pContext, ratio);
1844 //ALOGV("\tReverb_setParameter() Called ReverbSetDensity");
1845 break;
1846 break;
1847 case REVERB_PARAM_REFLECTIONS_LEVEL:
1848 case REVERB_PARAM_REFLECTIONS_DELAY:
1849 case REVERB_PARAM_REVERB_DELAY:
1850 break;
1851 default:
1852 ALOGV("\tLVM_ERROR : Reverb_setParameter() invalid param %d", param);
1853 break;
1854 }
1855
1856 //ALOGV("\tReverb_setParameter end");
1857 return status;
1858 } /* end Reverb_setParameter */
1859
1860
1861 /**
1862 * returns the size in bytes of the value of each environmental reverb parameter
1863 */
Reverb_paramValueSize(int32_t param)1864 int Reverb_paramValueSize(int32_t param) {
1865 switch (param) {
1866 case REVERB_PARAM_ROOM_LEVEL:
1867 case REVERB_PARAM_ROOM_HF_LEVEL:
1868 case REVERB_PARAM_REFLECTIONS_LEVEL:
1869 case REVERB_PARAM_REVERB_LEVEL:
1870 return sizeof(int16_t); // millibel
1871 case REVERB_PARAM_DECAY_TIME:
1872 case REVERB_PARAM_REFLECTIONS_DELAY:
1873 case REVERB_PARAM_REVERB_DELAY:
1874 return sizeof(uint32_t); // milliseconds
1875 case REVERB_PARAM_DECAY_HF_RATIO:
1876 case REVERB_PARAM_DIFFUSION:
1877 case REVERB_PARAM_DENSITY:
1878 return sizeof(int16_t); // permille
1879 case REVERB_PARAM_PROPERTIES:
1880 return sizeof(s_reverb_settings); // struct of all reverb properties
1881 }
1882 return sizeof(int32_t);
1883 }
1884
1885 } // namespace
1886 } // namespace
1887
1888 extern "C" {
1889 /* Effect Control Interface Implementation: Process */
Reverb_process(effect_handle_t self,audio_buffer_t * inBuffer,audio_buffer_t * outBuffer)1890 int Reverb_process(effect_handle_t self,
1891 audio_buffer_t *inBuffer,
1892 audio_buffer_t *outBuffer){
1893 android::ReverbContext * pContext = (android::ReverbContext *) self;
1894 int status = 0;
1895
1896 if (pContext == NULL){
1897 ALOGV("\tLVM_ERROR : Reverb_process() ERROR pContext == NULL");
1898 return -EINVAL;
1899 }
1900 if (inBuffer == NULL || inBuffer->raw == NULL ||
1901 outBuffer == NULL || outBuffer->raw == NULL ||
1902 inBuffer->frameCount != outBuffer->frameCount){
1903 ALOGV("\tLVM_ERROR : Reverb_process() ERROR NULL INPUT POINTER OR FRAME COUNT IS WRONG");
1904 return -EINVAL;
1905 }
1906 //ALOGV("\tReverb_process() Calling process with %d frames", outBuffer->frameCount);
1907 /* Process all the available frames, block processing is handled internalLY by the LVM bundle */
1908 status = process( (LVM_INT16 *)inBuffer->raw,
1909 (LVM_INT16 *)outBuffer->raw,
1910 outBuffer->frameCount,
1911 pContext);
1912
1913 if (pContext->bEnabled == LVM_FALSE) {
1914 if (pContext->SamplesToExitCount > 0) {
1915 pContext->SamplesToExitCount -= outBuffer->frameCount;
1916 } else {
1917 status = -ENODATA;
1918 }
1919 }
1920
1921 return status;
1922 } /* end Reverb_process */
1923
1924 /* Effect Control Interface Implementation: Command */
Reverb_command(effect_handle_t self,uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)1925 int Reverb_command(effect_handle_t self,
1926 uint32_t cmdCode,
1927 uint32_t cmdSize,
1928 void *pCmdData,
1929 uint32_t *replySize,
1930 void *pReplyData){
1931 android::ReverbContext * pContext = (android::ReverbContext *) self;
1932 LVREV_ControlParams_st ActiveParams; /* Current control Parameters */
1933 LVREV_ReturnStatus_en LvmStatus=LVREV_SUCCESS; /* Function call status */
1934
1935
1936 if (pContext == NULL){
1937 ALOGV("\tLVM_ERROR : Reverb_command ERROR pContext == NULL");
1938 return -EINVAL;
1939 }
1940
1941 //ALOGV("\tReverb_command INPUTS are: command %d cmdSize %d",cmdCode, cmdSize);
1942
1943 switch (cmdCode){
1944 case EFFECT_CMD_INIT:
1945 //ALOGV("\tReverb_command cmdCode Case: "
1946 // "EFFECT_CMD_INIT start");
1947
1948 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)){
1949 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
1950 "EFFECT_CMD_INIT: ERROR");
1951 return -EINVAL;
1952 }
1953 *(int *) pReplyData = 0;
1954 break;
1955
1956 case EFFECT_CMD_SET_CONFIG:
1957 //ALOGV("\tReverb_command cmdCode Case: "
1958 // "EFFECT_CMD_SET_CONFIG start");
1959 if (pCmdData == NULL || cmdSize != sizeof(effect_config_t) ||
1960 pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
1961 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
1962 "EFFECT_CMD_SET_CONFIG: ERROR");
1963 return -EINVAL;
1964 }
1965 *(int *) pReplyData = android::Reverb_setConfig(pContext,
1966 (effect_config_t *) pCmdData);
1967 break;
1968
1969 case EFFECT_CMD_GET_CONFIG:
1970 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(effect_config_t)) {
1971 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
1972 "EFFECT_CMD_GET_CONFIG: ERROR");
1973 return -EINVAL;
1974 }
1975
1976 android::Reverb_getConfig(pContext, (effect_config_t *)pReplyData);
1977 break;
1978
1979 case EFFECT_CMD_RESET:
1980 //ALOGV("\tReverb_command cmdCode Case: "
1981 // "EFFECT_CMD_RESET start");
1982 Reverb_setConfig(pContext, &pContext->config);
1983 break;
1984
1985 case EFFECT_CMD_GET_PARAM:{
1986 //ALOGV("\tReverb_command cmdCode Case: "
1987 // "EFFECT_CMD_GET_PARAM start");
1988 effect_param_t *p = (effect_param_t *)pCmdData;
1989 if (SIZE_MAX - sizeof(effect_param_t) < (size_t)p->psize) {
1990 android_errorWriteLog(0x534e4554, "26347509");
1991 return -EINVAL;
1992 }
1993 if (pCmdData == NULL || cmdSize < sizeof(effect_param_t) ||
1994 cmdSize < (sizeof(effect_param_t) + p->psize) ||
1995 pReplyData == NULL || replySize == NULL ||
1996 *replySize < (sizeof(effect_param_t) + p->psize)) {
1997 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
1998 "EFFECT_CMD_GET_PARAM: ERROR");
1999 return -EINVAL;
2000 }
2001
2002 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
2003
2004 p = (effect_param_t *)pReplyData;
2005
2006 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
2007
2008 p->status = android::Reverb_getParameter(pContext,
2009 (void *)p->data,
2010 &p->vsize,
2011 p->data + voffset);
2012
2013 *replySize = sizeof(effect_param_t) + voffset + p->vsize;
2014
2015 //ALOGV("\tReverb_command EFFECT_CMD_GET_PARAM "
2016 // "*pCmdData %d, *replySize %d, *pReplyData %d ",
2017 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
2018 // *replySize,
2019 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset));
2020
2021 } break;
2022 case EFFECT_CMD_SET_PARAM:{
2023
2024 //ALOGV("\tReverb_command cmdCode Case: "
2025 // "EFFECT_CMD_SET_PARAM start");
2026 //ALOGV("\tReverb_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ",
2027 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
2028 // *replySize,
2029 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t)));
2030
2031 if (pCmdData == NULL || (cmdSize < (sizeof(effect_param_t) + sizeof(int32_t))) ||
2032 pReplyData == NULL || replySize == NULL || *replySize != sizeof(int32_t)) {
2033 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2034 "EFFECT_CMD_SET_PARAM: ERROR");
2035 return -EINVAL;
2036 }
2037
2038 effect_param_t *p = (effect_param_t *) pCmdData;
2039
2040 if (p->psize != sizeof(int32_t)){
2041 ALOGV("\t4LVM_ERROR : Reverb_command cmdCode Case: "
2042 "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)");
2043 return -EINVAL;
2044 }
2045
2046 //ALOGV("\tn5Reverb_command cmdSize is %d\n"
2047 // "\tsizeof(effect_param_t) is %d\n"
2048 // "\tp->psize is %d\n"
2049 // "\tp->vsize is %d"
2050 // "\n",
2051 // cmdSize, sizeof(effect_param_t), p->psize, p->vsize );
2052
2053 *(int *)pReplyData = android::Reverb_setParameter(pContext,
2054 (void *)p->data,
2055 p->data + p->psize,
2056 p->vsize);
2057 } break;
2058
2059 case EFFECT_CMD_ENABLE:
2060 //ALOGV("\tReverb_command cmdCode Case: "
2061 // "EFFECT_CMD_ENABLE start");
2062
2063 if (pReplyData == NULL || *replySize != sizeof(int)){
2064 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2065 "EFFECT_CMD_ENABLE: ERROR");
2066 return -EINVAL;
2067 }
2068 if(pContext->bEnabled == LVM_TRUE){
2069 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2070 "EFFECT_CMD_ENABLE: ERROR-Effect is already enabled");
2071 return -EINVAL;
2072 }
2073 *(int *)pReplyData = 0;
2074 pContext->bEnabled = LVM_TRUE;
2075 /* Get the current settings */
2076 LvmStatus = LVREV_GetControlParameters(pContext->hInstance, &ActiveParams);
2077 LVM_ERROR_CHECK(LvmStatus, "LVREV_GetControlParameters", "EFFECT_CMD_ENABLE")
2078 pContext->SamplesToExitCount =
2079 (ActiveParams.T60 * pContext->config.inputCfg.samplingRate)/1000;
2080 // force no volume ramp for first buffer processed after enabling the effect
2081 pContext->volumeMode = android::REVERB_VOLUME_FLAT;
2082 //ALOGV("\tEFFECT_CMD_ENABLE SamplesToExitCount = %d", pContext->SamplesToExitCount);
2083 break;
2084 case EFFECT_CMD_DISABLE:
2085 //ALOGV("\tReverb_command cmdCode Case: "
2086 // "EFFECT_CMD_DISABLE start");
2087
2088 if (pReplyData == NULL || *replySize != sizeof(int)){
2089 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2090 "EFFECT_CMD_DISABLE: ERROR");
2091 return -EINVAL;
2092 }
2093 if(pContext->bEnabled == LVM_FALSE){
2094 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2095 "EFFECT_CMD_DISABLE: ERROR-Effect is not yet enabled");
2096 return -EINVAL;
2097 }
2098 *(int *)pReplyData = 0;
2099 pContext->bEnabled = LVM_FALSE;
2100 break;
2101
2102 case EFFECT_CMD_SET_VOLUME:
2103 if (pCmdData == NULL ||
2104 cmdSize != 2 * sizeof(uint32_t)) {
2105 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2106 "EFFECT_CMD_SET_VOLUME: ERROR");
2107 return -EINVAL;
2108 }
2109
2110
2111 if (pReplyData != NULL) { // we have volume control
2112 pContext->leftVolume = (LVM_INT16)((*(uint32_t *)pCmdData + (1 << 11)) >> 12);
2113 pContext->rightVolume = (LVM_INT16)((*((uint32_t *)pCmdData + 1) + (1 << 11)) >> 12);
2114 *(uint32_t *)pReplyData = (1 << 24);
2115 *((uint32_t *)pReplyData + 1) = (1 << 24);
2116 if (pContext->volumeMode == android::REVERB_VOLUME_OFF) {
2117 // force no volume ramp for first buffer processed after getting volume control
2118 pContext->volumeMode = android::REVERB_VOLUME_FLAT;
2119 }
2120 } else { // we don't have volume control
2121 pContext->leftVolume = REVERB_UNIT_VOLUME;
2122 pContext->rightVolume = REVERB_UNIT_VOLUME;
2123 pContext->volumeMode = android::REVERB_VOLUME_OFF;
2124 }
2125 ALOGV("EFFECT_CMD_SET_VOLUME left %d, right %d mode %d",
2126 pContext->leftVolume, pContext->rightVolume, pContext->volumeMode);
2127 break;
2128
2129 case EFFECT_CMD_SET_DEVICE:
2130 case EFFECT_CMD_SET_AUDIO_MODE:
2131 //ALOGV("\tReverb_command cmdCode Case: "
2132 // "EFFECT_CMD_SET_DEVICE/EFFECT_CMD_SET_VOLUME/EFFECT_CMD_SET_AUDIO_MODE start");
2133 break;
2134
2135 default:
2136 ALOGV("\tLVM_ERROR : Reverb_command cmdCode Case: "
2137 "DEFAULT start %d ERROR",cmdCode);
2138 return -EINVAL;
2139 }
2140
2141 //ALOGV("\tReverb_command end\n\n");
2142 return 0;
2143 } /* end Reverb_command */
2144
2145 /* Effect Control Interface Implementation: get_descriptor */
Reverb_getDescriptor(effect_handle_t self,effect_descriptor_t * pDescriptor)2146 int Reverb_getDescriptor(effect_handle_t self,
2147 effect_descriptor_t *pDescriptor)
2148 {
2149 android::ReverbContext * pContext = (android::ReverbContext *)self;
2150 const effect_descriptor_t *desc;
2151
2152 if (pContext == NULL || pDescriptor == NULL) {
2153 ALOGV("Reverb_getDescriptor() invalid param");
2154 return -EINVAL;
2155 }
2156
2157 if (pContext->auxiliary) {
2158 if (pContext->preset) {
2159 desc = &android::gAuxPresetReverbDescriptor;
2160 } else {
2161 desc = &android::gAuxEnvReverbDescriptor;
2162 }
2163 } else {
2164 if (pContext->preset) {
2165 desc = &android::gInsertPresetReverbDescriptor;
2166 } else {
2167 desc = &android::gInsertEnvReverbDescriptor;
2168 }
2169 }
2170
2171 *pDescriptor = *desc;
2172
2173 return 0;
2174 } /* end Reverb_getDescriptor */
2175
2176 // effect_handle_t interface implementation for Reverb effect
2177 const struct effect_interface_s gReverbInterface = {
2178 Reverb_process,
2179 Reverb_command,
2180 Reverb_getDescriptor,
2181 NULL,
2182 }; /* end gReverbInterface */
2183
2184 // This is the only symbol that needs to be exported
2185 __attribute__ ((visibility ("default")))
2186 audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
2187 .tag = AUDIO_EFFECT_LIBRARY_TAG,
2188 .version = EFFECT_LIBRARY_API_VERSION,
2189 .name = "Reverb Library",
2190 .implementor = "NXP Software Ltd.",
2191 .create_effect = android::EffectCreate,
2192 .release_effect = android::EffectRelease,
2193 .get_descriptor = android::EffectGetDescriptor,
2194 };
2195
2196 }
2197