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