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