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