EffectBundle.cpp revision 02521e37c0494b83947c35160f3669de8adc9e5b
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 "Bundle" 19#define ARRAY_SIZE(array) (sizeof array / sizeof array[0]) 20//#define LOG_NDEBUG 0 21 22#include <assert.h> 23#include <inttypes.h> 24#include <new> 25#include <stdlib.h> 26#include <string.h> 27 28#include <cutils/log.h> 29#include "EffectBundle.h" 30 31 32// effect_handle_t interface implementation for bass boost 33extern "C" const struct effect_interface_s gLvmEffectInterface; 34 35#define LVM_ERROR_CHECK(LvmStatus, callingFunc, calledFunc){\ 36 if (LvmStatus == LVM_NULLADDRESS){\ 37 ALOGV("\tLVM_ERROR : Parameter error - "\ 38 "null pointer returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\ 39 }\ 40 if (LvmStatus == LVM_ALIGNMENTERROR){\ 41 ALOGV("\tLVM_ERROR : Parameter error - "\ 42 "bad alignment returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\ 43 }\ 44 if (LvmStatus == LVM_INVALIDNUMSAMPLES){\ 45 ALOGV("\tLVM_ERROR : Parameter error - "\ 46 "bad number of samples returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\ 47 }\ 48 if (LvmStatus == LVM_OUTOFRANGE){\ 49 ALOGV("\tLVM_ERROR : Parameter error - "\ 50 "out of range returned by %s in %s\n", callingFunc, calledFunc);\ 51 }\ 52 } 53 54 55static inline int16_t clamp16(int32_t sample) 56{ 57 // check overflow for both positive and negative values: 58 // all bits above short range must me equal to sign bit 59 if ((sample>>15) ^ (sample>>31)) 60 sample = 0x7FFF ^ (sample>>31); 61 return sample; 62} 63 64// Namespaces 65namespace android { 66namespace { 67 68// Flag to allow a one time init of global memory, only happens on first call ever 69int LvmInitFlag = LVM_FALSE; 70SessionContext GlobalSessionMemory[LVM_MAX_SESSIONS]; 71int SessionIndex[LVM_MAX_SESSIONS]; 72 73/* local functions */ 74#define CHECK_ARG(cond) { \ 75 if (!(cond)) { \ 76 ALOGV("\tLVM_ERROR : Invalid argument: "#cond); \ 77 return -EINVAL; \ 78 } \ 79} 80 81 82// NXP SW BassBoost UUID 83const effect_descriptor_t gBassBoostDescriptor = { 84 {0x0634f220, 0xddd4, 0x11db, 0xa0fc, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }}, 85 {0x8631f300, 0x72e2, 0x11df, 0xb57e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid 86 EFFECT_CONTROL_API_VERSION, 87 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST | EFFECT_FLAG_DEVICE_IND 88 | EFFECT_FLAG_VOLUME_CTRL), 89 BASS_BOOST_CUP_LOAD_ARM9E, 90 BUNDLE_MEM_USAGE, 91 "Dynamic Bass Boost", 92 "NXP Software Ltd.", 93}; 94 95// NXP SW Virtualizer UUID 96const effect_descriptor_t gVirtualizerDescriptor = { 97 {0x37cc2c00, 0xdddd, 0x11db, 0x8577, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, 98 {0x1d4033c0, 0x8557, 0x11df, 0x9f2d, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, 99 EFFECT_CONTROL_API_VERSION, 100 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST | EFFECT_FLAG_DEVICE_IND 101 | EFFECT_FLAG_VOLUME_CTRL), 102 VIRTUALIZER_CUP_LOAD_ARM9E, 103 BUNDLE_MEM_USAGE, 104 "Virtualizer", 105 "NXP Software Ltd.", 106}; 107 108// NXP SW Equalizer UUID 109const effect_descriptor_t gEqualizerDescriptor = { 110 {0x0bed4300, 0xddd6, 0x11db, 0x8f34, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // type 111 {0xce772f20, 0x847d, 0x11df, 0xbb17, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid Eq NXP 112 EFFECT_CONTROL_API_VERSION, 113 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST | EFFECT_FLAG_VOLUME_CTRL), 114 EQUALIZER_CUP_LOAD_ARM9E, 115 BUNDLE_MEM_USAGE, 116 "Equalizer", 117 "NXP Software Ltd.", 118}; 119 120// NXP SW Volume UUID 121const effect_descriptor_t gVolumeDescriptor = { 122 {0x09e8ede0, 0xddde, 0x11db, 0xb4f6, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }}, 123 {0x119341a0, 0x8469, 0x11df, 0x81f9, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }}, //uuid VOL NXP 124 EFFECT_CONTROL_API_VERSION, 125 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST | EFFECT_FLAG_VOLUME_CTRL), 126 VOLUME_CUP_LOAD_ARM9E, 127 BUNDLE_MEM_USAGE, 128 "Volume", 129 "NXP Software Ltd.", 130}; 131 132//--- local function prototypes 133void LvmGlobalBundle_init (void); 134int LvmBundle_init (EffectContext *pContext); 135int LvmEffect_enable (EffectContext *pContext); 136int LvmEffect_disable (EffectContext *pContext); 137void LvmEffect_free (EffectContext *pContext); 138int Effect_setConfig (EffectContext *pContext, effect_config_t *pConfig); 139void Effect_getConfig (EffectContext *pContext, effect_config_t *pConfig); 140int BassBoost_setParameter (EffectContext *pContext, void *pParam, void *pValue); 141int BassBoost_getParameter (EffectContext *pContext, 142 void *pParam, 143 uint32_t *pValueSize, 144 void *pValue); 145int Virtualizer_setParameter (EffectContext *pContext, void *pParam, void *pValue); 146int Virtualizer_getParameter (EffectContext *pContext, 147 void *pParam, 148 uint32_t *pValueSize, 149 void *pValue); 150int Equalizer_setParameter (EffectContext *pContext, void *pParam, void *pValue); 151int Equalizer_getParameter (EffectContext *pContext, 152 void *pParam, 153 uint32_t *pValueSize, 154 void *pValue); 155int Volume_setParameter (EffectContext *pContext, void *pParam, void *pValue); 156int Volume_getParameter (EffectContext *pContext, 157 void *pParam, 158 uint32_t *pValueSize, 159 void *pValue); 160int Effect_setEnabled(EffectContext *pContext, bool enabled); 161 162/* Effect Library Interface Implementation */ 163 164extern "C" int EffectCreate(const effect_uuid_t *uuid, 165 int32_t sessionId, 166 int32_t ioId __unused, 167 effect_handle_t *pHandle){ 168 int ret = 0; 169 int sessionNo; 170 int i; 171 EffectContext *pContext = NULL; 172 bool newBundle = false; 173 SessionContext *pSessionContext; 174 175 ALOGV("\n\tEffectCreate start session %d", sessionId); 176 177 if (pHandle == NULL || uuid == NULL){ 178 ALOGV("\tLVM_ERROR : EffectCreate() called with NULL pointer"); 179 ret = -EINVAL; 180 goto exit; 181 } 182 183 if(LvmInitFlag == LVM_FALSE){ 184 LvmInitFlag = LVM_TRUE; 185 ALOGV("\tEffectCreate - Initializing all global memory"); 186 LvmGlobalBundle_init(); 187 } 188 189 // Find next available sessionNo 190 for(i=0; i<LVM_MAX_SESSIONS; i++){ 191 if((SessionIndex[i] == LVM_UNUSED_SESSION)||(SessionIndex[i] == sessionId)){ 192 sessionNo = i; 193 SessionIndex[i] = sessionId; 194 ALOGV("\tEffectCreate: Allocating SessionNo %d for SessionId %d\n", sessionNo,sessionId); 195 break; 196 } 197 } 198 199 if(i==LVM_MAX_SESSIONS){ 200 ALOGV("\tLVM_ERROR : Cannot find memory to allocate for current session"); 201 ret = -EINVAL; 202 goto exit; 203 } 204 205 pContext = new EffectContext; 206 207 // If this is the first create in this session 208 if(GlobalSessionMemory[sessionNo].bBundledEffectsEnabled == LVM_FALSE){ 209 ALOGV("\tEffectCreate - This is the first effect in current sessionId %d sessionNo %d", 210 sessionId, sessionNo); 211 212 GlobalSessionMemory[sessionNo].bBundledEffectsEnabled = LVM_TRUE; 213 GlobalSessionMemory[sessionNo].pBundledContext = new BundledEffectContext; 214 newBundle = true; 215 216 pContext->pBundledContext = GlobalSessionMemory[sessionNo].pBundledContext; 217 pContext->pBundledContext->SessionNo = sessionNo; 218 pContext->pBundledContext->SessionId = sessionId; 219 pContext->pBundledContext->hInstance = NULL; 220 pContext->pBundledContext->bVolumeEnabled = LVM_FALSE; 221 pContext->pBundledContext->bEqualizerEnabled = LVM_FALSE; 222 pContext->pBundledContext->bBassEnabled = LVM_FALSE; 223 pContext->pBundledContext->bBassTempDisabled = LVM_FALSE; 224 pContext->pBundledContext->bVirtualizerEnabled = LVM_FALSE; 225 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_FALSE; 226 pContext->pBundledContext->nOutputDevice = AUDIO_DEVICE_NONE; 227 pContext->pBundledContext->nVirtualizerForcedDevice = AUDIO_DEVICE_NONE; 228 pContext->pBundledContext->NumberEffectsEnabled = 0; 229 pContext->pBundledContext->NumberEffectsCalled = 0; 230 pContext->pBundledContext->firstVolume = LVM_TRUE; 231 pContext->pBundledContext->volume = 0; 232 233 #ifdef LVM_PCM 234 char fileName[256]; 235 snprintf(fileName, 256, "/data/tmp/bundle_%p_pcm_in.pcm", pContext->pBundledContext); 236 pContext->pBundledContext->PcmInPtr = fopen(fileName, "w"); 237 if (pContext->pBundledContext->PcmInPtr == NULL) { 238 ALOGV("cannot open %s", fileName); 239 ret = -EINVAL; 240 goto exit; 241 } 242 243 snprintf(fileName, 256, "/data/tmp/bundle_%p_pcm_out.pcm", pContext->pBundledContext); 244 pContext->pBundledContext->PcmOutPtr = fopen(fileName, "w"); 245 if (pContext->pBundledContext->PcmOutPtr == NULL) { 246 ALOGV("cannot open %s", fileName); 247 fclose(pContext->pBundledContext->PcmInPtr); 248 pContext->pBundledContext->PcmInPtr = NULL; 249 ret = -EINVAL; 250 goto exit; 251 } 252 #endif 253 254 /* Saved strength is used to return the exact strength that was used in the set to the get 255 * because we map the original strength range of 0:1000 to 1:15, and this will avoid 256 * quantisation like effect when returning 257 */ 258 pContext->pBundledContext->BassStrengthSaved = 0; 259 pContext->pBundledContext->VirtStrengthSaved = 0; 260 pContext->pBundledContext->CurPreset = PRESET_CUSTOM; 261 pContext->pBundledContext->levelSaved = 0; 262 pContext->pBundledContext->bMuteEnabled = LVM_FALSE; 263 pContext->pBundledContext->bStereoPositionEnabled = LVM_FALSE; 264 pContext->pBundledContext->positionSaved = 0; 265 pContext->pBundledContext->workBuffer = NULL; 266 pContext->pBundledContext->frameCount = -1; 267 pContext->pBundledContext->SamplesToExitCountVirt = 0; 268 pContext->pBundledContext->SamplesToExitCountBb = 0; 269 pContext->pBundledContext->SamplesToExitCountEq = 0; 270 271 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 272 pContext->pBundledContext->bandGaindB[i] = EQNB_5BandSoftPresets[i]; 273 } 274 275 ALOGV("\tEffectCreate - Calling LvmBundle_init"); 276 ret = LvmBundle_init(pContext); 277 278 if (ret < 0){ 279 ALOGV("\tLVM_ERROR : EffectCreate() Bundle init failed"); 280 goto exit; 281 } 282 } 283 else{ 284 ALOGV("\tEffectCreate - Assigning memory for previously created effect on sessionNo %d", 285 sessionNo); 286 pContext->pBundledContext = 287 GlobalSessionMemory[sessionNo].pBundledContext; 288 } 289 ALOGV("\tEffectCreate - pBundledContext is %p", pContext->pBundledContext); 290 291 pSessionContext = &GlobalSessionMemory[pContext->pBundledContext->SessionNo]; 292 293 // Create each Effect 294 if (memcmp(uuid, &gBassBoostDescriptor.uuid, sizeof(effect_uuid_t)) == 0){ 295 // Create Bass Boost 296 ALOGV("\tEffectCreate - Effect to be created is LVM_BASS_BOOST"); 297 pSessionContext->bBassInstantiated = LVM_TRUE; 298 pContext->pBundledContext->SamplesToExitCountBb = 0; 299 300 pContext->itfe = &gLvmEffectInterface; 301 pContext->EffectType = LVM_BASS_BOOST; 302 } else if (memcmp(uuid, &gVirtualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0){ 303 // Create Virtualizer 304 ALOGV("\tEffectCreate - Effect to be created is LVM_VIRTUALIZER"); 305 pSessionContext->bVirtualizerInstantiated=LVM_TRUE; 306 pContext->pBundledContext->SamplesToExitCountVirt = 0; 307 308 pContext->itfe = &gLvmEffectInterface; 309 pContext->EffectType = LVM_VIRTUALIZER; 310 } else if (memcmp(uuid, &gEqualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0){ 311 // Create Equalizer 312 ALOGV("\tEffectCreate - Effect to be created is LVM_EQUALIZER"); 313 pSessionContext->bEqualizerInstantiated = LVM_TRUE; 314 pContext->pBundledContext->SamplesToExitCountEq = 0; 315 316 pContext->itfe = &gLvmEffectInterface; 317 pContext->EffectType = LVM_EQUALIZER; 318 } else if (memcmp(uuid, &gVolumeDescriptor.uuid, sizeof(effect_uuid_t)) == 0){ 319 // Create Volume 320 ALOGV("\tEffectCreate - Effect to be created is LVM_VOLUME"); 321 pSessionContext->bVolumeInstantiated = LVM_TRUE; 322 323 pContext->itfe = &gLvmEffectInterface; 324 pContext->EffectType = LVM_VOLUME; 325 } 326 else{ 327 ALOGV("\tLVM_ERROR : EffectCreate() invalid UUID"); 328 ret = -EINVAL; 329 goto exit; 330 } 331 332exit: 333 if (ret != 0) { 334 if (pContext != NULL) { 335 if (newBundle) { 336 GlobalSessionMemory[sessionNo].bBundledEffectsEnabled = LVM_FALSE; 337 SessionIndex[sessionNo] = LVM_UNUSED_SESSION; 338 delete pContext->pBundledContext; 339 } 340 delete pContext; 341 } 342 *pHandle = (effect_handle_t)NULL; 343 } else { 344 *pHandle = (effect_handle_t)pContext; 345 } 346 ALOGV("\tEffectCreate end..\n\n"); 347 return ret; 348} /* end EffectCreate */ 349 350extern "C" int EffectRelease(effect_handle_t handle){ 351 ALOGV("\n\tEffectRelease start %p", handle); 352 EffectContext * pContext = (EffectContext *)handle; 353 354 ALOGV("\tEffectRelease start handle: %p, context %p", handle, pContext->pBundledContext); 355 if (pContext == NULL){ 356 ALOGV("\tLVM_ERROR : EffectRelease called with NULL pointer"); 357 return -EINVAL; 358 } 359 360 SessionContext *pSessionContext = &GlobalSessionMemory[pContext->pBundledContext->SessionNo]; 361 362 // Clear the instantiated flag for the effect 363 // protect agains the case where an effect is un-instantiated without being disabled 364 if(pContext->EffectType == LVM_BASS_BOOST) { 365 ALOGV("\tEffectRelease LVM_BASS_BOOST Clearing global intstantiated flag"); 366 pSessionContext->bBassInstantiated = LVM_FALSE; 367 if(pContext->pBundledContext->SamplesToExitCountBb > 0){ 368 pContext->pBundledContext->NumberEffectsEnabled--; 369 } 370 pContext->pBundledContext->SamplesToExitCountBb = 0; 371 } else if(pContext->EffectType == LVM_VIRTUALIZER) { 372 ALOGV("\tEffectRelease LVM_VIRTUALIZER Clearing global intstantiated flag"); 373 pSessionContext->bVirtualizerInstantiated = LVM_FALSE; 374 if(pContext->pBundledContext->SamplesToExitCountVirt > 0){ 375 pContext->pBundledContext->NumberEffectsEnabled--; 376 } 377 pContext->pBundledContext->SamplesToExitCountVirt = 0; 378 } else if(pContext->EffectType == LVM_EQUALIZER) { 379 ALOGV("\tEffectRelease LVM_EQUALIZER Clearing global intstantiated flag"); 380 pSessionContext->bEqualizerInstantiated =LVM_FALSE; 381 if(pContext->pBundledContext->SamplesToExitCountEq > 0){ 382 pContext->pBundledContext->NumberEffectsEnabled--; 383 } 384 pContext->pBundledContext->SamplesToExitCountEq = 0; 385 } else if(pContext->EffectType == LVM_VOLUME) { 386 ALOGV("\tEffectRelease LVM_VOLUME Clearing global intstantiated flag"); 387 pSessionContext->bVolumeInstantiated = LVM_FALSE; 388 if (pContext->pBundledContext->bVolumeEnabled == LVM_TRUE){ 389 pContext->pBundledContext->NumberEffectsEnabled--; 390 } 391 } else { 392 ALOGV("\tLVM_ERROR : EffectRelease : Unsupported effect\n\n\n\n\n\n\n"); 393 } 394 395 // Disable effect, in this case ignore errors (return codes) 396 // if an effect has already been disabled 397 Effect_setEnabled(pContext, LVM_FALSE); 398 399 // if all effects are no longer instantiaed free the lvm memory and delete BundledEffectContext 400 if ((pSessionContext->bBassInstantiated == LVM_FALSE) && 401 (pSessionContext->bVolumeInstantiated == LVM_FALSE) && 402 (pSessionContext->bEqualizerInstantiated ==LVM_FALSE) && 403 (pSessionContext->bVirtualizerInstantiated==LVM_FALSE)) 404 { 405 #ifdef LVM_PCM 406 if (pContext->pBundledContext->PcmInPtr != NULL) { 407 fclose(pContext->pBundledContext->PcmInPtr); 408 pContext->pBundledContext->PcmInPtr = NULL; 409 } 410 if (pContext->pBundledContext->PcmOutPtr != NULL) { 411 fclose(pContext->pBundledContext->PcmOutPtr); 412 pContext->pBundledContext->PcmOutPtr = NULL; 413 } 414 #endif 415 416 417 // Clear the SessionIndex 418 for(int i=0; i<LVM_MAX_SESSIONS; i++){ 419 if(SessionIndex[i] == pContext->pBundledContext->SessionId){ 420 SessionIndex[i] = LVM_UNUSED_SESSION; 421 ALOGV("\tEffectRelease: Clearing SessionIndex SessionNo %d for SessionId %d\n", 422 i, pContext->pBundledContext->SessionId); 423 break; 424 } 425 } 426 427 ALOGV("\tEffectRelease: All effects are no longer instantiated\n"); 428 pSessionContext->bBundledEffectsEnabled = LVM_FALSE; 429 pSessionContext->pBundledContext = LVM_NULL; 430 ALOGV("\tEffectRelease: Freeing LVM Bundle memory\n"); 431 LvmEffect_free(pContext); 432 ALOGV("\tEffectRelease: Deleting LVM Bundle context %p\n", pContext->pBundledContext); 433 if (pContext->pBundledContext->workBuffer != NULL) { 434 free(pContext->pBundledContext->workBuffer); 435 } 436 delete pContext->pBundledContext; 437 pContext->pBundledContext = LVM_NULL; 438 } 439 // free the effect context for current effect 440 delete pContext; 441 442 ALOGV("\tEffectRelease end\n"); 443 return 0; 444 445} /* end EffectRelease */ 446 447extern "C" int EffectGetDescriptor(const effect_uuid_t *uuid, 448 effect_descriptor_t *pDescriptor) { 449 const effect_descriptor_t *desc = NULL; 450 451 if (pDescriptor == NULL || uuid == NULL){ 452 ALOGV("EffectGetDescriptor() called with NULL pointer"); 453 return -EINVAL; 454 } 455 456 if (memcmp(uuid, &gBassBoostDescriptor.uuid, sizeof(effect_uuid_t)) == 0) { 457 desc = &gBassBoostDescriptor; 458 } else if (memcmp(uuid, &gVirtualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0) { 459 desc = &gVirtualizerDescriptor; 460 } else if (memcmp(uuid, &gEqualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0) { 461 desc = &gEqualizerDescriptor; 462 } else if (memcmp(uuid, &gVolumeDescriptor.uuid, sizeof(effect_uuid_t)) == 0) { 463 desc = &gVolumeDescriptor; 464 } 465 466 if (desc == NULL) { 467 return -EINVAL; 468 } 469 470 *pDescriptor = *desc; 471 472 return 0; 473} /* end EffectGetDescriptor */ 474 475void LvmGlobalBundle_init(){ 476 ALOGV("\tLvmGlobalBundle_init start"); 477 for(int i=0; i<LVM_MAX_SESSIONS; i++){ 478 GlobalSessionMemory[i].bBundledEffectsEnabled = LVM_FALSE; 479 GlobalSessionMemory[i].bVolumeInstantiated = LVM_FALSE; 480 GlobalSessionMemory[i].bEqualizerInstantiated = LVM_FALSE; 481 GlobalSessionMemory[i].bBassInstantiated = LVM_FALSE; 482 GlobalSessionMemory[i].bVirtualizerInstantiated = LVM_FALSE; 483 GlobalSessionMemory[i].pBundledContext = LVM_NULL; 484 485 SessionIndex[i] = LVM_UNUSED_SESSION; 486 } 487 return; 488} 489//---------------------------------------------------------------------------- 490// LvmBundle_init() 491//---------------------------------------------------------------------------- 492// Purpose: Initialize engine with default configuration, creates instance 493// with all effects disabled. 494// 495// Inputs: 496// pContext: effect engine context 497// 498// Outputs: 499// 500//---------------------------------------------------------------------------- 501 502int LvmBundle_init(EffectContext *pContext){ 503 int status; 504 505 ALOGV("\tLvmBundle_init start"); 506 507 pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; 508 pContext->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; 509 pContext->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 510 pContext->config.inputCfg.samplingRate = 44100; 511 pContext->config.inputCfg.bufferProvider.getBuffer = NULL; 512 pContext->config.inputCfg.bufferProvider.releaseBuffer = NULL; 513 pContext->config.inputCfg.bufferProvider.cookie = NULL; 514 pContext->config.inputCfg.mask = EFFECT_CONFIG_ALL; 515 pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE; 516 pContext->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; 517 pContext->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 518 pContext->config.outputCfg.samplingRate = 44100; 519 pContext->config.outputCfg.bufferProvider.getBuffer = NULL; 520 pContext->config.outputCfg.bufferProvider.releaseBuffer = NULL; 521 pContext->config.outputCfg.bufferProvider.cookie = NULL; 522 pContext->config.outputCfg.mask = EFFECT_CONFIG_ALL; 523 524 CHECK_ARG(pContext != NULL); 525 526 if (pContext->pBundledContext->hInstance != NULL){ 527 ALOGV("\tLvmBundle_init pContext->pBassBoost != NULL " 528 "-> Calling pContext->pBassBoost->free()"); 529 530 LvmEffect_free(pContext); 531 532 ALOGV("\tLvmBundle_init pContext->pBassBoost != NULL " 533 "-> Called pContext->pBassBoost->free()"); 534 } 535 536 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 537 LVM_ControlParams_t params; /* Control Parameters */ 538 LVM_InstParams_t InstParams; /* Instance parameters */ 539 LVM_EQNB_BandDef_t BandDefs[MAX_NUM_BANDS]; /* Equaliser band definitions */ 540 LVM_HeadroomParams_t HeadroomParams; /* Headroom parameters */ 541 LVM_HeadroomBandDef_t HeadroomBandDef[LVM_HEADROOM_MAX_NBANDS]; 542 LVM_MemTab_t MemTab; /* Memory allocation table */ 543 bool bMallocFailure = LVM_FALSE; 544 545 /* Set the capabilities */ 546 InstParams.BufferMode = LVM_UNMANAGED_BUFFERS; 547 InstParams.MaxBlockSize = MAX_CALL_SIZE; 548 InstParams.EQNB_NumBands = MAX_NUM_BANDS; 549 InstParams.PSA_Included = LVM_PSA_ON; 550 551 /* Allocate memory, forcing alignment */ 552 LvmStatus = LVM_GetMemoryTable(LVM_NULL, 553 &MemTab, 554 &InstParams); 555 556 LVM_ERROR_CHECK(LvmStatus, "LVM_GetMemoryTable", "LvmBundle_init") 557 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 558 559 ALOGV("\tCreateInstance Succesfully called LVM_GetMemoryTable\n"); 560 561 /* Allocate memory */ 562 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){ 563 if (MemTab.Region[i].Size != 0){ 564 MemTab.Region[i].pBaseAddress = malloc(MemTab.Region[i].Size); 565 566 if (MemTab.Region[i].pBaseAddress == LVM_NULL){ 567 ALOGV("\tLVM_ERROR :LvmBundle_init CreateInstance Failed to allocate %" PRIu32 568 " bytes for region %u\n", MemTab.Region[i].Size, i ); 569 bMallocFailure = LVM_TRUE; 570 }else{ 571 ALOGV("\tLvmBundle_init CreateInstance allocated %" PRIu32 572 " bytes for region %u at %p\n", 573 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 574 } 575 } 576 } 577 578 /* If one or more of the memory regions failed to allocate, free the regions that were 579 * succesfully allocated and return with an error 580 */ 581 if(bMallocFailure == LVM_TRUE){ 582 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){ 583 if (MemTab.Region[i].pBaseAddress == LVM_NULL){ 584 ALOGV("\tLVM_ERROR :LvmBundle_init CreateInstance Failed to allocate %" PRIu32 585 " bytes for region %u Not freeing\n", MemTab.Region[i].Size, i ); 586 }else{ 587 ALOGV("\tLVM_ERROR :LvmBundle_init CreateInstance Failed: but allocated %" PRIu32 588 " bytes for region %u at %p- free\n", 589 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 590 free(MemTab.Region[i].pBaseAddress); 591 } 592 } 593 return -EINVAL; 594 } 595 ALOGV("\tLvmBundle_init CreateInstance Succesfully malloc'd memory\n"); 596 597 /* Initialise */ 598 pContext->pBundledContext->hInstance = LVM_NULL; 599 600 /* Init sets the instance handle */ 601 LvmStatus = LVM_GetInstanceHandle(&pContext->pBundledContext->hInstance, 602 &MemTab, 603 &InstParams); 604 605 LVM_ERROR_CHECK(LvmStatus, "LVM_GetInstanceHandle", "LvmBundle_init") 606 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 607 608 ALOGV("\tLvmBundle_init CreateInstance Succesfully called LVM_GetInstanceHandle\n"); 609 610 /* Set the initial process parameters */ 611 /* General parameters */ 612 params.OperatingMode = LVM_MODE_ON; 613 params.SampleRate = LVM_FS_44100; 614 params.SourceFormat = LVM_STEREO; 615 params.SpeakerType = LVM_HEADPHONES; 616 617 pContext->pBundledContext->SampleRate = LVM_FS_44100; 618 619 /* Concert Sound parameters */ 620 params.VirtualizerOperatingMode = LVM_MODE_OFF; 621 params.VirtualizerType = LVM_CONCERTSOUND; 622 params.VirtualizerReverbLevel = 100; 623 params.CS_EffectLevel = LVM_CS_EFFECT_NONE; 624 625 /* N-Band Equaliser parameters */ 626 params.EQNB_OperatingMode = LVM_EQNB_OFF; 627 params.EQNB_NBands = FIVEBAND_NUMBANDS; 628 params.pEQNB_BandDefinition = &BandDefs[0]; 629 630 for (int i=0; i<FIVEBAND_NUMBANDS; i++) 631 { 632 BandDefs[i].Frequency = EQNB_5BandPresetsFrequencies[i]; 633 BandDefs[i].QFactor = EQNB_5BandPresetsQFactors[i]; 634 BandDefs[i].Gain = EQNB_5BandSoftPresets[i]; 635 } 636 637 /* Volume Control parameters */ 638 params.VC_EffectLevel = 0; 639 params.VC_Balance = 0; 640 641 /* Treble Enhancement parameters */ 642 params.TE_OperatingMode = LVM_TE_OFF; 643 params.TE_EffectLevel = 0; 644 645 /* PSA Control parameters */ 646 params.PSA_Enable = LVM_PSA_OFF; 647 params.PSA_PeakDecayRate = (LVM_PSA_DecaySpeed_en)0; 648 649 /* Bass Enhancement parameters */ 650 params.BE_OperatingMode = LVM_BE_OFF; 651 params.BE_EffectLevel = 0; 652 params.BE_CentreFreq = LVM_BE_CENTRE_90Hz; 653 params.BE_HPF = LVM_BE_HPF_ON; 654 655 /* PSA Control parameters */ 656 params.PSA_Enable = LVM_PSA_OFF; 657 params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM; 658 659 /* TE Control parameters */ 660 params.TE_OperatingMode = LVM_TE_OFF; 661 params.TE_EffectLevel = 0; 662 663 /* Activate the initial settings */ 664 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, 665 ¶ms); 666 667 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmBundle_init") 668 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 669 670 ALOGV("\tLvmBundle_init CreateInstance Succesfully called LVM_SetControlParameters\n"); 671 672 /* Set the headroom parameters */ 673 HeadroomBandDef[0].Limit_Low = 20; 674 HeadroomBandDef[0].Limit_High = 4999; 675 HeadroomBandDef[0].Headroom_Offset = 0; 676 HeadroomBandDef[1].Limit_Low = 5000; 677 HeadroomBandDef[1].Limit_High = 24000; 678 HeadroomBandDef[1].Headroom_Offset = 0; 679 HeadroomParams.pHeadroomDefinition = &HeadroomBandDef[0]; 680 HeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON; 681 HeadroomParams.NHeadroomBands = 2; 682 683 LvmStatus = LVM_SetHeadroomParams(pContext->pBundledContext->hInstance, 684 &HeadroomParams); 685 686 LVM_ERROR_CHECK(LvmStatus, "LVM_SetHeadroomParams", "LvmBundle_init") 687 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 688 689 ALOGV("\tLvmBundle_init CreateInstance Succesfully called LVM_SetHeadroomParams\n"); 690 ALOGV("\tLvmBundle_init End"); 691 return 0; 692} /* end LvmBundle_init */ 693 694 695//---------------------------------------------------------------------------- 696// LvmBundle_process() 697//---------------------------------------------------------------------------- 698// Purpose: 699// Apply LVM Bundle effects 700// 701// Inputs: 702// pIn: pointer to stereo 16 bit input data 703// pOut: pointer to stereo 16 bit output data 704// frameCount: Frames to process 705// pContext: effect engine context 706// strength strength to be applied 707// 708// Outputs: 709// pOut: pointer to updated stereo 16 bit output data 710// 711//---------------------------------------------------------------------------- 712 713int LvmBundle_process(LVM_INT16 *pIn, 714 LVM_INT16 *pOut, 715 int frameCount, 716 EffectContext *pContext){ 717 718 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 719 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 720 LVM_INT16 *pOutTmp; 721 722 if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE){ 723 pOutTmp = pOut; 724 }else if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE){ 725 if (pContext->pBundledContext->frameCount != frameCount) { 726 if (pContext->pBundledContext->workBuffer != NULL) { 727 free(pContext->pBundledContext->workBuffer); 728 } 729 pContext->pBundledContext->workBuffer = 730 (LVM_INT16 *)malloc(frameCount * sizeof(LVM_INT16) * 2); 731 pContext->pBundledContext->frameCount = frameCount; 732 } 733 pOutTmp = pContext->pBundledContext->workBuffer; 734 }else{ 735 ALOGV("LVM_ERROR : LvmBundle_process invalid access mode"); 736 return -EINVAL; 737 } 738 739 #ifdef LVM_PCM 740 fwrite(pIn, frameCount*sizeof(LVM_INT16)*2, 1, pContext->pBundledContext->PcmInPtr); 741 fflush(pContext->pBundledContext->PcmInPtr); 742 #endif 743 744 //ALOGV("Calling LVM_Process"); 745 746 /* Process the samples */ 747 LvmStatus = LVM_Process(pContext->pBundledContext->hInstance, /* Instance handle */ 748 pIn, /* Input buffer */ 749 pOutTmp, /* Output buffer */ 750 (LVM_UINT16)frameCount, /* Number of samples to read */ 751 0); /* Audo Time */ 752 753 LVM_ERROR_CHECK(LvmStatus, "LVM_Process", "LvmBundle_process") 754 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 755 756 #ifdef LVM_PCM 757 fwrite(pOutTmp, frameCount*sizeof(LVM_INT16)*2, 1, pContext->pBundledContext->PcmOutPtr); 758 fflush(pContext->pBundledContext->PcmOutPtr); 759 #endif 760 761 if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE){ 762 for (int i=0; i<frameCount*2; i++){ 763 pOut[i] = clamp16((LVM_INT32)pOut[i] + (LVM_INT32)pOutTmp[i]); 764 } 765 } 766 return 0; 767} /* end LvmBundle_process */ 768 769 770//---------------------------------------------------------------------------- 771// EqualizerUpdateActiveParams() 772//---------------------------------------------------------------------------- 773// Purpose: Update ActiveParams for Equalizer 774// 775// Inputs: 776// pContext: effect engine context 777// 778// Outputs: 779// 780//---------------------------------------------------------------------------- 781void EqualizerUpdateActiveParams(EffectContext *pContext) { 782 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 783 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 784 785 /* Get the current settings */ 786 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 787 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "EqualizerUpdateActiveParams") 788 //ALOGV("\tEqualizerUpdateActiveParams Succesfully returned from LVM_GetControlParameters\n"); 789 //ALOGV("\tEqualizerUpdateActiveParams just Got -> %d\n", 790 // ActiveParams.pEQNB_BandDefinition[band].Gain); 791 792 793 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 794 ActiveParams.pEQNB_BandDefinition[i].Frequency = EQNB_5BandPresetsFrequencies[i]; 795 ActiveParams.pEQNB_BandDefinition[i].QFactor = EQNB_5BandPresetsQFactors[i]; 796 ActiveParams.pEQNB_BandDefinition[i].Gain = pContext->pBundledContext->bandGaindB[i]; 797 } 798 799 /* Activate the initial settings */ 800 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 801 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "EqualizerUpdateActiveParams") 802 //ALOGV("\tEqualizerUpdateActiveParams just Set -> %d\n", 803 // ActiveParams.pEQNB_BandDefinition[band].Gain); 804 805} 806 807//---------------------------------------------------------------------------- 808// LvmEffect_limitLevel() 809//---------------------------------------------------------------------------- 810// Purpose: limit the overall level to a value less than 0 dB preserving 811// the overall EQ band gain and BassBoost relative levels. 812// 813// Inputs: 814// pContext: effect engine context 815// 816// Outputs: 817// 818//---------------------------------------------------------------------------- 819void LvmEffect_limitLevel(EffectContext *pContext) { 820 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 821 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 822 823 /* Get the current settings */ 824 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 825 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_limitLevel") 826 //ALOGV("\tLvmEffect_limitLevel Succesfully returned from LVM_GetControlParameters\n"); 827 //ALOGV("\tLvmEffect_limitLevel just Got -> %d\n", 828 // ActiveParams.pEQNB_BandDefinition[band].Gain); 829 830 int gainCorrection = 0; 831 //Count the energy contribution per band for EQ and BassBoost only if they are active. 832 float energyContribution = 0; 833 834 //EQ contribution 835 if (pContext->pBundledContext->bEqualizerEnabled == LVM_TRUE) { 836 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 837 float bandEnergy = (pContext->pBundledContext->bandGaindB[i] * 838 LimitLevel_bandEnergyContribution[i])/15.0; 839 if (bandEnergy > 0) 840 energyContribution += bandEnergy; 841 } 842 } 843 844 //BassBoost contribution 845 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 846 float bandEnergy = (pContext->pBundledContext->BassStrengthSaved * 847 LimitLevel_bassBoostEnergyContribution)/1000.0; 848 if (bandEnergy > 0) 849 energyContribution += bandEnergy; 850 } 851 852 //Virtualizer contribution 853 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) { 854 energyContribution += LimitLevel_virtualizerContribution; 855 } 856 857 //roundoff 858 int maxLevelRound = (int)(energyContribution + 0.99); 859 if (maxLevelRound + pContext->pBundledContext->volume > 0) { 860 gainCorrection = maxLevelRound + pContext->pBundledContext->volume; 861 } 862 863 ActiveParams.VC_EffectLevel = pContext->pBundledContext->volume - gainCorrection; 864 if (ActiveParams.VC_EffectLevel < -96) { 865 ActiveParams.VC_EffectLevel = -96; 866 } 867 ALOGV("\tVol:%d, GainCorrection: %d, Actual vol: %d", pContext->pBundledContext->volume, 868 gainCorrection, ActiveParams.VC_EffectLevel); 869 870 /* Activate the initial settings */ 871 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 872 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_limitLevel") 873 //ALOGV("\tLvmEffect_limitLevel just Set -> %d\n", 874 // ActiveParams.pEQNB_BandDefinition[band].Gain); 875 876 //ALOGV("\tLvmEffect_limitLevel just set (-96dB -> 0dB) -> %d\n",ActiveParams.VC_EffectLevel ); 877 if (pContext->pBundledContext->firstVolume == LVM_TRUE){ 878 LvmStatus = LVM_SetVolumeNoSmoothing(pContext->pBundledContext->hInstance, &ActiveParams); 879 LVM_ERROR_CHECK(LvmStatus, "LVM_SetVolumeNoSmoothing", "LvmBundle_process") 880 ALOGV("\tLVM_VOLUME: Disabling Smoothing for first volume change to remove spikes/clicks"); 881 pContext->pBundledContext->firstVolume = LVM_FALSE; 882 } 883} 884 885//---------------------------------------------------------------------------- 886// LvmEffect_enable() 887//---------------------------------------------------------------------------- 888// Purpose: Enable the effect in the bundle 889// 890// Inputs: 891// pContext: effect engine context 892// 893// Outputs: 894// 895//---------------------------------------------------------------------------- 896 897int LvmEffect_enable(EffectContext *pContext){ 898 //ALOGV("\tLvmEffect_enable start"); 899 900 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 901 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 902 903 /* Get the current settings */ 904 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 905 &ActiveParams); 906 907 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_enable") 908 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 909 //ALOGV("\tLvmEffect_enable Succesfully called LVM_GetControlParameters\n"); 910 911 if(pContext->EffectType == LVM_BASS_BOOST) { 912 ALOGV("\tLvmEffect_enable : Enabling LVM_BASS_BOOST"); 913 ActiveParams.BE_OperatingMode = LVM_BE_ON; 914 } 915 if(pContext->EffectType == LVM_VIRTUALIZER) { 916 ALOGV("\tLvmEffect_enable : Enabling LVM_VIRTUALIZER"); 917 ActiveParams.VirtualizerOperatingMode = LVM_MODE_ON; 918 } 919 if(pContext->EffectType == LVM_EQUALIZER) { 920 ALOGV("\tLvmEffect_enable : Enabling LVM_EQUALIZER"); 921 ActiveParams.EQNB_OperatingMode = LVM_EQNB_ON; 922 } 923 if(pContext->EffectType == LVM_VOLUME) { 924 ALOGV("\tLvmEffect_enable : Enabling LVM_VOLUME"); 925 } 926 927 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 928 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_enable") 929 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 930 931 //ALOGV("\tLvmEffect_enable Succesfully called LVM_SetControlParameters\n"); 932 //ALOGV("\tLvmEffect_enable end"); 933 LvmEffect_limitLevel(pContext); 934 return 0; 935} 936 937//---------------------------------------------------------------------------- 938// LvmEffect_disable() 939//---------------------------------------------------------------------------- 940// Purpose: Disable the effect in the bundle 941// 942// Inputs: 943// pContext: effect engine context 944// 945// Outputs: 946// 947//---------------------------------------------------------------------------- 948 949int LvmEffect_disable(EffectContext *pContext){ 950 //ALOGV("\tLvmEffect_disable start"); 951 952 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 953 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 954 /* Get the current settings */ 955 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 956 &ActiveParams); 957 958 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_disable") 959 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 960 //ALOGV("\tLvmEffect_disable Succesfully called LVM_GetControlParameters\n"); 961 962 if(pContext->EffectType == LVM_BASS_BOOST) { 963 ALOGV("\tLvmEffect_disable : Disabling LVM_BASS_BOOST"); 964 ActiveParams.BE_OperatingMode = LVM_BE_OFF; 965 } 966 if(pContext->EffectType == LVM_VIRTUALIZER) { 967 ALOGV("\tLvmEffect_disable : Disabling LVM_VIRTUALIZER"); 968 ActiveParams.VirtualizerOperatingMode = LVM_MODE_OFF; 969 } 970 if(pContext->EffectType == LVM_EQUALIZER) { 971 ALOGV("\tLvmEffect_disable : Disabling LVM_EQUALIZER"); 972 ActiveParams.EQNB_OperatingMode = LVM_EQNB_OFF; 973 } 974 if(pContext->EffectType == LVM_VOLUME) { 975 ALOGV("\tLvmEffect_disable : Disabling LVM_VOLUME"); 976 } 977 978 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 979 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_disable") 980 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 981 982 //ALOGV("\tLvmEffect_disable Succesfully called LVM_SetControlParameters\n"); 983 //ALOGV("\tLvmEffect_disable end"); 984 LvmEffect_limitLevel(pContext); 985 return 0; 986} 987 988//---------------------------------------------------------------------------- 989// LvmEffect_free() 990//---------------------------------------------------------------------------- 991// Purpose: Free all memory associated with the Bundle. 992// 993// Inputs: 994// pContext: effect engine context 995// 996// Outputs: 997// 998//---------------------------------------------------------------------------- 999 1000void LvmEffect_free(EffectContext *pContext){ 1001 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1002 LVM_ControlParams_t params; /* Control Parameters */ 1003 LVM_MemTab_t MemTab; 1004 1005 /* Free the algorithm memory */ 1006 LvmStatus = LVM_GetMemoryTable(pContext->pBundledContext->hInstance, 1007 &MemTab, 1008 LVM_NULL); 1009 1010 LVM_ERROR_CHECK(LvmStatus, "LVM_GetMemoryTable", "LvmEffect_free") 1011 1012 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){ 1013 if (MemTab.Region[i].Size != 0){ 1014 if (MemTab.Region[i].pBaseAddress != NULL){ 1015 ALOGV("\tLvmEffect_free - START freeing %" PRIu32 " bytes for region %u at %p\n", 1016 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 1017 1018 free(MemTab.Region[i].pBaseAddress); 1019 1020 ALOGV("\tLvmEffect_free - END freeing %" PRIu32 " bytes for region %u at %p\n", 1021 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 1022 }else{ 1023 ALOGV("\tLVM_ERROR : LvmEffect_free - trying to free with NULL pointer %" PRIu32 1024 " bytes for region %u at %p ERROR\n", 1025 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 1026 } 1027 } 1028 } 1029} /* end LvmEffect_free */ 1030 1031//---------------------------------------------------------------------------- 1032// Effect_setConfig() 1033//---------------------------------------------------------------------------- 1034// Purpose: Set input and output audio configuration. 1035// 1036// Inputs: 1037// pContext: effect engine context 1038// pConfig: pointer to effect_config_t structure holding input and output 1039// configuration parameters 1040// 1041// Outputs: 1042// 1043//---------------------------------------------------------------------------- 1044 1045int Effect_setConfig(EffectContext *pContext, effect_config_t *pConfig){ 1046 LVM_Fs_en SampleRate; 1047 //ALOGV("\tEffect_setConfig start"); 1048 1049 CHECK_ARG(pContext != NULL); 1050 CHECK_ARG(pConfig != NULL); 1051 1052 CHECK_ARG(pConfig->inputCfg.samplingRate == pConfig->outputCfg.samplingRate); 1053 CHECK_ARG(pConfig->inputCfg.channels == pConfig->outputCfg.channels); 1054 CHECK_ARG(pConfig->inputCfg.format == pConfig->outputCfg.format); 1055 CHECK_ARG(pConfig->inputCfg.channels == AUDIO_CHANNEL_OUT_STEREO); 1056 CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE 1057 || pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE); 1058 CHECK_ARG(pConfig->inputCfg.format == AUDIO_FORMAT_PCM_16_BIT); 1059 1060 pContext->config = *pConfig; 1061 1062 switch (pConfig->inputCfg.samplingRate) { 1063 case 8000: 1064 SampleRate = LVM_FS_8000; 1065 pContext->pBundledContext->SamplesPerSecond = 8000*2; // 2 secs Stereo 1066 break; 1067 case 16000: 1068 SampleRate = LVM_FS_16000; 1069 pContext->pBundledContext->SamplesPerSecond = 16000*2; // 2 secs Stereo 1070 break; 1071 case 22050: 1072 SampleRate = LVM_FS_22050; 1073 pContext->pBundledContext->SamplesPerSecond = 22050*2; // 2 secs Stereo 1074 break; 1075 case 32000: 1076 SampleRate = LVM_FS_32000; 1077 pContext->pBundledContext->SamplesPerSecond = 32000*2; // 2 secs Stereo 1078 break; 1079 case 44100: 1080 SampleRate = LVM_FS_44100; 1081 pContext->pBundledContext->SamplesPerSecond = 44100*2; // 2 secs Stereo 1082 break; 1083 case 48000: 1084 SampleRate = LVM_FS_48000; 1085 pContext->pBundledContext->SamplesPerSecond = 48000*2; // 2 secs Stereo 1086 break; 1087 default: 1088 ALOGV("\tEffect_setConfig invalid sampling rate %d", pConfig->inputCfg.samplingRate); 1089 return -EINVAL; 1090 } 1091 1092 if(pContext->pBundledContext->SampleRate != SampleRate){ 1093 1094 LVM_ControlParams_t ActiveParams; 1095 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; 1096 1097 ALOGV("\tEffect_setConfig change sampling rate to %d", SampleRate); 1098 1099 /* Get the current settings */ 1100 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1101 &ActiveParams); 1102 1103 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "Effect_setConfig") 1104 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1105 1106 ActiveParams.SampleRate = SampleRate; 1107 1108 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1109 1110 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "Effect_setConfig") 1111 ALOGV("\tEffect_setConfig Succesfully called LVM_SetControlParameters\n"); 1112 pContext->pBundledContext->SampleRate = SampleRate; 1113 1114 }else{ 1115 //ALOGV("\tEffect_setConfig keep sampling rate at %d", SampleRate); 1116 } 1117 1118 //ALOGV("\tEffect_setConfig End...."); 1119 return 0; 1120} /* end Effect_setConfig */ 1121 1122//---------------------------------------------------------------------------- 1123// Effect_getConfig() 1124//---------------------------------------------------------------------------- 1125// Purpose: Get input and output audio configuration. 1126// 1127// Inputs: 1128// pContext: effect engine context 1129// pConfig: pointer to effect_config_t structure holding input and output 1130// configuration parameters 1131// 1132// Outputs: 1133// 1134//---------------------------------------------------------------------------- 1135 1136void Effect_getConfig(EffectContext *pContext, effect_config_t *pConfig) 1137{ 1138 *pConfig = pContext->config; 1139} /* end Effect_getConfig */ 1140 1141//---------------------------------------------------------------------------- 1142// BassGetStrength() 1143//---------------------------------------------------------------------------- 1144// Purpose: 1145// get the effect strength currently being used, what is actually returned is the strengh that was 1146// previously used in the set, this is because the app uses a strength in the range 0-1000 while 1147// the bassboost uses 1-15, so to avoid a quantisation the original set value is used. However the 1148// actual used value is checked to make sure it corresponds to the one being returned 1149// 1150// Inputs: 1151// pContext: effect engine context 1152// 1153//---------------------------------------------------------------------------- 1154 1155uint32_t BassGetStrength(EffectContext *pContext){ 1156 //ALOGV("\tBassGetStrength() (0-1000) -> %d\n", pContext->pBundledContext->BassStrengthSaved); 1157 1158 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1159 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1160 /* Get the current settings */ 1161 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1162 &ActiveParams); 1163 1164 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "BassGetStrength") 1165 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1166 1167 //ALOGV("\tBassGetStrength Succesfully returned from LVM_GetControlParameters\n"); 1168 1169 /* Check that the strength returned matches the strength that was set earlier */ 1170 if(ActiveParams.BE_EffectLevel != 1171 (LVM_INT16)((15*pContext->pBundledContext->BassStrengthSaved)/1000)){ 1172 ALOGV("\tLVM_ERROR : BassGetStrength module strength does not match savedStrength %d %d\n", 1173 ActiveParams.BE_EffectLevel, pContext->pBundledContext->BassStrengthSaved); 1174 return -EINVAL; 1175 } 1176 1177 //ALOGV("\tBassGetStrength() (0-15) -> %d\n", ActiveParams.BE_EffectLevel ); 1178 //ALOGV("\tBassGetStrength() (saved) -> %d\n", pContext->pBundledContext->BassStrengthSaved ); 1179 return pContext->pBundledContext->BassStrengthSaved; 1180} /* end BassGetStrength */ 1181 1182//---------------------------------------------------------------------------- 1183// BassSetStrength() 1184//---------------------------------------------------------------------------- 1185// Purpose: 1186// Apply the strength to the BassBosst. Must first be converted from the range 0-1000 to 1-15 1187// 1188// Inputs: 1189// pContext: effect engine context 1190// strength strength to be applied 1191// 1192//---------------------------------------------------------------------------- 1193 1194void BassSetStrength(EffectContext *pContext, uint32_t strength){ 1195 //ALOGV("\tBassSetStrength(%d)", strength); 1196 1197 pContext->pBundledContext->BassStrengthSaved = (int)strength; 1198 1199 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1200 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1201 1202 /* Get the current settings */ 1203 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1204 &ActiveParams); 1205 1206 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "BassSetStrength") 1207 //ALOGV("\tBassSetStrength Succesfully returned from LVM_GetControlParameters\n"); 1208 1209 /* Bass Enhancement parameters */ 1210 ActiveParams.BE_EffectLevel = (LVM_INT16)((15*strength)/1000); 1211 ActiveParams.BE_CentreFreq = LVM_BE_CENTRE_90Hz; 1212 1213 //ALOGV("\tBassSetStrength() (0-15) -> %d\n", ActiveParams.BE_EffectLevel ); 1214 1215 /* Activate the initial settings */ 1216 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1217 1218 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "BassSetStrength") 1219 //ALOGV("\tBassSetStrength Succesfully called LVM_SetControlParameters\n"); 1220 1221 LvmEffect_limitLevel(pContext); 1222} /* end BassSetStrength */ 1223 1224//---------------------------------------------------------------------------- 1225// VirtualizerGetStrength() 1226//---------------------------------------------------------------------------- 1227// Purpose: 1228// get the effect strength currently being used, what is actually returned is the strengh that was 1229// previously used in the set, this is because the app uses a strength in the range 0-1000 while 1230// the Virtualizer uses 1-100, so to avoid a quantisation the original set value is used.However the 1231// actual used value is checked to make sure it corresponds to the one being returned 1232// 1233// Inputs: 1234// pContext: effect engine context 1235// 1236//---------------------------------------------------------------------------- 1237 1238uint32_t VirtualizerGetStrength(EffectContext *pContext){ 1239 //ALOGV("\tVirtualizerGetStrength (0-1000) -> %d\n",pContext->pBundledContext->VirtStrengthSaved); 1240 1241 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1242 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1243 1244 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1245 1246 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VirtualizerGetStrength") 1247 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1248 1249 //ALOGV("\tVirtualizerGetStrength Succesfully returned from LVM_GetControlParameters\n"); 1250 //ALOGV("\tVirtualizerGetStrength() (0-100) -> %d\n", ActiveParams.VirtualizerReverbLevel*10); 1251 return pContext->pBundledContext->VirtStrengthSaved; 1252} /* end getStrength */ 1253 1254//---------------------------------------------------------------------------- 1255// VirtualizerSetStrength() 1256//---------------------------------------------------------------------------- 1257// Purpose: 1258// Apply the strength to the Virtualizer. Must first be converted from the range 0-1000 to 1-15 1259// 1260// Inputs: 1261// pContext: effect engine context 1262// strength strength to be applied 1263// 1264//---------------------------------------------------------------------------- 1265 1266void VirtualizerSetStrength(EffectContext *pContext, uint32_t strength){ 1267 //ALOGV("\tVirtualizerSetStrength(%d)", strength); 1268 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1269 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1270 1271 pContext->pBundledContext->VirtStrengthSaved = (int)strength; 1272 1273 /* Get the current settings */ 1274 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams); 1275 1276 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VirtualizerSetStrength") 1277 //ALOGV("\tVirtualizerSetStrength Succesfully returned from LVM_GetControlParameters\n"); 1278 1279 /* Virtualizer parameters */ 1280 ActiveParams.CS_EffectLevel = (int)((strength*32767)/1000); 1281 1282 ALOGV("\tVirtualizerSetStrength() (0-1000) -> %d\n", strength ); 1283 ALOGV("\tVirtualizerSetStrength() (0- 100) -> %d\n", ActiveParams.CS_EffectLevel ); 1284 1285 /* Activate the initial settings */ 1286 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1287 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VirtualizerSetStrength") 1288 //ALOGV("\tVirtualizerSetStrength Succesfully called LVM_SetControlParameters\n\n"); 1289 LvmEffect_limitLevel(pContext); 1290} /* end setStrength */ 1291 1292//---------------------------------------------------------------------------- 1293// VirtualizerIsDeviceSupported() 1294//---------------------------------------------------------------------------- 1295// Purpose: 1296// Check if an audio device type is supported by this implementation 1297// 1298// Inputs: 1299// deviceType the type of device that affects the processing (e.g. for binaural vs transaural) 1300// Output: 1301// -EINVAL if the configuration is not supported or it is unknown 1302// 0 if the configuration is supported 1303//---------------------------------------------------------------------------- 1304int VirtualizerIsDeviceSupported(audio_devices_t deviceType) { 1305 switch (deviceType) { 1306 case AUDIO_DEVICE_OUT_WIRED_HEADSET: 1307 case AUDIO_DEVICE_OUT_WIRED_HEADPHONE: 1308 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES: 1309 return 0; 1310 default : 1311 return -EINVAL; 1312 } 1313} 1314 1315//---------------------------------------------------------------------------- 1316// VirtualizerIsConfigurationSupported() 1317//---------------------------------------------------------------------------- 1318// Purpose: 1319// Check if a channel mask + audio device type is supported by this implementation 1320// 1321// Inputs: 1322// channelMask the channel mask of the input to virtualize 1323// deviceType the type of device that affects the processing (e.g. for binaural vs transaural) 1324// Output: 1325// -EINVAL if the configuration is not supported or it is unknown 1326// 0 if the configuration is supported 1327//---------------------------------------------------------------------------- 1328int VirtualizerIsConfigurationSupported(audio_channel_mask_t channelMask, 1329 audio_devices_t deviceType) { 1330 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask); 1331 if ((channelCount == 0) || (channelCount > 2)) { 1332 return -EINVAL; 1333 } 1334 1335 return VirtualizerIsDeviceSupported(deviceType); 1336} 1337 1338//---------------------------------------------------------------------------- 1339// VirtualizerForceVirtualizationMode() 1340//---------------------------------------------------------------------------- 1341// Purpose: 1342// Force the virtualization mode to that of the given audio device 1343// 1344// Inputs: 1345// pContext effect engine context 1346// forcedDevice the type of device whose virtualization mode we'll always use 1347// Output: 1348// -EINVAL if the device is not supported or is unknown 1349// 0 if the device is supported and the virtualization mode forced 1350// 1351//---------------------------------------------------------------------------- 1352int VirtualizerForceVirtualizationMode(EffectContext *pContext, audio_devices_t forcedDevice) { 1353 ALOGV("VirtualizerForceVirtualizationMode: forcedDev=0x%x enabled=%d tmpDisabled=%d", 1354 forcedDevice, pContext->pBundledContext->bVirtualizerEnabled, 1355 pContext->pBundledContext->bVirtualizerTempDisabled); 1356 int status = 0; 1357 bool useVirtualizer = false; 1358 1359 if (VirtualizerIsDeviceSupported(forcedDevice) != 0) { 1360 if (forcedDevice != AUDIO_DEVICE_NONE) { 1361 //forced device is not supported, make it behave as a reset of forced mode 1362 forcedDevice = AUDIO_DEVICE_NONE; 1363 // but return an error 1364 status = -EINVAL; 1365 } 1366 } 1367 1368 if (forcedDevice == AUDIO_DEVICE_NONE) { 1369 // disabling forced virtualization mode: 1370 // verify whether the virtualization should be enabled or disabled 1371 if (VirtualizerIsDeviceSupported(pContext->pBundledContext->nOutputDevice) == 0) { 1372 useVirtualizer = (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE); 1373 } 1374 pContext->pBundledContext->nVirtualizerForcedDevice = AUDIO_DEVICE_NONE; 1375 } else { 1376 // forcing virtualization mode: here we already know the device is supported 1377 pContext->pBundledContext->nVirtualizerForcedDevice = AUDIO_DEVICE_OUT_WIRED_HEADPHONE; 1378 // only enable for a supported mode, when the effect is enabled 1379 useVirtualizer = (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE); 1380 } 1381 1382 if (useVirtualizer) { 1383 if (pContext->pBundledContext->bVirtualizerTempDisabled == LVM_TRUE) { 1384 ALOGV("\tVirtualizerForceVirtualizationMode re-enable LVM_VIRTUALIZER"); 1385 android::LvmEffect_enable(pContext); 1386 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_FALSE; 1387 } else { 1388 ALOGV("\tVirtualizerForceVirtualizationMode leaving LVM_VIRTUALIZER enabled"); 1389 } 1390 } else { 1391 if (pContext->pBundledContext->bVirtualizerTempDisabled == LVM_FALSE) { 1392 ALOGV("\tVirtualizerForceVirtualizationMode disable LVM_VIRTUALIZER"); 1393 android::LvmEffect_disable(pContext); 1394 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_TRUE; 1395 } else { 1396 ALOGV("\tVirtualizerForceVirtualizationMode leaving LVM_VIRTUALIZER disabled"); 1397 } 1398 } 1399 1400 ALOGV("\tafter VirtualizerForceVirtualizationMode: enabled=%d tmpDisabled=%d", 1401 pContext->pBundledContext->bVirtualizerEnabled, 1402 pContext->pBundledContext->bVirtualizerTempDisabled); 1403 1404 return status; 1405} 1406//---------------------------------------------------------------------------- 1407// VirtualizerGetSpeakerAngles() 1408//---------------------------------------------------------------------------- 1409// Purpose: 1410// Get the virtual speaker angles for a channel mask + audio device type 1411// configuration which is guaranteed to be supported by this implementation 1412// 1413// Inputs: 1414// channelMask: the channel mask of the input to virtualize 1415// deviceType the type of device that affects the processing (e.g. for binaural vs transaural) 1416// Input/Output: 1417// pSpeakerAngles the array of integer where each speaker angle is written as a triplet in the 1418// following format: 1419// int32_t a bit mask with a single value selected for each speaker, following 1420// the convention of the audio_channel_mask_t type 1421// int32_t a value in degrees expressing the speaker azimuth, where 0 is in front 1422// of the user, 180 behind, -90 to the left, 90 to the right of the user 1423// int32_t a value in degrees expressing the speaker elevation, where 0 is the 1424// horizontal plane, +90 is directly above the user, -90 below 1425// 1426//---------------------------------------------------------------------------- 1427void VirtualizerGetSpeakerAngles(audio_channel_mask_t channelMask __unused, 1428 audio_devices_t deviceType __unused, int32_t *pSpeakerAngles) { 1429 // the channel count is guaranteed to be 1 or 2 1430 // the device is guaranteed to be of type headphone 1431 // this virtualizer is always 2in with speakers at -90 and 90deg of azimuth, 0deg of elevation 1432 *pSpeakerAngles++ = (int32_t) AUDIO_CHANNEL_OUT_FRONT_LEFT; 1433 *pSpeakerAngles++ = -90; // azimuth 1434 *pSpeakerAngles++ = 0; // elevation 1435 *pSpeakerAngles++ = (int32_t) AUDIO_CHANNEL_OUT_FRONT_RIGHT; 1436 *pSpeakerAngles++ = 90; // azimuth 1437 *pSpeakerAngles = 0; // elevation 1438} 1439 1440//---------------------------------------------------------------------------- 1441// VirtualizerGetVirtualizationMode() 1442//---------------------------------------------------------------------------- 1443// Purpose: 1444// Retrieve the current device whose processing mode is used by this effect 1445// 1446// Output: 1447// AUDIO_DEVICE_NONE if the effect is not virtualizing 1448// or the device type if the effect is virtualizing 1449//---------------------------------------------------------------------------- 1450audio_devices_t VirtualizerGetVirtualizationMode(EffectContext *pContext) { 1451 audio_devices_t virtDevice = AUDIO_DEVICE_NONE; 1452 if ((pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) 1453 && (pContext->pBundledContext->bVirtualizerTempDisabled == LVM_FALSE)) { 1454 if (pContext->pBundledContext->nVirtualizerForcedDevice != AUDIO_DEVICE_NONE) { 1455 // virtualization mode is forced, return that device 1456 virtDevice = pContext->pBundledContext->nVirtualizerForcedDevice; 1457 } else { 1458 // no forced mode, return the current device 1459 virtDevice = pContext->pBundledContext->nOutputDevice; 1460 } 1461 } 1462 ALOGV("VirtualizerGetVirtualizationMode() returning 0x%x", virtDevice); 1463 return virtDevice; 1464} 1465 1466//---------------------------------------------------------------------------- 1467// EqualizerGetBandLevel() 1468//---------------------------------------------------------------------------- 1469// Purpose: Retrieve the gain currently being used for the band passed in 1470// 1471// Inputs: 1472// band: band number 1473// pContext: effect engine context 1474// 1475// Outputs: 1476// 1477//---------------------------------------------------------------------------- 1478int32_t EqualizerGetBandLevel(EffectContext *pContext, int32_t band){ 1479 //ALOGV("\tEqualizerGetBandLevel -> %d\n", pContext->pBundledContext->bandGaindB[band] ); 1480 return pContext->pBundledContext->bandGaindB[band] * 100; 1481} 1482 1483//---------------------------------------------------------------------------- 1484// EqualizerSetBandLevel() 1485//---------------------------------------------------------------------------- 1486// Purpose: 1487// Sets gain value for the given band. 1488// 1489// Inputs: 1490// band: band number 1491// Gain: Gain to be applied in millibels 1492// pContext: effect engine context 1493// 1494// Outputs: 1495// 1496//--------------------------------------------------------------------------- 1497void EqualizerSetBandLevel(EffectContext *pContext, int band, short Gain){ 1498 int gainRounded; 1499 if(Gain > 0){ 1500 gainRounded = (int)((Gain+50)/100); 1501 }else{ 1502 gainRounded = (int)((Gain-50)/100); 1503 } 1504 //ALOGV("\tEqualizerSetBandLevel(%d)->(%d)", Gain, gainRounded); 1505 pContext->pBundledContext->bandGaindB[band] = gainRounded; 1506 pContext->pBundledContext->CurPreset = PRESET_CUSTOM; 1507 1508 EqualizerUpdateActiveParams(pContext); 1509 LvmEffect_limitLevel(pContext); 1510} 1511 1512//---------------------------------------------------------------------------- 1513// EqualizerGetCentreFrequency() 1514//---------------------------------------------------------------------------- 1515// Purpose: Retrieve the frequency being used for the band passed in 1516// 1517// Inputs: 1518// band: band number 1519// pContext: effect engine context 1520// 1521// Outputs: 1522// 1523//---------------------------------------------------------------------------- 1524int32_t EqualizerGetCentreFrequency(EffectContext *pContext, int32_t band){ 1525 int32_t Frequency =0; 1526 1527 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1528 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1529 LVM_EQNB_BandDef_t *BandDef; 1530 /* Get the current settings */ 1531 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1532 &ActiveParams); 1533 1534 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "EqualizerGetCentreFrequency") 1535 1536 BandDef = ActiveParams.pEQNB_BandDefinition; 1537 Frequency = (int32_t)BandDef[band].Frequency*1000; // Convert to millibels 1538 1539 //ALOGV("\tEqualizerGetCentreFrequency -> %d\n", Frequency ); 1540 //ALOGV("\tEqualizerGetCentreFrequency Succesfully returned from LVM_GetControlParameters\n"); 1541 return Frequency; 1542} 1543 1544//---------------------------------------------------------------------------- 1545// EqualizerGetBandFreqRange( 1546//---------------------------------------------------------------------------- 1547// Purpose: 1548// 1549// Gets lower and upper boundaries of a band. 1550// For the high shelf, the low bound is the band frequency and the high 1551// bound is Nyquist. 1552// For the peaking filters, they are the gain[dB]/2 points. 1553// 1554// Inputs: 1555// band: band number 1556// pContext: effect engine context 1557// 1558// Outputs: 1559// pLow: lower band range 1560// pLow: upper band range 1561//---------------------------------------------------------------------------- 1562int32_t EqualizerGetBandFreqRange(EffectContext *pContext __unused, int32_t band, uint32_t *pLow, 1563 uint32_t *pHi){ 1564 *pLow = bandFreqRange[band][0]; 1565 *pHi = bandFreqRange[band][1]; 1566 return 0; 1567} 1568 1569//---------------------------------------------------------------------------- 1570// EqualizerGetBand( 1571//---------------------------------------------------------------------------- 1572// Purpose: 1573// 1574// Returns the band with the maximum influence on a given frequency. 1575// Result is unaffected by whether EQ is enabled or not, or by whether 1576// changes have been committed or not. 1577// 1578// Inputs: 1579// targetFreq The target frequency, in millihertz. 1580// pContext: effect engine context 1581// 1582// Outputs: 1583// pLow: lower band range 1584// pLow: upper band range 1585//---------------------------------------------------------------------------- 1586int32_t EqualizerGetBand(EffectContext *pContext __unused, uint32_t targetFreq){ 1587 int band = 0; 1588 1589 if(targetFreq < bandFreqRange[0][0]){ 1590 return -EINVAL; 1591 }else if(targetFreq == bandFreqRange[0][0]){ 1592 return 0; 1593 } 1594 for(int i=0; i<FIVEBAND_NUMBANDS;i++){ 1595 if((targetFreq > bandFreqRange[i][0])&&(targetFreq <= bandFreqRange[i][1])){ 1596 band = i; 1597 } 1598 } 1599 return band; 1600} 1601 1602//---------------------------------------------------------------------------- 1603// EqualizerGetPreset( 1604//---------------------------------------------------------------------------- 1605// Purpose: 1606// 1607// Gets the currently set preset ID. 1608// Will return PRESET_CUSTOM in case the EQ parameters have been modified 1609// manually since a preset was set. 1610// 1611// Inputs: 1612// pContext: effect engine context 1613// 1614//---------------------------------------------------------------------------- 1615int32_t EqualizerGetPreset(EffectContext *pContext){ 1616 return pContext->pBundledContext->CurPreset; 1617} 1618 1619//---------------------------------------------------------------------------- 1620// EqualizerSetPreset( 1621//---------------------------------------------------------------------------- 1622// Purpose: 1623// 1624// Sets the current preset by ID. 1625// All the band parameters will be overridden. 1626// 1627// Inputs: 1628// pContext: effect engine context 1629// preset The preset ID. 1630// 1631//---------------------------------------------------------------------------- 1632void EqualizerSetPreset(EffectContext *pContext, int preset){ 1633 1634 //ALOGV("\tEqualizerSetPreset(%d)", preset); 1635 pContext->pBundledContext->CurPreset = preset; 1636 1637 //ActiveParams.pEQNB_BandDefinition = &BandDefs[0]; 1638 for (int i=0; i<FIVEBAND_NUMBANDS; i++) 1639 { 1640 pContext->pBundledContext->bandGaindB[i] = 1641 EQNB_5BandSoftPresets[i + preset * FIVEBAND_NUMBANDS]; 1642 } 1643 1644 EqualizerUpdateActiveParams(pContext); 1645 LvmEffect_limitLevel(pContext); 1646 1647 //ALOGV("\tEqualizerSetPreset Succesfully called LVM_SetControlParameters\n"); 1648 return; 1649} 1650 1651int32_t EqualizerGetNumPresets(){ 1652 return sizeof(gEqualizerPresets) / sizeof(PresetConfig); 1653} 1654 1655//---------------------------------------------------------------------------- 1656// EqualizerGetPresetName( 1657//---------------------------------------------------------------------------- 1658// Purpose: 1659// Gets a human-readable name for a preset ID. Will return "Custom" if 1660// PRESET_CUSTOM is passed. 1661// 1662// Inputs: 1663// preset The preset ID. Must be less than number of presets. 1664// 1665//------------------------------------------------------------------------- 1666const char * EqualizerGetPresetName(int32_t preset){ 1667 //ALOGV("\tEqualizerGetPresetName start(%d)", preset); 1668 if (preset == PRESET_CUSTOM) { 1669 return "Custom"; 1670 } else { 1671 return gEqualizerPresets[preset].name; 1672 } 1673 //ALOGV("\tEqualizerGetPresetName end(%d)", preset); 1674 return 0; 1675} 1676 1677//---------------------------------------------------------------------------- 1678// VolumeSetVolumeLevel() 1679//---------------------------------------------------------------------------- 1680// Purpose: 1681// 1682// Inputs: 1683// pContext: effect engine context 1684// level level to be applied 1685// 1686//---------------------------------------------------------------------------- 1687 1688int VolumeSetVolumeLevel(EffectContext *pContext, int16_t level){ 1689 1690 if (level > 0 || level < -9600) { 1691 return -EINVAL; 1692 } 1693 1694 if (pContext->pBundledContext->bMuteEnabled == LVM_TRUE) { 1695 pContext->pBundledContext->levelSaved = level / 100; 1696 } else { 1697 pContext->pBundledContext->volume = level / 100; 1698 } 1699 1700 LvmEffect_limitLevel(pContext); 1701 1702 return 0; 1703} /* end VolumeSetVolumeLevel */ 1704 1705//---------------------------------------------------------------------------- 1706// VolumeGetVolumeLevel() 1707//---------------------------------------------------------------------------- 1708// Purpose: 1709// 1710// Inputs: 1711// pContext: effect engine context 1712// 1713//---------------------------------------------------------------------------- 1714 1715int VolumeGetVolumeLevel(EffectContext *pContext, int16_t *level){ 1716 1717 if (pContext->pBundledContext->bMuteEnabled == LVM_TRUE) { 1718 *level = pContext->pBundledContext->levelSaved * 100; 1719 } else { 1720 *level = pContext->pBundledContext->volume * 100; 1721 } 1722 return 0; 1723} /* end VolumeGetVolumeLevel */ 1724 1725//---------------------------------------------------------------------------- 1726// VolumeSetMute() 1727//---------------------------------------------------------------------------- 1728// Purpose: 1729// 1730// Inputs: 1731// pContext: effect engine context 1732// mute: enable/disable flag 1733// 1734//---------------------------------------------------------------------------- 1735 1736int32_t VolumeSetMute(EffectContext *pContext, uint32_t mute){ 1737 //ALOGV("\tVolumeSetMute start(%d)", mute); 1738 1739 pContext->pBundledContext->bMuteEnabled = mute; 1740 1741 /* Set appropriate volume level */ 1742 if(pContext->pBundledContext->bMuteEnabled == LVM_TRUE){ 1743 pContext->pBundledContext->levelSaved = pContext->pBundledContext->volume; 1744 pContext->pBundledContext->volume = -96; 1745 }else{ 1746 pContext->pBundledContext->volume = pContext->pBundledContext->levelSaved; 1747 } 1748 1749 LvmEffect_limitLevel(pContext); 1750 1751 return 0; 1752} /* end setMute */ 1753 1754//---------------------------------------------------------------------------- 1755// VolumeGetMute() 1756//---------------------------------------------------------------------------- 1757// Purpose: 1758// 1759// Inputs: 1760// pContext: effect engine context 1761// 1762// Ourputs: 1763// mute: enable/disable flag 1764//---------------------------------------------------------------------------- 1765 1766int32_t VolumeGetMute(EffectContext *pContext, uint32_t *mute){ 1767 //ALOGV("\tVolumeGetMute start"); 1768 if((pContext->pBundledContext->bMuteEnabled == LVM_FALSE)|| 1769 (pContext->pBundledContext->bMuteEnabled == LVM_TRUE)){ 1770 *mute = pContext->pBundledContext->bMuteEnabled; 1771 return 0; 1772 }else{ 1773 ALOGV("\tLVM_ERROR : VolumeGetMute read an invalid value from context %d", 1774 pContext->pBundledContext->bMuteEnabled); 1775 return -EINVAL; 1776 } 1777 //ALOGV("\tVolumeGetMute end"); 1778} /* end getMute */ 1779 1780int16_t VolumeConvertStereoPosition(int16_t position){ 1781 int16_t convertedPosition = 0; 1782 1783 convertedPosition = (int16_t)(((float)position/1000)*96); 1784 return convertedPosition; 1785 1786} 1787 1788//---------------------------------------------------------------------------- 1789// VolumeSetStereoPosition() 1790//---------------------------------------------------------------------------- 1791// Purpose: 1792// 1793// Inputs: 1794// pContext: effect engine context 1795// position: stereo position 1796// 1797// Outputs: 1798//---------------------------------------------------------------------------- 1799 1800int VolumeSetStereoPosition(EffectContext *pContext, int16_t position){ 1801 1802 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1803 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1804 LVM_INT16 Balance = 0; 1805 1806 1807 1808 pContext->pBundledContext->positionSaved = position; 1809 Balance = VolumeConvertStereoPosition(pContext->pBundledContext->positionSaved); 1810 1811 //ALOGV("\tVolumeSetStereoPosition start pContext->pBundledContext->positionSaved = %d", 1812 //pContext->pBundledContext->positionSaved); 1813 1814 if(pContext->pBundledContext->bStereoPositionEnabled == LVM_TRUE){ 1815 1816 //ALOGV("\tVolumeSetStereoPosition Position to be set is %d %d\n", position, Balance); 1817 pContext->pBundledContext->positionSaved = position; 1818 /* Get the current settings */ 1819 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1820 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetStereoPosition") 1821 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1822 //ALOGV("\tVolumeSetStereoPosition Succesfully returned from LVM_GetControlParameters got:" 1823 // " %d\n", ActiveParams.VC_Balance); 1824 1825 /* Volume parameters */ 1826 ActiveParams.VC_Balance = Balance; 1827 //ALOGV("\tVolumeSetStereoPosition() (-96dB -> +96dB) -> %d\n", ActiveParams.VC_Balance ); 1828 1829 /* Activate the initial settings */ 1830 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1831 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeSetStereoPosition") 1832 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1833 1834 //ALOGV("\tVolumeSetStereoPosition Succesfully called LVM_SetControlParameters\n"); 1835 1836 /* Get the current settings */ 1837 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1838 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetStereoPosition") 1839 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1840 //ALOGV("\tVolumeSetStereoPosition Succesfully returned from LVM_GetControlParameters got: " 1841 // "%d\n", ActiveParams.VC_Balance); 1842 } 1843 else{ 1844 //ALOGV("\tVolumeSetStereoPosition Position attempting to set, but not enabled %d %d\n", 1845 //position, Balance); 1846 } 1847 //ALOGV("\tVolumeSetStereoPosition end pContext->pBundledContext->positionSaved = %d\n", 1848 //pContext->pBundledContext->positionSaved); 1849 return 0; 1850} /* end VolumeSetStereoPosition */ 1851 1852 1853//---------------------------------------------------------------------------- 1854// VolumeGetStereoPosition() 1855//---------------------------------------------------------------------------- 1856// Purpose: 1857// 1858// Inputs: 1859// pContext: effect engine context 1860// 1861// Outputs: 1862// position: stereo position 1863//---------------------------------------------------------------------------- 1864 1865int32_t VolumeGetStereoPosition(EffectContext *pContext, int16_t *position){ 1866 //ALOGV("\tVolumeGetStereoPosition start"); 1867 1868 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1869 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1870 LVM_INT16 balance; 1871 1872 //ALOGV("\tVolumeGetStereoPosition start pContext->pBundledContext->positionSaved = %d", 1873 //pContext->pBundledContext->positionSaved); 1874 1875 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1876 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeGetStereoPosition") 1877 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1878 1879 //ALOGV("\tVolumeGetStereoPosition -> %d\n", ActiveParams.VC_Balance); 1880 //ALOGV("\tVolumeGetStereoPosition Succesfully returned from LVM_GetControlParameters\n"); 1881 1882 balance = VolumeConvertStereoPosition(pContext->pBundledContext->positionSaved); 1883 1884 if(pContext->pBundledContext->bStereoPositionEnabled == LVM_TRUE){ 1885 if(balance != ActiveParams.VC_Balance){ 1886 return -EINVAL; 1887 } 1888 } 1889 *position = (LVM_INT16)pContext->pBundledContext->positionSaved; // Convert dB to millibels 1890 //ALOGV("\tVolumeGetStereoPosition end returning pContext->pBundledContext->positionSaved =%d\n", 1891 //pContext->pBundledContext->positionSaved); 1892 return 0; 1893} /* end VolumeGetStereoPosition */ 1894 1895//---------------------------------------------------------------------------- 1896// VolumeEnableStereoPosition() 1897//---------------------------------------------------------------------------- 1898// Purpose: 1899// 1900// Inputs: 1901// pContext: effect engine context 1902// mute: enable/disable flag 1903// 1904//---------------------------------------------------------------------------- 1905 1906int32_t VolumeEnableStereoPosition(EffectContext *pContext, uint32_t enabled){ 1907 //ALOGV("\tVolumeEnableStereoPosition start()"); 1908 1909 pContext->pBundledContext->bStereoPositionEnabled = enabled; 1910 1911 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1912 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1913 1914 /* Get the current settings */ 1915 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1916 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeEnableStereoPosition") 1917 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1918 1919 //ALOGV("\tVolumeEnableStereoPosition Succesfully returned from LVM_GetControlParameters\n"); 1920 //ALOGV("\tVolumeEnableStereoPosition to %d, position was %d\n", 1921 // enabled, ActiveParams.VC_Balance ); 1922 1923 /* Set appropriate stereo position */ 1924 if(pContext->pBundledContext->bStereoPositionEnabled == LVM_FALSE){ 1925 ActiveParams.VC_Balance = 0; 1926 }else{ 1927 ActiveParams.VC_Balance = 1928 VolumeConvertStereoPosition(pContext->pBundledContext->positionSaved); 1929 } 1930 1931 /* Activate the initial settings */ 1932 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1933 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeEnableStereoPosition") 1934 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1935 1936 //ALOGV("\tVolumeEnableStereoPosition Succesfully called LVM_SetControlParameters\n"); 1937 //ALOGV("\tVolumeEnableStereoPosition end()\n"); 1938 return 0; 1939} /* end VolumeEnableStereoPosition */ 1940 1941//---------------------------------------------------------------------------- 1942// BassBoost_getParameter() 1943//---------------------------------------------------------------------------- 1944// Purpose: 1945// Get a BassBoost parameter 1946// 1947// Inputs: 1948// pBassBoost - handle to instance data 1949// pParam - pointer to parameter 1950// pValue - pointer to variable to hold retrieved value 1951// pValueSize - pointer to value size: maximum size as input 1952// 1953// Outputs: 1954// *pValue updated with parameter value 1955// *pValueSize updated with actual value size 1956// 1957// 1958// Side Effects: 1959// 1960//---------------------------------------------------------------------------- 1961 1962int BassBoost_getParameter(EffectContext *pContext, 1963 void *pParam, 1964 uint32_t *pValueSize, 1965 void *pValue){ 1966 int status = 0; 1967 int32_t *pParamTemp = (int32_t *)pParam; 1968 int32_t param = *pParamTemp++; 1969 int32_t param2; 1970 char *name; 1971 1972 //ALOGV("\tBassBoost_getParameter start"); 1973 1974 switch (param){ 1975 case BASSBOOST_PARAM_STRENGTH_SUPPORTED: 1976 if (*pValueSize != sizeof(uint32_t)){ 1977 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid pValueSize1 %d", *pValueSize); 1978 return -EINVAL; 1979 } 1980 *pValueSize = sizeof(uint32_t); 1981 break; 1982 case BASSBOOST_PARAM_STRENGTH: 1983 if (*pValueSize != sizeof(int16_t)){ 1984 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid pValueSize2 %d", *pValueSize); 1985 return -EINVAL; 1986 } 1987 *pValueSize = sizeof(int16_t); 1988 break; 1989 1990 default: 1991 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid param %d", param); 1992 return -EINVAL; 1993 } 1994 1995 switch (param){ 1996 case BASSBOOST_PARAM_STRENGTH_SUPPORTED: 1997 *(uint32_t *)pValue = 1; 1998 1999 //ALOGV("\tBassBoost_getParameter() BASSBOOST_PARAM_STRENGTH_SUPPORTED Value is %d", 2000 // *(uint32_t *)pValue); 2001 break; 2002 2003 case BASSBOOST_PARAM_STRENGTH: 2004 *(int16_t *)pValue = BassGetStrength(pContext); 2005 2006 //ALOGV("\tBassBoost_getParameter() BASSBOOST_PARAM_STRENGTH Value is %d", 2007 // *(int16_t *)pValue); 2008 break; 2009 2010 default: 2011 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid param %d", param); 2012 status = -EINVAL; 2013 break; 2014 } 2015 2016 //ALOGV("\tBassBoost_getParameter end"); 2017 return status; 2018} /* end BassBoost_getParameter */ 2019 2020//---------------------------------------------------------------------------- 2021// BassBoost_setParameter() 2022//---------------------------------------------------------------------------- 2023// Purpose: 2024// Set a BassBoost parameter 2025// 2026// Inputs: 2027// pBassBoost - handle to instance data 2028// pParam - pointer to parameter 2029// pValue - pointer to value 2030// 2031// Outputs: 2032// 2033//---------------------------------------------------------------------------- 2034 2035int BassBoost_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2036 int status = 0; 2037 int16_t strength; 2038 int32_t *pParamTemp = (int32_t *)pParam; 2039 2040 //ALOGV("\tBassBoost_setParameter start"); 2041 2042 switch (*pParamTemp){ 2043 case BASSBOOST_PARAM_STRENGTH: 2044 strength = *(int16_t *)pValue; 2045 //ALOGV("\tBassBoost_setParameter() BASSBOOST_PARAM_STRENGTH value is %d", strength); 2046 //ALOGV("\tBassBoost_setParameter() Calling pBassBoost->BassSetStrength"); 2047 BassSetStrength(pContext, (int32_t)strength); 2048 //ALOGV("\tBassBoost_setParameter() Called pBassBoost->BassSetStrength"); 2049 break; 2050 default: 2051 ALOGV("\tLVM_ERROR : BassBoost_setParameter() invalid param %d", *pParamTemp); 2052 break; 2053 } 2054 2055 //ALOGV("\tBassBoost_setParameter end"); 2056 return status; 2057} /* end BassBoost_setParameter */ 2058 2059//---------------------------------------------------------------------------- 2060// Virtualizer_getParameter() 2061//---------------------------------------------------------------------------- 2062// Purpose: 2063// Get a Virtualizer parameter 2064// 2065// Inputs: 2066// pVirtualizer - handle to instance data 2067// pParam - pointer to parameter 2068// pValue - pointer to variable to hold retrieved value 2069// pValueSize - pointer to value size: maximum size as input 2070// 2071// Outputs: 2072// *pValue updated with parameter value 2073// *pValueSize updated with actual value size 2074// 2075// 2076// Side Effects: 2077// 2078//---------------------------------------------------------------------------- 2079 2080int Virtualizer_getParameter(EffectContext *pContext, 2081 void *pParam, 2082 uint32_t *pValueSize, 2083 void *pValue){ 2084 int status = 0; 2085 int32_t *pParamTemp = (int32_t *)pParam; 2086 int32_t param = *pParamTemp++; 2087 char *name; 2088 2089 //ALOGV("\tVirtualizer_getParameter start"); 2090 2091 switch (param){ 2092 case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: 2093 if (*pValueSize != sizeof(uint32_t)){ 2094 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize %d",*pValueSize); 2095 return -EINVAL; 2096 } 2097 *pValueSize = sizeof(uint32_t); 2098 break; 2099 case VIRTUALIZER_PARAM_STRENGTH: 2100 if (*pValueSize != sizeof(int16_t)){ 2101 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize2 %d",*pValueSize); 2102 return -EINVAL; 2103 } 2104 *pValueSize = sizeof(int16_t); 2105 break; 2106 case VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES: 2107 // return value size can only be interpreted as relative to input value, 2108 // deferring validity check to below 2109 break; 2110 case VIRTUALIZER_PARAM_VIRTUALIZATION_MODE: 2111 if (*pValueSize != sizeof(uint32_t)){ 2112 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize %d",*pValueSize); 2113 return -EINVAL; 2114 } 2115 *pValueSize = sizeof(uint32_t); 2116 break; 2117 default: 2118 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid param %d", param); 2119 return -EINVAL; 2120 } 2121 2122 switch (param){ 2123 case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: 2124 *(uint32_t *)pValue = 1; 2125 2126 //ALOGV("\tVirtualizer_getParameter() VIRTUALIZER_PARAM_STRENGTH_SUPPORTED Value is %d", 2127 // *(uint32_t *)pValue); 2128 break; 2129 2130 case VIRTUALIZER_PARAM_STRENGTH: 2131 *(int16_t *)pValue = VirtualizerGetStrength(pContext); 2132 2133 //ALOGV("\tVirtualizer_getParameter() VIRTUALIZER_PARAM_STRENGTH Value is %d", 2134 // *(int16_t *)pValue); 2135 break; 2136 2137 case VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES: { 2138 const audio_channel_mask_t channelMask = (audio_channel_mask_t) *pParamTemp++; 2139 const audio_devices_t deviceType = (audio_devices_t) *pParamTemp; 2140 uint32_t nbChannels = audio_channel_count_from_out_mask(channelMask); 2141 if (*pValueSize < 3 * nbChannels * sizeof(int32_t)){ 2142 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize %d",*pValueSize); 2143 return -EINVAL; 2144 } 2145 // verify the configuration is supported 2146 status = VirtualizerIsConfigurationSupported(channelMask, deviceType); 2147 if (status == 0) { 2148 ALOGV("VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES supports mask=0x%x device=0x%x", 2149 channelMask, deviceType); 2150 // configuration is supported, get the angles 2151 VirtualizerGetSpeakerAngles(channelMask, deviceType, (int32_t *)pValue); 2152 } 2153 } 2154 break; 2155 2156 case VIRTUALIZER_PARAM_VIRTUALIZATION_MODE: 2157 *(uint32_t *)pValue = (uint32_t) VirtualizerGetVirtualizationMode(pContext); 2158 break; 2159 2160 default: 2161 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid param %d", param); 2162 status = -EINVAL; 2163 break; 2164 } 2165 2166 ALOGV("\tVirtualizer_getParameter end returning status=%d", status); 2167 return status; 2168} /* end Virtualizer_getParameter */ 2169 2170//---------------------------------------------------------------------------- 2171// Virtualizer_setParameter() 2172//---------------------------------------------------------------------------- 2173// Purpose: 2174// Set a Virtualizer parameter 2175// 2176// Inputs: 2177// pVirtualizer - handle to instance data 2178// pParam - pointer to parameter 2179// pValue - pointer to value 2180// 2181// Outputs: 2182// 2183//---------------------------------------------------------------------------- 2184 2185int Virtualizer_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2186 int status = 0; 2187 int16_t strength; 2188 int32_t *pParamTemp = (int32_t *)pParam; 2189 int32_t param = *pParamTemp++; 2190 2191 //ALOGV("\tVirtualizer_setParameter start"); 2192 2193 switch (param){ 2194 case VIRTUALIZER_PARAM_STRENGTH: 2195 strength = *(int16_t *)pValue; 2196 //ALOGV("\tVirtualizer_setParameter() VIRTUALIZER_PARAM_STRENGTH value is %d", strength); 2197 //ALOGV("\tVirtualizer_setParameter() Calling pVirtualizer->setStrength"); 2198 VirtualizerSetStrength(pContext, (int32_t)strength); 2199 //ALOGV("\tVirtualizer_setParameter() Called pVirtualizer->setStrength"); 2200 break; 2201 2202 case VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE: { 2203 const audio_devices_t deviceType = *(audio_devices_t *) pValue; 2204 status = VirtualizerForceVirtualizationMode(pContext, deviceType); 2205 //ALOGV("VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE device=0x%x result=%d", 2206 // deviceType, status); 2207 } 2208 break; 2209 2210 default: 2211 ALOGV("\tLVM_ERROR : Virtualizer_setParameter() invalid param %d", param); 2212 break; 2213 } 2214 2215 //ALOGV("\tVirtualizer_setParameter end"); 2216 return status; 2217} /* end Virtualizer_setParameter */ 2218 2219//---------------------------------------------------------------------------- 2220// Equalizer_getParameter() 2221//---------------------------------------------------------------------------- 2222// Purpose: 2223// Get a Equalizer parameter 2224// 2225// Inputs: 2226// pEqualizer - handle to instance data 2227// pParam - pointer to parameter 2228// pValue - pointer to variable to hold retrieved value 2229// pValueSize - pointer to value size: maximum size as input 2230// 2231// Outputs: 2232// *pValue updated with parameter value 2233// *pValueSize updated with actual value size 2234// 2235// 2236// Side Effects: 2237// 2238//---------------------------------------------------------------------------- 2239int Equalizer_getParameter(EffectContext *pContext, 2240 void *pParam, 2241 uint32_t *pValueSize, 2242 void *pValue){ 2243 int status = 0; 2244 int bMute = 0; 2245 int32_t *pParamTemp = (int32_t *)pParam; 2246 int32_t param = *pParamTemp++; 2247 int32_t param2; 2248 char *name; 2249 2250 //ALOGV("\tEqualizer_getParameter start"); 2251 2252 switch (param) { 2253 case EQ_PARAM_NUM_BANDS: 2254 case EQ_PARAM_CUR_PRESET: 2255 case EQ_PARAM_GET_NUM_OF_PRESETS: 2256 case EQ_PARAM_BAND_LEVEL: 2257 case EQ_PARAM_GET_BAND: 2258 if (*pValueSize < sizeof(int16_t)) { 2259 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 1 %d", *pValueSize); 2260 return -EINVAL; 2261 } 2262 *pValueSize = sizeof(int16_t); 2263 break; 2264 2265 case EQ_PARAM_LEVEL_RANGE: 2266 if (*pValueSize < 2 * sizeof(int16_t)) { 2267 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 2 %d", *pValueSize); 2268 return -EINVAL; 2269 } 2270 *pValueSize = 2 * sizeof(int16_t); 2271 break; 2272 case EQ_PARAM_BAND_FREQ_RANGE: 2273 if (*pValueSize < 2 * sizeof(int32_t)) { 2274 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 3 %d", *pValueSize); 2275 return -EINVAL; 2276 } 2277 *pValueSize = 2 * sizeof(int32_t); 2278 break; 2279 2280 case EQ_PARAM_CENTER_FREQ: 2281 if (*pValueSize < sizeof(int32_t)) { 2282 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 5 %d", *pValueSize); 2283 return -EINVAL; 2284 } 2285 *pValueSize = sizeof(int32_t); 2286 break; 2287 2288 case EQ_PARAM_GET_PRESET_NAME: 2289 break; 2290 2291 case EQ_PARAM_PROPERTIES: 2292 if (*pValueSize < (2 + FIVEBAND_NUMBANDS) * sizeof(uint16_t)) { 2293 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 1 %d", *pValueSize); 2294 return -EINVAL; 2295 } 2296 *pValueSize = (2 + FIVEBAND_NUMBANDS) * sizeof(uint16_t); 2297 break; 2298 2299 default: 2300 ALOGV("\tLVM_ERROR : Equalizer_getParameter unknown param %d", param); 2301 return -EINVAL; 2302 } 2303 2304 switch (param) { 2305 case EQ_PARAM_NUM_BANDS: 2306 *(uint16_t *)pValue = (uint16_t)FIVEBAND_NUMBANDS; 2307 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_NUM_BANDS %d", *(int16_t *)pValue); 2308 break; 2309 2310 case EQ_PARAM_LEVEL_RANGE: 2311 *(int16_t *)pValue = -1500; 2312 *((int16_t *)pValue + 1) = 1500; 2313 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_LEVEL_RANGE min %d, max %d", 2314 // *(int16_t *)pValue, *((int16_t *)pValue + 1)); 2315 break; 2316 2317 case EQ_PARAM_BAND_LEVEL: 2318 param2 = *pParamTemp; 2319 if (param2 >= FIVEBAND_NUMBANDS) { 2320 status = -EINVAL; 2321 break; 2322 } 2323 *(int16_t *)pValue = (int16_t)EqualizerGetBandLevel(pContext, param2); 2324 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", 2325 // param2, *(int32_t *)pValue); 2326 break; 2327 2328 case EQ_PARAM_CENTER_FREQ: 2329 param2 = *pParamTemp; 2330 if (param2 >= FIVEBAND_NUMBANDS) { 2331 status = -EINVAL; 2332 break; 2333 } 2334 *(int32_t *)pValue = EqualizerGetCentreFrequency(pContext, param2); 2335 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_CENTER_FREQ band %d, frequency %d", 2336 // param2, *(int32_t *)pValue); 2337 break; 2338 2339 case EQ_PARAM_BAND_FREQ_RANGE: 2340 param2 = *pParamTemp; 2341 if (param2 >= FIVEBAND_NUMBANDS) { 2342 status = -EINVAL; 2343 break; 2344 } 2345 EqualizerGetBandFreqRange(pContext, param2, (uint32_t *)pValue, ((uint32_t *)pValue + 1)); 2346 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_BAND_FREQ_RANGE band %d, min %d, max %d", 2347 // param2, *(int32_t *)pValue, *((int32_t *)pValue + 1)); 2348 break; 2349 2350 case EQ_PARAM_GET_BAND: 2351 param2 = *pParamTemp; 2352 *(uint16_t *)pValue = (uint16_t)EqualizerGetBand(pContext, param2); 2353 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_GET_BAND frequency %d, band %d", 2354 // param2, *(uint16_t *)pValue); 2355 break; 2356 2357 case EQ_PARAM_CUR_PRESET: 2358 *(uint16_t *)pValue = (uint16_t)EqualizerGetPreset(pContext); 2359 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_CUR_PRESET %d", *(int32_t *)pValue); 2360 break; 2361 2362 case EQ_PARAM_GET_NUM_OF_PRESETS: 2363 *(uint16_t *)pValue = (uint16_t)EqualizerGetNumPresets(); 2364 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_GET_NUM_OF_PRESETS %d", *(int16_t *)pValue); 2365 break; 2366 2367 case EQ_PARAM_GET_PRESET_NAME: 2368 param2 = *pParamTemp; 2369 if (param2 >= EqualizerGetNumPresets()) { 2370 //if (param2 >= 20) { // AGO FIX 2371 status = -EINVAL; 2372 break; 2373 } 2374 name = (char *)pValue; 2375 strncpy(name, EqualizerGetPresetName(param2), *pValueSize - 1); 2376 name[*pValueSize - 1] = 0; 2377 *pValueSize = strlen(name) + 1; 2378 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_GET_PRESET_NAME preset %d, name %s len %d", 2379 // param2, gEqualizerPresets[param2].name, *pValueSize); 2380 break; 2381 2382 case EQ_PARAM_PROPERTIES: { 2383 int16_t *p = (int16_t *)pValue; 2384 ALOGV("\tEqualizer_getParameter() EQ_PARAM_PROPERTIES"); 2385 p[0] = (int16_t)EqualizerGetPreset(pContext); 2386 p[1] = (int16_t)FIVEBAND_NUMBANDS; 2387 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 2388 p[2 + i] = (int16_t)EqualizerGetBandLevel(pContext, i); 2389 } 2390 } break; 2391 2392 default: 2393 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid param %d", param); 2394 status = -EINVAL; 2395 break; 2396 } 2397 2398 //GV("\tEqualizer_getParameter end\n"); 2399 return status; 2400} /* end Equalizer_getParameter */ 2401 2402//---------------------------------------------------------------------------- 2403// Equalizer_setParameter() 2404//---------------------------------------------------------------------------- 2405// Purpose: 2406// Set a Equalizer parameter 2407// 2408// Inputs: 2409// pEqualizer - handle to instance data 2410// pParam - pointer to parameter 2411// pValue - pointer to value 2412// 2413// Outputs: 2414// 2415//---------------------------------------------------------------------------- 2416int Equalizer_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2417 int status = 0; 2418 int32_t preset; 2419 int32_t band; 2420 int32_t level; 2421 int32_t *pParamTemp = (int32_t *)pParam; 2422 int32_t param = *pParamTemp++; 2423 2424 2425 //ALOGV("\tEqualizer_setParameter start"); 2426 switch (param) { 2427 case EQ_PARAM_CUR_PRESET: 2428 preset = (int32_t)(*(uint16_t *)pValue); 2429 2430 //ALOGV("\tEqualizer_setParameter() EQ_PARAM_CUR_PRESET %d", preset); 2431 if ((preset >= EqualizerGetNumPresets())||(preset < 0)) { 2432 status = -EINVAL; 2433 break; 2434 } 2435 EqualizerSetPreset(pContext, preset); 2436 break; 2437 case EQ_PARAM_BAND_LEVEL: 2438 band = *pParamTemp; 2439 level = (int32_t)(*(int16_t *)pValue); 2440 //ALOGV("\tEqualizer_setParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", band, level); 2441 if (band >= FIVEBAND_NUMBANDS) { 2442 status = -EINVAL; 2443 break; 2444 } 2445 EqualizerSetBandLevel(pContext, band, level); 2446 break; 2447 case EQ_PARAM_PROPERTIES: { 2448 //ALOGV("\tEqualizer_setParameter() EQ_PARAM_PROPERTIES"); 2449 int16_t *p = (int16_t *)pValue; 2450 if ((int)p[0] >= EqualizerGetNumPresets()) { 2451 status = -EINVAL; 2452 break; 2453 } 2454 if (p[0] >= 0) { 2455 EqualizerSetPreset(pContext, (int)p[0]); 2456 } else { 2457 if ((int)p[1] != FIVEBAND_NUMBANDS) { 2458 status = -EINVAL; 2459 break; 2460 } 2461 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 2462 EqualizerSetBandLevel(pContext, i, (int)p[2 + i]); 2463 } 2464 } 2465 } break; 2466 default: 2467 ALOGV("\tLVM_ERROR : Equalizer_setParameter() invalid param %d", param); 2468 status = -EINVAL; 2469 break; 2470 } 2471 2472 //ALOGV("\tEqualizer_setParameter end"); 2473 return status; 2474} /* end Equalizer_setParameter */ 2475 2476//---------------------------------------------------------------------------- 2477// Volume_getParameter() 2478//---------------------------------------------------------------------------- 2479// Purpose: 2480// Get a Volume parameter 2481// 2482// Inputs: 2483// pVolume - handle to instance data 2484// pParam - pointer to parameter 2485// pValue - pointer to variable to hold retrieved value 2486// pValueSize - pointer to value size: maximum size as input 2487// 2488// Outputs: 2489// *pValue updated with parameter value 2490// *pValueSize updated with actual value size 2491// 2492// 2493// Side Effects: 2494// 2495//---------------------------------------------------------------------------- 2496 2497int Volume_getParameter(EffectContext *pContext, 2498 void *pParam, 2499 uint32_t *pValueSize, 2500 void *pValue){ 2501 int status = 0; 2502 int bMute = 0; 2503 int32_t *pParamTemp = (int32_t *)pParam; 2504 int32_t param = *pParamTemp++;; 2505 char *name; 2506 2507 //ALOGV("\tVolume_getParameter start"); 2508 2509 switch (param){ 2510 case VOLUME_PARAM_LEVEL: 2511 case VOLUME_PARAM_MAXLEVEL: 2512 case VOLUME_PARAM_STEREOPOSITION: 2513 if (*pValueSize != sizeof(int16_t)){ 2514 ALOGV("\tLVM_ERROR : Volume_getParameter() invalid pValueSize 1 %d", *pValueSize); 2515 return -EINVAL; 2516 } 2517 *pValueSize = sizeof(int16_t); 2518 break; 2519 2520 case VOLUME_PARAM_MUTE: 2521 case VOLUME_PARAM_ENABLESTEREOPOSITION: 2522 if (*pValueSize < sizeof(int32_t)){ 2523 ALOGV("\tLVM_ERROR : Volume_getParameter() invalid pValueSize 2 %d", *pValueSize); 2524 return -EINVAL; 2525 } 2526 *pValueSize = sizeof(int32_t); 2527 break; 2528 2529 default: 2530 ALOGV("\tLVM_ERROR : Volume_getParameter unknown param %d", param); 2531 return -EINVAL; 2532 } 2533 2534 switch (param){ 2535 case VOLUME_PARAM_LEVEL: 2536 status = VolumeGetVolumeLevel(pContext, (int16_t *)(pValue)); 2537 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_LEVEL Value is %d", 2538 // *(int16_t *)pValue); 2539 break; 2540 2541 case VOLUME_PARAM_MAXLEVEL: 2542 *(int16_t *)pValue = 0; 2543 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_MAXLEVEL Value is %d", 2544 // *(int16_t *)pValue); 2545 break; 2546 2547 case VOLUME_PARAM_STEREOPOSITION: 2548 VolumeGetStereoPosition(pContext, (int16_t *)pValue); 2549 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_STEREOPOSITION Value is %d", 2550 // *(int16_t *)pValue); 2551 break; 2552 2553 case VOLUME_PARAM_MUTE: 2554 status = VolumeGetMute(pContext, (uint32_t *)pValue); 2555 ALOGV("\tVolume_getParameter() VOLUME_PARAM_MUTE Value is %d", 2556 *(uint32_t *)pValue); 2557 break; 2558 2559 case VOLUME_PARAM_ENABLESTEREOPOSITION: 2560 *(int32_t *)pValue = pContext->pBundledContext->bStereoPositionEnabled; 2561 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_ENABLESTEREOPOSITION Value is %d", 2562 // *(uint32_t *)pValue); 2563 break; 2564 2565 default: 2566 ALOGV("\tLVM_ERROR : Volume_getParameter() invalid param %d", param); 2567 status = -EINVAL; 2568 break; 2569 } 2570 2571 //ALOGV("\tVolume_getParameter end"); 2572 return status; 2573} /* end Volume_getParameter */ 2574 2575 2576//---------------------------------------------------------------------------- 2577// Volume_setParameter() 2578//---------------------------------------------------------------------------- 2579// Purpose: 2580// Set a Volume parameter 2581// 2582// Inputs: 2583// pVolume - handle to instance data 2584// pParam - pointer to parameter 2585// pValue - pointer to value 2586// 2587// Outputs: 2588// 2589//---------------------------------------------------------------------------- 2590 2591int Volume_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2592 int status = 0; 2593 int16_t level; 2594 int16_t position; 2595 uint32_t mute; 2596 uint32_t positionEnabled; 2597 int32_t *pParamTemp = (int32_t *)pParam; 2598 int32_t param = *pParamTemp++; 2599 2600 //ALOGV("\tVolume_setParameter start"); 2601 2602 switch (param){ 2603 case VOLUME_PARAM_LEVEL: 2604 level = *(int16_t *)pValue; 2605 //ALOGV("\tVolume_setParameter() VOLUME_PARAM_LEVEL value is %d", level); 2606 //ALOGV("\tVolume_setParameter() Calling pVolume->setVolumeLevel"); 2607 status = VolumeSetVolumeLevel(pContext, (int16_t)level); 2608 //ALOGV("\tVolume_setParameter() Called pVolume->setVolumeLevel"); 2609 break; 2610 2611 case VOLUME_PARAM_MUTE: 2612 mute = *(uint32_t *)pValue; 2613 //ALOGV("\tVolume_setParameter() Calling pVolume->setMute, mute is %d", mute); 2614 //ALOGV("\tVolume_setParameter() Calling pVolume->setMute"); 2615 status = VolumeSetMute(pContext, mute); 2616 //ALOGV("\tVolume_setParameter() Called pVolume->setMute"); 2617 break; 2618 2619 case VOLUME_PARAM_ENABLESTEREOPOSITION: 2620 positionEnabled = *(uint32_t *)pValue; 2621 status = VolumeEnableStereoPosition(pContext, positionEnabled); 2622 status = VolumeSetStereoPosition(pContext, pContext->pBundledContext->positionSaved); 2623 //ALOGV("\tVolume_setParameter() VOLUME_PARAM_ENABLESTEREOPOSITION called"); 2624 break; 2625 2626 case VOLUME_PARAM_STEREOPOSITION: 2627 position = *(int16_t *)pValue; 2628 //ALOGV("\tVolume_setParameter() VOLUME_PARAM_STEREOPOSITION value is %d", position); 2629 //ALOGV("\tVolume_setParameter() Calling pVolume->VolumeSetStereoPosition"); 2630 status = VolumeSetStereoPosition(pContext, (int16_t)position); 2631 //ALOGV("\tVolume_setParameter() Called pVolume->VolumeSetStereoPosition"); 2632 break; 2633 2634 default: 2635 ALOGV("\tLVM_ERROR : Volume_setParameter() invalid param %d", param); 2636 break; 2637 } 2638 2639 //ALOGV("\tVolume_setParameter end"); 2640 return status; 2641} /* end Volume_setParameter */ 2642 2643/**************************************************************************************** 2644 * Name : LVC_ToDB_s32Tos16() 2645 * Input : Signed 32-bit integer 2646 * Output : Signed 16-bit integer 2647 * MSB (16) = sign bit 2648 * (15->05) = integer part 2649 * (04->01) = decimal part 2650 * Returns : Db value with respect to full scale 2651 * Description : 2652 * Remarks : 2653 ****************************************************************************************/ 2654 2655LVM_INT16 LVC_ToDB_s32Tos16(LVM_INT32 Lin_fix) 2656{ 2657 LVM_INT16 db_fix; 2658 LVM_INT16 Shift; 2659 LVM_INT16 SmallRemainder; 2660 LVM_UINT32 Remainder = (LVM_UINT32)Lin_fix; 2661 2662 /* Count leading bits, 1 cycle in assembly*/ 2663 for (Shift = 0; Shift<32; Shift++) 2664 { 2665 if ((Remainder & 0x80000000U)!=0) 2666 { 2667 break; 2668 } 2669 Remainder = Remainder << 1; 2670 } 2671 2672 /* 2673 * Based on the approximation equation (for Q11.4 format): 2674 * 2675 * dB = -96 * Shift + 16 * (8 * Remainder - 2 * Remainder^2) 2676 */ 2677 db_fix = (LVM_INT16)(-96 * Shift); /* Six dB steps in Q11.4 format*/ 2678 SmallRemainder = (LVM_INT16)((Remainder & 0x7fffffff) >> 24); 2679 db_fix = (LVM_INT16)(db_fix + SmallRemainder ); 2680 SmallRemainder = (LVM_INT16)(SmallRemainder * SmallRemainder); 2681 db_fix = (LVM_INT16)(db_fix - (LVM_INT16)((LVM_UINT16)SmallRemainder >> 9)); 2682 2683 /* Correct for small offset */ 2684 db_fix = (LVM_INT16)(db_fix - 5); 2685 2686 return db_fix; 2687} 2688 2689//---------------------------------------------------------------------------- 2690// Effect_setEnabled() 2691//---------------------------------------------------------------------------- 2692// Purpose: 2693// Enable or disable effect 2694// 2695// Inputs: 2696// pContext - pointer to effect context 2697// enabled - true if enabling the effect, false otherwise 2698// 2699// Outputs: 2700// 2701//---------------------------------------------------------------------------- 2702 2703int Effect_setEnabled(EffectContext *pContext, bool enabled) 2704{ 2705 ALOGV("\tEffect_setEnabled() type %d, enabled %d", pContext->EffectType, enabled); 2706 2707 if (enabled) { 2708 // Bass boost or Virtualizer can be temporarily disabled if playing over device speaker due 2709 // to their nature. 2710 bool tempDisabled = false; 2711 switch (pContext->EffectType) { 2712 case LVM_BASS_BOOST: 2713 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 2714 ALOGV("\tEffect_setEnabled() LVM_BASS_BOOST is already enabled"); 2715 return -EINVAL; 2716 } 2717 if(pContext->pBundledContext->SamplesToExitCountBb <= 0){ 2718 pContext->pBundledContext->NumberEffectsEnabled++; 2719 } 2720 pContext->pBundledContext->SamplesToExitCountBb = 2721 (LVM_INT32)(pContext->pBundledContext->SamplesPerSecond*0.1); 2722 pContext->pBundledContext->bBassEnabled = LVM_TRUE; 2723 tempDisabled = pContext->pBundledContext->bBassTempDisabled; 2724 break; 2725 case LVM_EQUALIZER: 2726 if (pContext->pBundledContext->bEqualizerEnabled == LVM_TRUE) { 2727 ALOGV("\tEffect_setEnabled() LVM_EQUALIZER is already enabled"); 2728 return -EINVAL; 2729 } 2730 if(pContext->pBundledContext->SamplesToExitCountEq <= 0){ 2731 pContext->pBundledContext->NumberEffectsEnabled++; 2732 } 2733 pContext->pBundledContext->SamplesToExitCountEq = 2734 (LVM_INT32)(pContext->pBundledContext->SamplesPerSecond*0.1); 2735 pContext->pBundledContext->bEqualizerEnabled = LVM_TRUE; 2736 break; 2737 case LVM_VIRTUALIZER: 2738 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) { 2739 ALOGV("\tEffect_setEnabled() LVM_VIRTUALIZER is already enabled"); 2740 return -EINVAL; 2741 } 2742 if(pContext->pBundledContext->SamplesToExitCountVirt <= 0){ 2743 pContext->pBundledContext->NumberEffectsEnabled++; 2744 } 2745 pContext->pBundledContext->SamplesToExitCountVirt = 2746 (LVM_INT32)(pContext->pBundledContext->SamplesPerSecond*0.1); 2747 pContext->pBundledContext->bVirtualizerEnabled = LVM_TRUE; 2748 tempDisabled = pContext->pBundledContext->bVirtualizerTempDisabled; 2749 break; 2750 case LVM_VOLUME: 2751 if (pContext->pBundledContext->bVolumeEnabled == LVM_TRUE) { 2752 ALOGV("\tEffect_setEnabled() LVM_VOLUME is already enabled"); 2753 return -EINVAL; 2754 } 2755 pContext->pBundledContext->NumberEffectsEnabled++; 2756 pContext->pBundledContext->bVolumeEnabled = LVM_TRUE; 2757 break; 2758 default: 2759 ALOGV("\tEffect_setEnabled() invalid effect type"); 2760 return -EINVAL; 2761 } 2762 if (!tempDisabled) { 2763 LvmEffect_enable(pContext); 2764 } 2765 } else { 2766 switch (pContext->EffectType) { 2767 case LVM_BASS_BOOST: 2768 if (pContext->pBundledContext->bBassEnabled == LVM_FALSE) { 2769 ALOGV("\tEffect_setEnabled() LVM_BASS_BOOST is already disabled"); 2770 return -EINVAL; 2771 } 2772 pContext->pBundledContext->bBassEnabled = LVM_FALSE; 2773 break; 2774 case LVM_EQUALIZER: 2775 if (pContext->pBundledContext->bEqualizerEnabled == LVM_FALSE) { 2776 ALOGV("\tEffect_setEnabled() LVM_EQUALIZER is already disabled"); 2777 return -EINVAL; 2778 } 2779 pContext->pBundledContext->bEqualizerEnabled = LVM_FALSE; 2780 break; 2781 case LVM_VIRTUALIZER: 2782 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_FALSE) { 2783 ALOGV("\tEffect_setEnabled() LVM_VIRTUALIZER is already disabled"); 2784 return -EINVAL; 2785 } 2786 pContext->pBundledContext->bVirtualizerEnabled = LVM_FALSE; 2787 break; 2788 case LVM_VOLUME: 2789 if (pContext->pBundledContext->bVolumeEnabled == LVM_FALSE) { 2790 ALOGV("\tEffect_setEnabled() LVM_VOLUME is already disabled"); 2791 return -EINVAL; 2792 } 2793 pContext->pBundledContext->bVolumeEnabled = LVM_FALSE; 2794 break; 2795 default: 2796 ALOGV("\tEffect_setEnabled() invalid effect type"); 2797 return -EINVAL; 2798 } 2799 LvmEffect_disable(pContext); 2800 } 2801 2802 return 0; 2803} 2804 2805//---------------------------------------------------------------------------- 2806// LVC_Convert_VolToDb() 2807//---------------------------------------------------------------------------- 2808// Purpose: 2809// Convery volume in Q24 to dB 2810// 2811// Inputs: 2812// vol: Q.24 volume dB 2813// 2814//----------------------------------------------------------------------- 2815 2816int16_t LVC_Convert_VolToDb(uint32_t vol){ 2817 int16_t dB; 2818 2819 dB = LVC_ToDB_s32Tos16(vol <<7); 2820 dB = (dB +8)>>4; 2821 dB = (dB <-96) ? -96 : dB ; 2822 2823 return dB; 2824} 2825 2826} // namespace 2827} // namespace 2828 2829extern "C" { 2830/* Effect Control Interface Implementation: Process */ 2831int Effect_process(effect_handle_t self, 2832 audio_buffer_t *inBuffer, 2833 audio_buffer_t *outBuffer){ 2834 EffectContext * pContext = (EffectContext *) self; 2835 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 2836 int status = 0; 2837 int lvmStatus = 0; 2838 LVM_INT16 *in = (LVM_INT16 *)inBuffer->raw; 2839 LVM_INT16 *out = (LVM_INT16 *)outBuffer->raw; 2840 2841//ALOGV("\tEffect_process Start : Enabled = %d Called = %d (%8d %8d %8d)", 2842//pContext->pBundledContext->NumberEffectsEnabled,pContext->pBundledContext->NumberEffectsCalled, 2843// pContext->pBundledContext->SamplesToExitCountBb, 2844// pContext->pBundledContext->SamplesToExitCountVirt, 2845// pContext->pBundledContext->SamplesToExitCountEq); 2846 2847 if (pContext == NULL){ 2848 ALOGV("\tLVM_ERROR : Effect_process() ERROR pContext == NULL"); 2849 return -EINVAL; 2850 } 2851 2852 //if(pContext->EffectType == LVM_BASS_BOOST){ 2853 // ALOGV("\tEffect_process: Effect type is BASS_BOOST"); 2854 //}else if(pContext->EffectType == LVM_EQUALIZER){ 2855 // ALOGV("\tEffect_process: Effect type is LVM_EQUALIZER"); 2856 //}else if(pContext->EffectType == LVM_VIRTUALIZER){ 2857 // ALOGV("\tEffect_process: Effect type is LVM_VIRTUALIZER"); 2858 //} 2859 2860 if (inBuffer == NULL || inBuffer->raw == NULL || 2861 outBuffer == NULL || outBuffer->raw == NULL || 2862 inBuffer->frameCount != outBuffer->frameCount){ 2863 ALOGV("\tLVM_ERROR : Effect_process() ERROR NULL INPUT POINTER OR FRAME COUNT IS WRONG"); 2864 return -EINVAL; 2865 } 2866 if ((pContext->pBundledContext->bBassEnabled == LVM_FALSE)&& 2867 (pContext->EffectType == LVM_BASS_BOOST)){ 2868 //ALOGV("\tEffect_process() LVM_BASS_BOOST Effect is not enabled"); 2869 if(pContext->pBundledContext->SamplesToExitCountBb > 0){ 2870 pContext->pBundledContext->SamplesToExitCountBb -= outBuffer->frameCount * 2; // STEREO 2871 //ALOGV("\tEffect_process: Waiting to turn off BASS_BOOST, %d samples left", 2872 // pContext->pBundledContext->SamplesToExitCountBb); 2873 } 2874 if(pContext->pBundledContext->SamplesToExitCountBb <= 0) { 2875 status = -ENODATA; 2876 pContext->pBundledContext->NumberEffectsEnabled--; 2877 ALOGV("\tEffect_process() this is the last frame for LVM_BASS_BOOST"); 2878 } 2879 } 2880 if ((pContext->pBundledContext->bVolumeEnabled == LVM_FALSE)&& 2881 (pContext->EffectType == LVM_VOLUME)){ 2882 //ALOGV("\tEffect_process() LVM_VOLUME Effect is not enabled"); 2883 status = -ENODATA; 2884 pContext->pBundledContext->NumberEffectsEnabled--; 2885 } 2886 if ((pContext->pBundledContext->bEqualizerEnabled == LVM_FALSE)&& 2887 (pContext->EffectType == LVM_EQUALIZER)){ 2888 //ALOGV("\tEffect_process() LVM_EQUALIZER Effect is not enabled"); 2889 if(pContext->pBundledContext->SamplesToExitCountEq > 0){ 2890 pContext->pBundledContext->SamplesToExitCountEq -= outBuffer->frameCount * 2; // STEREO 2891 //ALOGV("\tEffect_process: Waiting to turn off EQUALIZER, %d samples left", 2892 // pContext->pBundledContext->SamplesToExitCountEq); 2893 } 2894 if(pContext->pBundledContext->SamplesToExitCountEq <= 0) { 2895 status = -ENODATA; 2896 pContext->pBundledContext->NumberEffectsEnabled--; 2897 ALOGV("\tEffect_process() this is the last frame for LVM_EQUALIZER"); 2898 } 2899 } 2900 if ((pContext->pBundledContext->bVirtualizerEnabled == LVM_FALSE)&& 2901 (pContext->EffectType == LVM_VIRTUALIZER)){ 2902 //ALOGV("\tEffect_process() LVM_VIRTUALIZER Effect is not enabled"); 2903 if(pContext->pBundledContext->SamplesToExitCountVirt > 0){ 2904 pContext->pBundledContext->SamplesToExitCountVirt -= outBuffer->frameCount * 2;// STEREO 2905 //ALOGV("\tEffect_process: Waiting for to turn off VIRTUALIZER, %d samples left", 2906 // pContext->pBundledContext->SamplesToExitCountVirt); 2907 } 2908 if(pContext->pBundledContext->SamplesToExitCountVirt <= 0) { 2909 status = -ENODATA; 2910 pContext->pBundledContext->NumberEffectsEnabled--; 2911 ALOGV("\tEffect_process() this is the last frame for LVM_VIRTUALIZER"); 2912 } 2913 } 2914 2915 if(status != -ENODATA){ 2916 pContext->pBundledContext->NumberEffectsCalled++; 2917 } 2918 2919 if(pContext->pBundledContext->NumberEffectsCalled == 2920 pContext->pBundledContext->NumberEffectsEnabled){ 2921 //ALOGV("\tEffect_process Calling process with %d effects enabled, %d called: Effect %d", 2922 //pContext->pBundledContext->NumberEffectsEnabled, 2923 //pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType); 2924 2925 if(status == -ENODATA){ 2926 ALOGV("\tEffect_process() processing last frame"); 2927 } 2928 pContext->pBundledContext->NumberEffectsCalled = 0; 2929 /* Process all the available frames, block processing is 2930 handled internalLY by the LVM bundle */ 2931 lvmStatus = android::LvmBundle_process( (LVM_INT16 *)inBuffer->raw, 2932 (LVM_INT16 *)outBuffer->raw, 2933 outBuffer->frameCount, 2934 pContext); 2935 if(lvmStatus != LVM_SUCCESS){ 2936 ALOGV("\tLVM_ERROR : LvmBundle_process returned error %d", lvmStatus); 2937 return lvmStatus; 2938 } 2939 } else { 2940 //ALOGV("\tEffect_process Not Calling process with %d effects enabled, %d called: Effect %d", 2941 //pContext->pBundledContext->NumberEffectsEnabled, 2942 //pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType); 2943 // 2 is for stereo input 2944 if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) { 2945 for (size_t i=0; i < outBuffer->frameCount*2; i++){ 2946 outBuffer->s16[i] = 2947 clamp16((LVM_INT32)outBuffer->s16[i] + (LVM_INT32)inBuffer->s16[i]); 2948 } 2949 } else if (outBuffer->raw != inBuffer->raw) { 2950 memcpy(outBuffer->raw, inBuffer->raw, outBuffer->frameCount*sizeof(LVM_INT16)*2); 2951 } 2952 } 2953 2954 return status; 2955} /* end Effect_process */ 2956 2957/* Effect Control Interface Implementation: Command */ 2958int Effect_command(effect_handle_t self, 2959 uint32_t cmdCode, 2960 uint32_t cmdSize, 2961 void *pCmdData, 2962 uint32_t *replySize, 2963 void *pReplyData){ 2964 EffectContext * pContext = (EffectContext *) self; 2965 int retsize; 2966 2967 //ALOGV("\t\nEffect_command start"); 2968 2969 if(pContext->EffectType == LVM_BASS_BOOST){ 2970 //ALOGV("\tEffect_command setting command for LVM_BASS_BOOST"); 2971 } 2972 if(pContext->EffectType == LVM_VIRTUALIZER){ 2973 //ALOGV("\tEffect_command setting command for LVM_VIRTUALIZER"); 2974 } 2975 if(pContext->EffectType == LVM_EQUALIZER){ 2976 //ALOGV("\tEffect_command setting command for LVM_EQUALIZER"); 2977 } 2978 if(pContext->EffectType == LVM_VOLUME){ 2979 //ALOGV("\tEffect_command setting command for LVM_VOLUME"); 2980 } 2981 2982 if (pContext == NULL){ 2983 ALOGV("\tLVM_ERROR : Effect_command ERROR pContext == NULL"); 2984 return -EINVAL; 2985 } 2986 2987 //ALOGV("\tEffect_command INPUTS are: command %d cmdSize %d",cmdCode, cmdSize); 2988 2989 // Incase we disable an effect, next time process is 2990 // called the number of effect called could be greater 2991 // pContext->pBundledContext->NumberEffectsCalled = 0; 2992 2993 //ALOGV("\tEffect_command NumberEffectsCalled = %d, NumberEffectsEnabled = %d", 2994 // pContext->pBundledContext->NumberEffectsCalled, 2995 // pContext->pBundledContext->NumberEffectsEnabled); 2996 2997 switch (cmdCode){ 2998 case EFFECT_CMD_INIT: 2999 if (pReplyData == NULL || *replySize != sizeof(int)){ 3000 ALOGV("\tLVM_ERROR, EFFECT_CMD_INIT: ERROR for effect type %d", 3001 pContext->EffectType); 3002 return -EINVAL; 3003 } 3004 *(int *) pReplyData = 0; 3005 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT start"); 3006 if(pContext->EffectType == LVM_BASS_BOOST){ 3007 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_BASS_BOOST"); 3008 android::BassSetStrength(pContext, 0); 3009 } 3010 if(pContext->EffectType == LVM_VIRTUALIZER){ 3011 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_VIRTUALIZER"); 3012 android::VirtualizerSetStrength(pContext, 0); 3013 } 3014 if(pContext->EffectType == LVM_EQUALIZER){ 3015 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_EQUALIZER"); 3016 android::EqualizerSetPreset(pContext, 0); 3017 } 3018 if(pContext->EffectType == LVM_VOLUME){ 3019 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_VOLUME"); 3020 *(int *) pReplyData = android::VolumeSetVolumeLevel(pContext, 0); 3021 } 3022 break; 3023 3024 case EFFECT_CMD_SET_CONFIG: 3025 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_CONFIG start"); 3026 if (pCmdData == NULL|| 3027 cmdSize != sizeof(effect_config_t)|| 3028 pReplyData == NULL|| 3029 *replySize != sizeof(int)){ 3030 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: " 3031 "EFFECT_CMD_SET_CONFIG: ERROR"); 3032 return -EINVAL; 3033 } 3034 *(int *) pReplyData = android::Effect_setConfig(pContext, (effect_config_t *) pCmdData); 3035 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_CONFIG end"); 3036 break; 3037 3038 case EFFECT_CMD_GET_CONFIG: 3039 if (pReplyData == NULL || 3040 *replySize != sizeof(effect_config_t)) { 3041 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: " 3042 "EFFECT_CMD_GET_CONFIG: ERROR"); 3043 return -EINVAL; 3044 } 3045 3046 android::Effect_getConfig(pContext, (effect_config_t *)pReplyData); 3047 break; 3048 3049 case EFFECT_CMD_RESET: 3050 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_RESET start"); 3051 android::Effect_setConfig(pContext, &pContext->config); 3052 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_RESET end"); 3053 break; 3054 3055 case EFFECT_CMD_GET_PARAM:{ 3056 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_GET_PARAM start"); 3057 3058 if(pContext->EffectType == LVM_BASS_BOOST){ 3059 if (pCmdData == NULL || 3060 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3061 pReplyData == NULL || 3062 *replySize < (sizeof(effect_param_t) + sizeof(int32_t))){ 3063 ALOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: " 3064 "EFFECT_CMD_GET_PARAM: ERROR"); 3065 return -EINVAL; 3066 } 3067 effect_param_t *p = (effect_param_t *)pCmdData; 3068 3069 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3070 3071 p = (effect_param_t *)pReplyData; 3072 3073 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3074 3075 p->status = android::BassBoost_getParameter(pContext, 3076 p->data, 3077 &p->vsize, 3078 p->data + voffset); 3079 3080 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3081 3082 //ALOGV("\tBassBoost_command EFFECT_CMD_GET_PARAM " 3083 // "*pCmdData %d, *replySize %d, *pReplyData %d ", 3084 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3085 // *replySize, 3086 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset)); 3087 } 3088 3089 if(pContext->EffectType == LVM_VIRTUALIZER){ 3090 if (pCmdData == NULL || 3091 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3092 pReplyData == NULL || 3093 *replySize < (sizeof(effect_param_t) + sizeof(int32_t))){ 3094 ALOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: " 3095 "EFFECT_CMD_GET_PARAM: ERROR"); 3096 return -EINVAL; 3097 } 3098 effect_param_t *p = (effect_param_t *)pCmdData; 3099 3100 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3101 3102 p = (effect_param_t *)pReplyData; 3103 3104 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3105 3106 p->status = android::Virtualizer_getParameter(pContext, 3107 (void *)p->data, 3108 &p->vsize, 3109 p->data + voffset); 3110 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3111 3112 //ALOGV("\tVirtualizer_command EFFECT_CMD_GET_PARAM " 3113 // "*pCmdData %d, *replySize %d, *pReplyData %d ", 3114 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3115 // *replySize, 3116 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset)); 3117 } 3118 if(pContext->EffectType == LVM_EQUALIZER){ 3119 //ALOGV("\tEqualizer_command cmdCode Case: " 3120 // "EFFECT_CMD_GET_PARAM start"); 3121 if (pCmdData == NULL || 3122 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3123 pReplyData == NULL || 3124 *replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))) { 3125 ALOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: " 3126 "EFFECT_CMD_GET_PARAM"); 3127 return -EINVAL; 3128 } 3129 effect_param_t *p = (effect_param_t *)pCmdData; 3130 3131 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3132 3133 p = (effect_param_t *)pReplyData; 3134 3135 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3136 3137 p->status = android::Equalizer_getParameter(pContext, 3138 p->data, 3139 &p->vsize, 3140 p->data + voffset); 3141 3142 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3143 3144 //ALOGV("\tEqualizer_command EFFECT_CMD_GET_PARAM *pCmdData %d, *replySize %d, " 3145 // "*pReplyData %08x %08x", 3146 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), *replySize, 3147 // *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset), 3148 // *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset + 3149 // sizeof(int32_t))); 3150 } 3151 if(pContext->EffectType == LVM_VOLUME){ 3152 //ALOGV("\tVolume_command cmdCode Case: EFFECT_CMD_GET_PARAM start"); 3153 if (pCmdData == NULL || 3154 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3155 pReplyData == NULL || 3156 *replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))){ 3157 ALOGV("\tLVM_ERROR : Volume_command cmdCode Case: " 3158 "EFFECT_CMD_GET_PARAM: ERROR"); 3159 return -EINVAL; 3160 } 3161 effect_param_t *p = (effect_param_t *)pCmdData; 3162 3163 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3164 3165 p = (effect_param_t *)pReplyData; 3166 3167 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3168 3169 p->status = android::Volume_getParameter(pContext, 3170 (void *)p->data, 3171 &p->vsize, 3172 p->data + voffset); 3173 3174 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3175 3176 //ALOGV("\tVolume_command EFFECT_CMD_GET_PARAM " 3177 // "*pCmdData %d, *replySize %d, *pReplyData %d ", 3178 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3179 // *replySize, 3180 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset)); 3181 } 3182 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_GET_PARAM end"); 3183 } break; 3184 case EFFECT_CMD_SET_PARAM:{ 3185 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_PARAM start"); 3186 if(pContext->EffectType == LVM_BASS_BOOST){ 3187 //ALOGV("\tBassBoost_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d", 3188 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3189 // *replySize, 3190 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t))); 3191 3192 if (pCmdData == NULL|| 3193 cmdSize != (sizeof(effect_param_t) + sizeof(int32_t) +sizeof(int16_t))|| 3194 pReplyData == NULL|| 3195 *replySize != sizeof(int32_t)){ 3196 ALOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: " 3197 "EFFECT_CMD_SET_PARAM: ERROR"); 3198 return -EINVAL; 3199 } 3200 effect_param_t *p = (effect_param_t *) pCmdData; 3201 3202 if (p->psize != sizeof(int32_t)){ 3203 ALOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: " 3204 "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)"); 3205 return -EINVAL; 3206 } 3207 3208 //ALOGV("\tnBassBoost_command cmdSize is %d\n" 3209 // "\tsizeof(effect_param_t) is %d\n" 3210 // "\tp->psize is %d\n" 3211 // "\tp->vsize is %d" 3212 // "\n", 3213 // cmdSize, sizeof(effect_param_t), p->psize, p->vsize ); 3214 3215 *(int *)pReplyData = android::BassBoost_setParameter(pContext, 3216 (void *)p->data, 3217 p->data + p->psize); 3218 } 3219 if(pContext->EffectType == LVM_VIRTUALIZER){ 3220 // Warning this log will fail to properly read an int32_t value, assumes int16_t 3221 //ALOGV("\tVirtualizer_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d", 3222 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3223 // *replySize, 3224 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t))); 3225 3226 if (pCmdData == NULL || 3227 // legal parameters are int16_t or int32_t 3228 cmdSize > (sizeof(effect_param_t) + sizeof(int32_t) +sizeof(int32_t)) || 3229 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t) +sizeof(int16_t)) || 3230 pReplyData == NULL || 3231 *replySize != sizeof(int32_t)){ 3232 ALOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: " 3233 "EFFECT_CMD_SET_PARAM: ERROR"); 3234 return -EINVAL; 3235 } 3236 effect_param_t *p = (effect_param_t *) pCmdData; 3237 3238 if (p->psize != sizeof(int32_t)){ 3239 ALOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: " 3240 "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)"); 3241 return -EINVAL; 3242 } 3243 3244 //ALOGV("\tnVirtualizer_command cmdSize is %d\n" 3245 // "\tsizeof(effect_param_t) is %d\n" 3246 // "\tp->psize is %d\n" 3247 // "\tp->vsize is %d" 3248 // "\n", 3249 // cmdSize, sizeof(effect_param_t), p->psize, p->vsize ); 3250 3251 *(int *)pReplyData = android::Virtualizer_setParameter(pContext, 3252 (void *)p->data, 3253 p->data + p->psize); 3254 } 3255 if(pContext->EffectType == LVM_EQUALIZER){ 3256 //ALOGV("\tEqualizer_command cmdCode Case: " 3257 // "EFFECT_CMD_SET_PARAM start"); 3258 //ALOGV("\tEqualizer_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ", 3259 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3260 // *replySize, 3261 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t))); 3262 3263 if (pCmdData == NULL || cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3264 pReplyData == NULL || *replySize != sizeof(int32_t)) { 3265 ALOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: " 3266 "EFFECT_CMD_SET_PARAM: ERROR"); 3267 return -EINVAL; 3268 } 3269 effect_param_t *p = (effect_param_t *) pCmdData; 3270 3271 *(int *)pReplyData = android::Equalizer_setParameter(pContext, 3272 (void *)p->data, 3273 p->data + p->psize); 3274 } 3275 if(pContext->EffectType == LVM_VOLUME){ 3276 //ALOGV("\tVolume_command cmdCode Case: EFFECT_CMD_SET_PARAM start"); 3277 //ALOGV("\tVolume_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ", 3278 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3279 // *replySize, 3280 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) +sizeof(int32_t))); 3281 3282 if ( pCmdData == NULL|| 3283 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t))|| 3284 pReplyData == NULL|| 3285 *replySize != sizeof(int32_t)){ 3286 ALOGV("\tLVM_ERROR : Volume_command cmdCode Case: " 3287 "EFFECT_CMD_SET_PARAM: ERROR"); 3288 return -EINVAL; 3289 } 3290 effect_param_t *p = (effect_param_t *) pCmdData; 3291 3292 *(int *)pReplyData = android::Volume_setParameter(pContext, 3293 (void *)p->data, 3294 p->data + p->psize); 3295 } 3296 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_PARAM end"); 3297 } break; 3298 3299 case EFFECT_CMD_ENABLE: 3300 ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE start"); 3301 if (pReplyData == NULL || *replySize != sizeof(int)){ 3302 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: EFFECT_CMD_ENABLE: ERROR"); 3303 return -EINVAL; 3304 } 3305 3306 *(int *)pReplyData = android::Effect_setEnabled(pContext, LVM_TRUE); 3307 break; 3308 3309 case EFFECT_CMD_DISABLE: 3310 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE start"); 3311 if (pReplyData == NULL || *replySize != sizeof(int)){ 3312 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: EFFECT_CMD_DISABLE: ERROR"); 3313 return -EINVAL; 3314 } 3315 *(int *)pReplyData = android::Effect_setEnabled(pContext, LVM_FALSE); 3316 break; 3317 3318 case EFFECT_CMD_SET_DEVICE: 3319 { 3320 ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_DEVICE start"); 3321 uint32_t device = *(uint32_t *)pCmdData; 3322 pContext->pBundledContext->nOutputDevice = (audio_devices_t) device; 3323 3324 if (pContext->EffectType == LVM_BASS_BOOST) { 3325 if((device == AUDIO_DEVICE_OUT_SPEAKER) || 3326 (device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT) || 3327 (device == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER)){ 3328 ALOGV("\tEFFECT_CMD_SET_DEVICE device is invalid for LVM_BASS_BOOST %d", 3329 *(int32_t *)pCmdData); 3330 ALOGV("\tEFFECT_CMD_SET_DEVICE temporary disable LVM_BAS_BOOST"); 3331 3332 // If a device doesnt support bassboost the effect must be temporarily disabled 3333 // the effect must still report its original state as this can only be changed 3334 // by the ENABLE/DISABLE command 3335 3336 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 3337 ALOGV("\tEFFECT_CMD_SET_DEVICE disable LVM_BASS_BOOST %d", 3338 *(int32_t *)pCmdData); 3339 android::LvmEffect_disable(pContext); 3340 } 3341 pContext->pBundledContext->bBassTempDisabled = LVM_TRUE; 3342 } else { 3343 ALOGV("\tEFFECT_CMD_SET_DEVICE device is valid for LVM_BASS_BOOST %d", 3344 *(int32_t *)pCmdData); 3345 3346 // If a device supports bassboost and the effect has been temporarily disabled 3347 // previously then re-enable it 3348 3349 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 3350 ALOGV("\tEFFECT_CMD_SET_DEVICE re-enable LVM_BASS_BOOST %d", 3351 *(int32_t *)pCmdData); 3352 android::LvmEffect_enable(pContext); 3353 } 3354 pContext->pBundledContext->bBassTempDisabled = LVM_FALSE; 3355 } 3356 } 3357 if (pContext->EffectType == LVM_VIRTUALIZER) { 3358 if (pContext->pBundledContext->nVirtualizerForcedDevice == AUDIO_DEVICE_NONE) { 3359 // default case unless configuration is forced 3360 if (android::VirtualizerIsDeviceSupported(device) != 0) { 3361 ALOGV("\tEFFECT_CMD_SET_DEVICE device is invalid for LVM_VIRTUALIZER %d", 3362 *(int32_t *)pCmdData); 3363 ALOGV("\tEFFECT_CMD_SET_DEVICE temporary disable LVM_VIRTUALIZER"); 3364 3365 //If a device doesnt support virtualizer the effect must be temporarily 3366 // disabled the effect must still report its original state as this can 3367 // only be changed by the ENABLE/DISABLE command 3368 3369 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) { 3370 ALOGV("\tEFFECT_CMD_SET_DEVICE disable LVM_VIRTUALIZER %d", 3371 *(int32_t *)pCmdData); 3372 android::LvmEffect_disable(pContext); 3373 } 3374 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_TRUE; 3375 } else { 3376 ALOGV("\tEFFECT_CMD_SET_DEVICE device is valid for LVM_VIRTUALIZER %d", 3377 *(int32_t *)pCmdData); 3378 3379 // If a device supports virtualizer and the effect has been temporarily 3380 // disabled previously then re-enable it 3381 3382 if(pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE){ 3383 ALOGV("\tEFFECT_CMD_SET_DEVICE re-enable LVM_VIRTUALIZER %d", 3384 *(int32_t *)pCmdData); 3385 android::LvmEffect_enable(pContext); 3386 } 3387 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_FALSE; 3388 } 3389 } // else virtualization mode is forced to a certain device, nothing to do 3390 } 3391 ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_DEVICE end"); 3392 break; 3393 } 3394 case EFFECT_CMD_SET_VOLUME: 3395 { 3396 uint32_t leftVolume, rightVolume; 3397 int16_t leftdB, rightdB; 3398 int16_t maxdB, pandB; 3399 int32_t vol_ret[2] = {1<<24,1<<24}; // Apply no volume 3400 int status = 0; 3401 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 3402 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 3403 3404 // if pReplyData is NULL, VOL_CTRL is delegated to another effect 3405 if(pReplyData == LVM_NULL){ 3406 break; 3407 } 3408 3409 if (pCmdData == NULL || 3410 cmdSize != 2 * sizeof(uint32_t)) { 3411 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: " 3412 "EFFECT_CMD_SET_VOLUME: ERROR"); 3413 return -EINVAL; 3414 } 3415 3416 leftVolume = ((*(uint32_t *)pCmdData)); 3417 rightVolume = ((*((uint32_t *)pCmdData + 1))); 3418 3419 if(leftVolume == 0x1000000){ 3420 leftVolume -= 1; 3421 } 3422 if(rightVolume == 0x1000000){ 3423 rightVolume -= 1; 3424 } 3425 3426 // Convert volume to dB 3427 leftdB = android::LVC_Convert_VolToDb(leftVolume); 3428 rightdB = android::LVC_Convert_VolToDb(rightVolume); 3429 3430 pandB = rightdB - leftdB; 3431 3432 // Calculate max volume in dB 3433 maxdB = leftdB; 3434 if(rightdB > maxdB){ 3435 maxdB = rightdB; 3436 } 3437 //ALOGV("\tEFFECT_CMD_SET_VOLUME Session: %d, SessionID: %d VOLUME is %d dB (%d), " 3438 // "effect is %d", 3439 //pContext->pBundledContext->SessionNo, pContext->pBundledContext->SessionId, 3440 //(int32_t)maxdB, maxVol<<7, pContext->EffectType); 3441 //ALOGV("\tEFFECT_CMD_SET_VOLUME: Left is %d, Right is %d", leftVolume, rightVolume); 3442 //ALOGV("\tEFFECT_CMD_SET_VOLUME: Left %ddB, Right %ddB, Position %ddB", 3443 // leftdB, rightdB, pandB); 3444 3445 memcpy(pReplyData, vol_ret, sizeof(int32_t)*2); 3446 android::VolumeSetVolumeLevel(pContext, (int16_t)(maxdB*100)); 3447 3448 /* Get the current settings */ 3449 LvmStatus =LVM_GetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams); 3450 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetStereoPosition") 3451 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 3452 3453 /* Volume parameters */ 3454 ActiveParams.VC_Balance = pandB; 3455 ALOGV("\t\tVolumeSetStereoPosition() (-96dB -> +96dB)-> %d\n", ActiveParams.VC_Balance ); 3456 3457 /* Activate the initial settings */ 3458 LvmStatus =LVM_SetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams); 3459 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeSetStereoPosition") 3460 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 3461 break; 3462 } 3463 case EFFECT_CMD_SET_AUDIO_MODE: 3464 break; 3465 default: 3466 return -EINVAL; 3467 } 3468 3469 //ALOGV("\tEffect_command end...\n\n"); 3470 return 0; 3471} /* end Effect_command */ 3472 3473/* Effect Control Interface Implementation: get_descriptor */ 3474int Effect_getDescriptor(effect_handle_t self, 3475 effect_descriptor_t *pDescriptor) 3476{ 3477 EffectContext * pContext = (EffectContext *) self; 3478 const effect_descriptor_t *desc; 3479 3480 if (pContext == NULL || pDescriptor == NULL) { 3481 ALOGV("Effect_getDescriptor() invalid param"); 3482 return -EINVAL; 3483 } 3484 3485 switch(pContext->EffectType) { 3486 case LVM_BASS_BOOST: 3487 desc = &android::gBassBoostDescriptor; 3488 break; 3489 case LVM_VIRTUALIZER: 3490 desc = &android::gVirtualizerDescriptor; 3491 break; 3492 case LVM_EQUALIZER: 3493 desc = &android::gEqualizerDescriptor; 3494 break; 3495 case LVM_VOLUME: 3496 desc = &android::gVolumeDescriptor; 3497 break; 3498 default: 3499 return -EINVAL; 3500 } 3501 3502 *pDescriptor = *desc; 3503 3504 return 0; 3505} /* end Effect_getDescriptor */ 3506 3507// effect_handle_t interface implementation for effect 3508const struct effect_interface_s gLvmEffectInterface = { 3509 Effect_process, 3510 Effect_command, 3511 Effect_getDescriptor, 3512 NULL, 3513}; /* end gLvmEffectInterface */ 3514 3515// This is the only symbol that needs to be exported 3516__attribute__ ((visibility ("default"))) 3517audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = { 3518 .tag = AUDIO_EFFECT_LIBRARY_TAG, 3519 .version = EFFECT_LIBRARY_API_VERSION, 3520 .name = "Effect Bundle Library", 3521 .implementor = "NXP Software Ltd.", 3522 .create_effect = android::EffectCreate, 3523 .release_effect = android::EffectRelease, 3524 .get_descriptor = android::EffectGetDescriptor, 3525}; 3526 3527} 3528