EffectBundle.cpp revision 47d4c9a4d53ed014b520edbda2edc3e280efb8a5
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// LvmEffect_enable() 771//---------------------------------------------------------------------------- 772// Purpose: Enable the effect in the bundle 773// 774// Inputs: 775// pContext: effect engine context 776// 777// Outputs: 778// 779//---------------------------------------------------------------------------- 780 781int LvmEffect_enable(EffectContext *pContext){ 782 //ALOGV("\tLvmEffect_enable start"); 783 784 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 785 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 786 787 /* Get the current settings */ 788 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 789 &ActiveParams); 790 791 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_enable") 792 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 793 //ALOGV("\tLvmEffect_enable Succesfully called LVM_GetControlParameters\n"); 794 795 if(pContext->EffectType == LVM_BASS_BOOST) { 796 ALOGV("\tLvmEffect_enable : Enabling LVM_BASS_BOOST"); 797 ActiveParams.BE_OperatingMode = LVM_BE_ON; 798 } 799 if(pContext->EffectType == LVM_VIRTUALIZER) { 800 ALOGV("\tLvmEffect_enable : Enabling LVM_VIRTUALIZER"); 801 ActiveParams.VirtualizerOperatingMode = LVM_MODE_ON; 802 } 803 if(pContext->EffectType == LVM_EQUALIZER) { 804 ALOGV("\tLvmEffect_enable : Enabling LVM_EQUALIZER"); 805 ActiveParams.EQNB_OperatingMode = LVM_EQNB_ON; 806 } 807 if(pContext->EffectType == LVM_VOLUME) { 808 ALOGV("\tLvmEffect_enable : Enabling LVM_VOLUME"); 809 } 810 811 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 812 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_enable") 813 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 814 815 //ALOGV("\tLvmEffect_enable Succesfully called LVM_SetControlParameters\n"); 816 //ALOGV("\tLvmEffect_enable end"); 817 return 0; 818} 819 820//---------------------------------------------------------------------------- 821// LvmEffect_disable() 822//---------------------------------------------------------------------------- 823// Purpose: Disable the effect in the bundle 824// 825// Inputs: 826// pContext: effect engine context 827// 828// Outputs: 829// 830//---------------------------------------------------------------------------- 831 832int LvmEffect_disable(EffectContext *pContext){ 833 //ALOGV("\tLvmEffect_disable start"); 834 835 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 836 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 837 /* Get the current settings */ 838 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 839 &ActiveParams); 840 841 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_disable") 842 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 843 //ALOGV("\tLvmEffect_disable Succesfully called LVM_GetControlParameters\n"); 844 845 if(pContext->EffectType == LVM_BASS_BOOST) { 846 ALOGV("\tLvmEffect_disable : Disabling LVM_BASS_BOOST"); 847 ActiveParams.BE_OperatingMode = LVM_BE_OFF; 848 } 849 if(pContext->EffectType == LVM_VIRTUALIZER) { 850 ALOGV("\tLvmEffect_disable : Disabling LVM_VIRTUALIZER"); 851 ActiveParams.VirtualizerOperatingMode = LVM_MODE_OFF; 852 } 853 if(pContext->EffectType == LVM_EQUALIZER) { 854 ALOGV("\tLvmEffect_disable : Disabling LVM_EQUALIZER"); 855 ActiveParams.EQNB_OperatingMode = LVM_EQNB_OFF; 856 } 857 if(pContext->EffectType == LVM_VOLUME) { 858 ALOGV("\tLvmEffect_disable : Disabling LVM_VOLUME"); 859 } 860 861 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 862 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_disable") 863 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 864 865 //ALOGV("\tLvmEffect_disable Succesfully called LVM_SetControlParameters\n"); 866 //ALOGV("\tLvmEffect_disable end"); 867 return 0; 868} 869 870//---------------------------------------------------------------------------- 871// LvmEffect_free() 872//---------------------------------------------------------------------------- 873// Purpose: Free all memory associated with the Bundle. 874// 875// Inputs: 876// pContext: effect engine context 877// 878// Outputs: 879// 880//---------------------------------------------------------------------------- 881 882void LvmEffect_free(EffectContext *pContext){ 883 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 884 LVM_ControlParams_t params; /* Control Parameters */ 885 LVM_MemTab_t MemTab; 886 887 /* Free the algorithm memory */ 888 LvmStatus = LVM_GetMemoryTable(pContext->pBundledContext->hInstance, 889 &MemTab, 890 LVM_NULL); 891 892 LVM_ERROR_CHECK(LvmStatus, "LVM_GetMemoryTable", "LvmEffect_free") 893 894 for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){ 895 if (MemTab.Region[i].Size != 0){ 896 if (MemTab.Region[i].pBaseAddress != NULL){ 897 ALOGV("\tLvmEffect_free - START freeing %" PRIu32 " bytes for region %u at %p\n", 898 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 899 900 free(MemTab.Region[i].pBaseAddress); 901 902 ALOGV("\tLvmEffect_free - END freeing %" PRIu32 " bytes for region %u at %p\n", 903 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 904 }else{ 905 ALOGV("\tLVM_ERROR : LvmEffect_free - trying to free with NULL pointer %" PRIu32 906 " bytes for region %u at %p ERROR\n", 907 MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress); 908 } 909 } 910 } 911} /* end LvmEffect_free */ 912 913//---------------------------------------------------------------------------- 914// Effect_setConfig() 915//---------------------------------------------------------------------------- 916// Purpose: Set input and output audio configuration. 917// 918// Inputs: 919// pContext: effect engine context 920// pConfig: pointer to effect_config_t structure holding input and output 921// configuration parameters 922// 923// Outputs: 924// 925//---------------------------------------------------------------------------- 926 927int Effect_setConfig(EffectContext *pContext, effect_config_t *pConfig){ 928 LVM_Fs_en SampleRate; 929 //ALOGV("\tEffect_setConfig start"); 930 931 CHECK_ARG(pContext != NULL); 932 CHECK_ARG(pConfig != NULL); 933 934 CHECK_ARG(pConfig->inputCfg.samplingRate == pConfig->outputCfg.samplingRate); 935 CHECK_ARG(pConfig->inputCfg.channels == pConfig->outputCfg.channels); 936 CHECK_ARG(pConfig->inputCfg.format == pConfig->outputCfg.format); 937 CHECK_ARG(pConfig->inputCfg.channels == AUDIO_CHANNEL_OUT_STEREO); 938 CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE 939 || pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE); 940 CHECK_ARG(pConfig->inputCfg.format == AUDIO_FORMAT_PCM_16_BIT); 941 942 pContext->config = *pConfig; 943 944 switch (pConfig->inputCfg.samplingRate) { 945 case 8000: 946 SampleRate = LVM_FS_8000; 947 pContext->pBundledContext->SamplesPerSecond = 8000*2; // 2 secs Stereo 948 break; 949 case 16000: 950 SampleRate = LVM_FS_16000; 951 pContext->pBundledContext->SamplesPerSecond = 16000*2; // 2 secs Stereo 952 break; 953 case 22050: 954 SampleRate = LVM_FS_22050; 955 pContext->pBundledContext->SamplesPerSecond = 22050*2; // 2 secs Stereo 956 break; 957 case 32000: 958 SampleRate = LVM_FS_32000; 959 pContext->pBundledContext->SamplesPerSecond = 32000*2; // 2 secs Stereo 960 break; 961 case 44100: 962 SampleRate = LVM_FS_44100; 963 pContext->pBundledContext->SamplesPerSecond = 44100*2; // 2 secs Stereo 964 break; 965 case 48000: 966 SampleRate = LVM_FS_48000; 967 pContext->pBundledContext->SamplesPerSecond = 48000*2; // 2 secs Stereo 968 break; 969 default: 970 ALOGV("\tEffect_setConfig invalid sampling rate %d", pConfig->inputCfg.samplingRate); 971 return -EINVAL; 972 } 973 974 if(pContext->pBundledContext->SampleRate != SampleRate){ 975 976 LVM_ControlParams_t ActiveParams; 977 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; 978 979 ALOGV("\tEffect_setConfig change sampling rate to %d", SampleRate); 980 981 /* Get the current settings */ 982 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 983 &ActiveParams); 984 985 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "Effect_setConfig") 986 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 987 988 ActiveParams.SampleRate = SampleRate; 989 990 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 991 992 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "Effect_setConfig") 993 ALOGV("\tEffect_setConfig Succesfully called LVM_SetControlParameters\n"); 994 pContext->pBundledContext->SampleRate = SampleRate; 995 996 }else{ 997 //ALOGV("\tEffect_setConfig keep sampling rate at %d", SampleRate); 998 } 999 1000 //ALOGV("\tEffect_setConfig End...."); 1001 return 0; 1002} /* end Effect_setConfig */ 1003 1004//---------------------------------------------------------------------------- 1005// Effect_getConfig() 1006//---------------------------------------------------------------------------- 1007// Purpose: Get input and output audio configuration. 1008// 1009// Inputs: 1010// pContext: effect engine context 1011// pConfig: pointer to effect_config_t structure holding input and output 1012// configuration parameters 1013// 1014// Outputs: 1015// 1016//---------------------------------------------------------------------------- 1017 1018void Effect_getConfig(EffectContext *pContext, effect_config_t *pConfig) 1019{ 1020 *pConfig = pContext->config; 1021} /* end Effect_getConfig */ 1022 1023//---------------------------------------------------------------------------- 1024// BassGetStrength() 1025//---------------------------------------------------------------------------- 1026// Purpose: 1027// get the effect strength currently being used, what is actually returned is the strengh that was 1028// previously used in the set, this is because the app uses a strength in the range 0-1000 while 1029// the bassboost uses 1-15, so to avoid a quantisation the original set value is used. However the 1030// actual used value is checked to make sure it corresponds to the one being returned 1031// 1032// Inputs: 1033// pContext: effect engine context 1034// 1035//---------------------------------------------------------------------------- 1036 1037uint32_t BassGetStrength(EffectContext *pContext){ 1038 //ALOGV("\tBassGetStrength() (0-1000) -> %d\n", pContext->pBundledContext->BassStrengthSaved); 1039 1040 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1041 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1042 /* Get the current settings */ 1043 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1044 &ActiveParams); 1045 1046 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "BassGetStrength") 1047 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1048 1049 //ALOGV("\tBassGetStrength Succesfully returned from LVM_GetControlParameters\n"); 1050 1051 /* Check that the strength returned matches the strength that was set earlier */ 1052 if(ActiveParams.BE_EffectLevel != 1053 (LVM_INT16)((15*pContext->pBundledContext->BassStrengthSaved)/1000)){ 1054 ALOGV("\tLVM_ERROR : BassGetStrength module strength does not match savedStrength %d %d\n", 1055 ActiveParams.BE_EffectLevel, pContext->pBundledContext->BassStrengthSaved); 1056 return -EINVAL; 1057 } 1058 1059 //ALOGV("\tBassGetStrength() (0-15) -> %d\n", ActiveParams.BE_EffectLevel ); 1060 //ALOGV("\tBassGetStrength() (saved) -> %d\n", pContext->pBundledContext->BassStrengthSaved ); 1061 return pContext->pBundledContext->BassStrengthSaved; 1062} /* end BassGetStrength */ 1063 1064//---------------------------------------------------------------------------- 1065// BassSetStrength() 1066//---------------------------------------------------------------------------- 1067// Purpose: 1068// Apply the strength to the BassBosst. Must first be converted from the range 0-1000 to 1-15 1069// 1070// Inputs: 1071// pContext: effect engine context 1072// strength strength to be applied 1073// 1074//---------------------------------------------------------------------------- 1075 1076void BassSetStrength(EffectContext *pContext, uint32_t strength){ 1077 //ALOGV("\tBassSetStrength(%d)", strength); 1078 1079 pContext->pBundledContext->BassStrengthSaved = (int)strength; 1080 1081 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1082 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1083 1084 /* Get the current settings */ 1085 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1086 &ActiveParams); 1087 1088 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "BassSetStrength") 1089 //ALOGV("\tBassSetStrength Succesfully returned from LVM_GetControlParameters\n"); 1090 1091 /* Bass Enhancement parameters */ 1092 ActiveParams.BE_EffectLevel = (LVM_INT16)((15*strength)/1000); 1093 ActiveParams.BE_CentreFreq = LVM_BE_CENTRE_90Hz; 1094 1095 //ALOGV("\tBassSetStrength() (0-15) -> %d\n", ActiveParams.BE_EffectLevel ); 1096 1097 /* Activate the initial settings */ 1098 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1099 1100 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "BassSetStrength") 1101 //ALOGV("\tBassSetStrength Succesfully called LVM_SetControlParameters\n"); 1102} /* end BassSetStrength */ 1103 1104//---------------------------------------------------------------------------- 1105// VirtualizerGetStrength() 1106//---------------------------------------------------------------------------- 1107// Purpose: 1108// get the effect strength currently being used, what is actually returned is the strengh that was 1109// previously used in the set, this is because the app uses a strength in the range 0-1000 while 1110// the Virtualizer uses 1-100, so to avoid a quantisation the original set value is used.However the 1111// actual used value is checked to make sure it corresponds to the one being returned 1112// 1113// Inputs: 1114// pContext: effect engine context 1115// 1116//---------------------------------------------------------------------------- 1117 1118uint32_t VirtualizerGetStrength(EffectContext *pContext){ 1119 //ALOGV("\tVirtualizerGetStrength (0-1000) -> %d\n",pContext->pBundledContext->VirtStrengthSaved); 1120 1121 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1122 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1123 1124 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1125 1126 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VirtualizerGetStrength") 1127 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1128 1129 //ALOGV("\tVirtualizerGetStrength Succesfully returned from LVM_GetControlParameters\n"); 1130 //ALOGV("\tVirtualizerGetStrength() (0-100) -> %d\n", ActiveParams.VirtualizerReverbLevel*10); 1131 return pContext->pBundledContext->VirtStrengthSaved; 1132} /* end getStrength */ 1133 1134//---------------------------------------------------------------------------- 1135// VirtualizerSetStrength() 1136//---------------------------------------------------------------------------- 1137// Purpose: 1138// Apply the strength to the Virtualizer. Must first be converted from the range 0-1000 to 1-15 1139// 1140// Inputs: 1141// pContext: effect engine context 1142// strength strength to be applied 1143// 1144//---------------------------------------------------------------------------- 1145 1146void VirtualizerSetStrength(EffectContext *pContext, uint32_t strength){ 1147 //ALOGV("\tVirtualizerSetStrength(%d)", strength); 1148 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1149 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1150 1151 pContext->pBundledContext->VirtStrengthSaved = (int)strength; 1152 1153 /* Get the current settings */ 1154 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams); 1155 1156 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VirtualizerSetStrength") 1157 //ALOGV("\tVirtualizerSetStrength Succesfully returned from LVM_GetControlParameters\n"); 1158 1159 /* Virtualizer parameters */ 1160 ActiveParams.CS_EffectLevel = (int)((strength*32767)/1000); 1161 1162 //ALOGV("\tVirtualizerSetStrength() (0-1000) -> %d\n", strength ); 1163 //ALOGV("\tVirtualizerSetStrength() (0- 100) -> %d\n", ActiveParams.CS_EffectLevel ); 1164 1165 /* Activate the initial settings */ 1166 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1167 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VirtualizerSetStrength") 1168 //ALOGV("\tVirtualizerSetStrength Succesfully called LVM_SetControlParameters\n\n"); 1169} /* end setStrength */ 1170 1171//---------------------------------------------------------------------------- 1172// VirtualizerIsDeviceSupported() 1173//---------------------------------------------------------------------------- 1174// Purpose: 1175// Check if an audio device type is supported by this implementation 1176// 1177// Inputs: 1178// deviceType the type of device that affects the processing (e.g. for binaural vs transaural) 1179// Output: 1180// -EINVAL if the configuration is not supported or it is unknown 1181// 0 if the configuration is supported 1182//---------------------------------------------------------------------------- 1183int VirtualizerIsDeviceSupported(audio_devices_t deviceType) { 1184 switch (deviceType) { 1185 case AUDIO_DEVICE_OUT_WIRED_HEADSET: 1186 case AUDIO_DEVICE_OUT_WIRED_HEADPHONE: 1187 case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES: 1188 return 0; 1189 default : 1190 return -EINVAL; 1191 } 1192} 1193 1194//---------------------------------------------------------------------------- 1195// VirtualizerIsConfigurationSupported() 1196//---------------------------------------------------------------------------- 1197// Purpose: 1198// Check if a channel mask + audio device type is supported by this implementation 1199// 1200// Inputs: 1201// channelMask the channel mask of the input to virtualize 1202// deviceType the type of device that affects the processing (e.g. for binaural vs transaural) 1203// Output: 1204// -EINVAL if the configuration is not supported or it is unknown 1205// 0 if the configuration is supported 1206//---------------------------------------------------------------------------- 1207int VirtualizerIsConfigurationSupported(audio_channel_mask_t channelMask, 1208 audio_devices_t deviceType) { 1209 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask); 1210 if ((channelCount == 0) || (channelCount > 2)) { 1211 return -EINVAL; 1212 } 1213 1214 return VirtualizerIsDeviceSupported(deviceType); 1215} 1216 1217//---------------------------------------------------------------------------- 1218// VirtualizerForceVirtualizationMode() 1219//---------------------------------------------------------------------------- 1220// Purpose: 1221// Force the virtualization mode to that of the given audio device 1222// 1223// Inputs: 1224// pContext effect engine context 1225// forcedDevice the type of device whose virtualization mode we'll always use 1226// Output: 1227// -EINVAL if the device is not supported or is unknown 1228// 0 if the device is supported and the virtualization mode forced 1229// 1230//---------------------------------------------------------------------------- 1231int VirtualizerForceVirtualizationMode(EffectContext *pContext, audio_devices_t forcedDevice) { 1232 ALOGV("VirtualizerForceVirtualizationMode: forcedDev=0x%x enabled=%d tmpDisabled=%d", 1233 forcedDevice, pContext->pBundledContext->bVirtualizerEnabled, 1234 pContext->pBundledContext->bVirtualizerTempDisabled); 1235 int status = 0; 1236 bool useVirtualizer = false; 1237 1238 if (VirtualizerIsDeviceSupported(forcedDevice) != 0) { 1239 if (forcedDevice != AUDIO_DEVICE_NONE) { 1240 //forced device is not supported, make it behave as a reset of forced mode 1241 forcedDevice = AUDIO_DEVICE_NONE; 1242 // but return an error 1243 status = -EINVAL; 1244 } 1245 } 1246 1247 if (forcedDevice == AUDIO_DEVICE_NONE) { 1248 // disabling forced virtualization mode: 1249 // verify whether the virtualization should be enabled or disabled 1250 if (VirtualizerIsDeviceSupported(pContext->pBundledContext->nOutputDevice) == 0) { 1251 useVirtualizer = (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE); 1252 } 1253 pContext->pBundledContext->nVirtualizerForcedDevice = AUDIO_DEVICE_NONE; 1254 } else { 1255 // forcing virtualization mode: here we already know the device is supported 1256 pContext->pBundledContext->nVirtualizerForcedDevice = AUDIO_DEVICE_OUT_WIRED_HEADPHONE; 1257 // only enable for a supported mode, when the effect is enabled 1258 useVirtualizer = (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE); 1259 } 1260 1261 if (useVirtualizer) { 1262 if (pContext->pBundledContext->bVirtualizerTempDisabled == LVM_TRUE) { 1263 ALOGV("\tVirtualizerForceVirtualizationMode re-enable LVM_VIRTUALIZER"); 1264 android::LvmEffect_enable(pContext); 1265 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_FALSE; 1266 } else { 1267 ALOGV("\tVirtualizerForceVirtualizationMode leaving LVM_VIRTUALIZER enabled"); 1268 } 1269 } else { 1270 if (pContext->pBundledContext->bVirtualizerTempDisabled == LVM_FALSE) { 1271 ALOGV("\tVirtualizerForceVirtualizationMode disable LVM_VIRTUALIZER"); 1272 android::LvmEffect_disable(pContext); 1273 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_TRUE; 1274 } else { 1275 ALOGV("\tVirtualizerForceVirtualizationMode leaving LVM_VIRTUALIZER disabled"); 1276 } 1277 } 1278 1279 ALOGV("\tafter VirtualizerForceVirtualizationMode: enabled=%d tmpDisabled=%d", 1280 pContext->pBundledContext->bVirtualizerEnabled, 1281 pContext->pBundledContext->bVirtualizerTempDisabled); 1282 1283 return status; 1284} 1285//---------------------------------------------------------------------------- 1286// VirtualizerGetSpeakerAngles() 1287//---------------------------------------------------------------------------- 1288// Purpose: 1289// Get the virtual speaker angles for a channel mask + audio device type 1290// configuration which is guaranteed to be supported by this implementation 1291// 1292// Inputs: 1293// channelMask: the channel mask of the input to virtualize 1294// deviceType the type of device that affects the processing (e.g. for binaural vs transaural) 1295// Input/Output: 1296// pSpeakerAngles the array of integer where each speaker angle is written as a triplet in the 1297// following format: 1298// int32_t a bit mask with a single value selected for each speaker, following 1299// the convention of the audio_channel_mask_t type 1300// int32_t a value in degrees expressing the speaker azimuth, where 0 is in front 1301// of the user, 180 behind, -90 to the left, 90 to the right of the user 1302// int32_t a value in degrees expressing the speaker elevation, where 0 is the 1303// horizontal plane, +90 is directly above the user, -90 below 1304// 1305//---------------------------------------------------------------------------- 1306void VirtualizerGetSpeakerAngles(audio_channel_mask_t channelMask __unused, 1307 audio_devices_t deviceType __unused, int32_t *pSpeakerAngles) { 1308 // the channel count is guaranteed to be 1 or 2 1309 // the device is guaranteed to be of type headphone 1310 // this virtualizer is always 2in with speakers at -90 and 90deg of azimuth, 0deg of elevation 1311 *pSpeakerAngles++ = (int32_t) AUDIO_CHANNEL_OUT_FRONT_LEFT; 1312 *pSpeakerAngles++ = -90; // azimuth 1313 *pSpeakerAngles++ = 0; // elevation 1314 *pSpeakerAngles++ = (int32_t) AUDIO_CHANNEL_OUT_FRONT_RIGHT; 1315 *pSpeakerAngles++ = 90; // azimuth 1316 *pSpeakerAngles = 0; // elevation 1317} 1318 1319//---------------------------------------------------------------------------- 1320// VirtualizerGetVirtualizationMode() 1321//---------------------------------------------------------------------------- 1322// Purpose: 1323// Retrieve the current device whose processing mode is used by this effect 1324// 1325// Output: 1326// AUDIO_DEVICE_NONE if the effect is not virtualizing 1327// or the device type if the effect is virtualizing 1328//---------------------------------------------------------------------------- 1329audio_devices_t VirtualizerGetVirtualizationMode(EffectContext *pContext) { 1330 audio_devices_t virtDevice = AUDIO_DEVICE_NONE; 1331 if ((pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) 1332 && (pContext->pBundledContext->bVirtualizerTempDisabled == LVM_FALSE)) { 1333 if (pContext->pBundledContext->nVirtualizerForcedDevice != AUDIO_DEVICE_NONE) { 1334 // virtualization mode is forced, return that device 1335 virtDevice = pContext->pBundledContext->nVirtualizerForcedDevice; 1336 } else { 1337 // no forced mode, return the current device 1338 virtDevice = pContext->pBundledContext->nOutputDevice; 1339 } 1340 } 1341 ALOGV("VirtualizerGetVirtualizationMode() returning 0x%x", virtDevice); 1342 return virtDevice; 1343} 1344 1345//---------------------------------------------------------------------------- 1346// EqualizerLimitBandLevels() 1347//---------------------------------------------------------------------------- 1348// Purpose: limit all EQ band gains to a value less than 0 dB while 1349// preserving the relative band levels. 1350// 1351// Inputs: 1352// pContext: effect engine context 1353// 1354// Outputs: 1355// 1356//---------------------------------------------------------------------------- 1357void EqualizerLimitBandLevels(EffectContext *pContext) { 1358 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1359 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1360 1361 /* Get the current settings */ 1362 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1363 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "EqualizerLimitBandLevels") 1364 //ALOGV("\tEqualizerLimitBandLevels Succesfully returned from LVM_GetControlParameters\n"); 1365 //ALOGV("\tEqualizerLimitBandLevels just Got -> %d\n", 1366 // ActiveParams.pEQNB_BandDefinition[band].Gain); 1367 1368 // Apply a volume correction to avoid clipping in the EQ based on 2 factors: 1369 // - the maximum EQ band gain: the volume correction is such that the total of volume + max 1370 // band gain is <= 0 dB 1371 // - the average gain in all bands weighted by their proximity to max gain band. 1372 int maxGain = 0; 1373 int avgGain = 0; 1374 int avgCount = 0; 1375 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 1376 if (pContext->pBundledContext->bandGaindB[i] >= maxGain) { 1377 int tmpMaxGain = pContext->pBundledContext->bandGaindB[i]; 1378 int tmpAvgGain = 0; 1379 int tmpAvgCount = 0; 1380 for (int j = 0; j < FIVEBAND_NUMBANDS; j++) { 1381 int gain = pContext->pBundledContext->bandGaindB[j]; 1382 // skip current band and gains < 0 dB 1383 if (j == i || gain < 0) 1384 continue; 1385 // no need to continue if one band not processed yet has a higher gain than current 1386 // max 1387 if (gain > tmpMaxGain) { 1388 // force skipping "if (tmpAvgGain >= avgGain)" below as tmpAvgGain is not 1389 // meaningful in this case 1390 tmpAvgGain = -1; 1391 break; 1392 } 1393 1394 int weight = 1; 1395 if (j < (i + 2) && j > (i - 2)) 1396 weight = 4; 1397 tmpAvgGain += weight * gain; 1398 tmpAvgCount += weight; 1399 } 1400 if (tmpAvgGain >= avgGain) { 1401 maxGain = tmpMaxGain; 1402 avgGain = tmpAvgGain; 1403 avgCount = tmpAvgCount; 1404 } 1405 } 1406 ActiveParams.pEQNB_BandDefinition[i].Frequency = EQNB_5BandPresetsFrequencies[i]; 1407 ActiveParams.pEQNB_BandDefinition[i].QFactor = EQNB_5BandPresetsQFactors[i]; 1408 ActiveParams.pEQNB_BandDefinition[i].Gain = pContext->pBundledContext->bandGaindB[i]; 1409 } 1410 1411 int gainCorrection = 0; 1412 if (maxGain + pContext->pBundledContext->volume > 0) { 1413 gainCorrection = maxGain + pContext->pBundledContext->volume; 1414 } 1415 if (avgCount) { 1416 gainCorrection += avgGain/avgCount; 1417 } 1418 1419 ALOGV("EqualizerLimitBandLevels() gainCorrection %d maxGain %d avgGain %d avgCount %d", 1420 gainCorrection, maxGain, avgGain, avgCount); 1421 1422 ActiveParams.VC_EffectLevel = pContext->pBundledContext->volume - gainCorrection; 1423 if (ActiveParams.VC_EffectLevel < -96) { 1424 ActiveParams.VC_EffectLevel = -96; 1425 } 1426 1427 /* Activate the initial settings */ 1428 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1429 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "EqualizerLimitBandLevels") 1430 //ALOGV("\tEqualizerLimitBandLevels just Set -> %d\n", 1431 // ActiveParams.pEQNB_BandDefinition[band].Gain); 1432 1433 //ALOGV("\tEqualizerLimitBandLevels just set (-96dB -> 0dB) -> %d\n",ActiveParams.VC_EffectLevel ); 1434 if(pContext->pBundledContext->firstVolume == LVM_TRUE){ 1435 LvmStatus = LVM_SetVolumeNoSmoothing(pContext->pBundledContext->hInstance, &ActiveParams); 1436 LVM_ERROR_CHECK(LvmStatus, "LVM_SetVolumeNoSmoothing", "LvmBundle_process") 1437 ALOGV("\tLVM_VOLUME: Disabling Smoothing for first volume change to remove spikes/clicks"); 1438 pContext->pBundledContext->firstVolume = LVM_FALSE; 1439 } 1440} 1441 1442 1443//---------------------------------------------------------------------------- 1444// EqualizerGetBandLevel() 1445//---------------------------------------------------------------------------- 1446// Purpose: Retrieve the gain currently being used for the band passed in 1447// 1448// Inputs: 1449// band: band number 1450// pContext: effect engine context 1451// 1452// Outputs: 1453// 1454//---------------------------------------------------------------------------- 1455int32_t EqualizerGetBandLevel(EffectContext *pContext, int32_t band){ 1456 //ALOGV("\tEqualizerGetBandLevel -> %d\n", pContext->pBundledContext->bandGaindB[band] ); 1457 return pContext->pBundledContext->bandGaindB[band] * 100; 1458} 1459 1460//---------------------------------------------------------------------------- 1461// EqualizerSetBandLevel() 1462//---------------------------------------------------------------------------- 1463// Purpose: 1464// Sets gain value for the given band. 1465// 1466// Inputs: 1467// band: band number 1468// Gain: Gain to be applied in millibels 1469// pContext: effect engine context 1470// 1471// Outputs: 1472// 1473//--------------------------------------------------------------------------- 1474void EqualizerSetBandLevel(EffectContext *pContext, int band, short Gain){ 1475 int gainRounded; 1476 if(Gain > 0){ 1477 gainRounded = (int)((Gain+50)/100); 1478 }else{ 1479 gainRounded = (int)((Gain-50)/100); 1480 } 1481 //ALOGV("\tEqualizerSetBandLevel(%d)->(%d)", Gain, gainRounded); 1482 pContext->pBundledContext->bandGaindB[band] = gainRounded; 1483 pContext->pBundledContext->CurPreset = PRESET_CUSTOM; 1484 1485 EqualizerLimitBandLevels(pContext); 1486} 1487 1488//---------------------------------------------------------------------------- 1489// EqualizerGetCentreFrequency() 1490//---------------------------------------------------------------------------- 1491// Purpose: Retrieve the frequency being used for the band passed in 1492// 1493// Inputs: 1494// band: band number 1495// pContext: effect engine context 1496// 1497// Outputs: 1498// 1499//---------------------------------------------------------------------------- 1500int32_t EqualizerGetCentreFrequency(EffectContext *pContext, int32_t band){ 1501 int32_t Frequency =0; 1502 1503 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1504 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1505 LVM_EQNB_BandDef_t *BandDef; 1506 /* Get the current settings */ 1507 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, 1508 &ActiveParams); 1509 1510 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "EqualizerGetCentreFrequency") 1511 1512 BandDef = ActiveParams.pEQNB_BandDefinition; 1513 Frequency = (int32_t)BandDef[band].Frequency*1000; // Convert to millibels 1514 1515 //ALOGV("\tEqualizerGetCentreFrequency -> %d\n", Frequency ); 1516 //ALOGV("\tEqualizerGetCentreFrequency Succesfully returned from LVM_GetControlParameters\n"); 1517 return Frequency; 1518} 1519 1520//---------------------------------------------------------------------------- 1521// EqualizerGetBandFreqRange( 1522//---------------------------------------------------------------------------- 1523// Purpose: 1524// 1525// Gets lower and upper boundaries of a band. 1526// For the high shelf, the low bound is the band frequency and the high 1527// bound is Nyquist. 1528// For the peaking filters, they are the gain[dB]/2 points. 1529// 1530// Inputs: 1531// band: band number 1532// pContext: effect engine context 1533// 1534// Outputs: 1535// pLow: lower band range 1536// pLow: upper band range 1537//---------------------------------------------------------------------------- 1538int32_t EqualizerGetBandFreqRange(EffectContext *pContext __unused, int32_t band, uint32_t *pLow, 1539 uint32_t *pHi){ 1540 *pLow = bandFreqRange[band][0]; 1541 *pHi = bandFreqRange[band][1]; 1542 return 0; 1543} 1544 1545//---------------------------------------------------------------------------- 1546// EqualizerGetBand( 1547//---------------------------------------------------------------------------- 1548// Purpose: 1549// 1550// Returns the band with the maximum influence on a given frequency. 1551// Result is unaffected by whether EQ is enabled or not, or by whether 1552// changes have been committed or not. 1553// 1554// Inputs: 1555// targetFreq The target frequency, in millihertz. 1556// pContext: effect engine context 1557// 1558// Outputs: 1559// pLow: lower band range 1560// pLow: upper band range 1561//---------------------------------------------------------------------------- 1562int32_t EqualizerGetBand(EffectContext *pContext __unused, uint32_t targetFreq){ 1563 int band = 0; 1564 1565 if(targetFreq < bandFreqRange[0][0]){ 1566 return -EINVAL; 1567 }else if(targetFreq == bandFreqRange[0][0]){ 1568 return 0; 1569 } 1570 for(int i=0; i<FIVEBAND_NUMBANDS;i++){ 1571 if((targetFreq > bandFreqRange[i][0])&&(targetFreq <= bandFreqRange[i][1])){ 1572 band = i; 1573 } 1574 } 1575 return band; 1576} 1577 1578//---------------------------------------------------------------------------- 1579// EqualizerGetPreset( 1580//---------------------------------------------------------------------------- 1581// Purpose: 1582// 1583// Gets the currently set preset ID. 1584// Will return PRESET_CUSTOM in case the EQ parameters have been modified 1585// manually since a preset was set. 1586// 1587// Inputs: 1588// pContext: effect engine context 1589// 1590//---------------------------------------------------------------------------- 1591int32_t EqualizerGetPreset(EffectContext *pContext){ 1592 return pContext->pBundledContext->CurPreset; 1593} 1594 1595//---------------------------------------------------------------------------- 1596// EqualizerSetPreset( 1597//---------------------------------------------------------------------------- 1598// Purpose: 1599// 1600// Sets the current preset by ID. 1601// All the band parameters will be overridden. 1602// 1603// Inputs: 1604// pContext: effect engine context 1605// preset The preset ID. 1606// 1607//---------------------------------------------------------------------------- 1608void EqualizerSetPreset(EffectContext *pContext, int preset){ 1609 1610 //ALOGV("\tEqualizerSetPreset(%d)", preset); 1611 pContext->pBundledContext->CurPreset = preset; 1612 1613 //ActiveParams.pEQNB_BandDefinition = &BandDefs[0]; 1614 for (int i=0; i<FIVEBAND_NUMBANDS; i++) 1615 { 1616 pContext->pBundledContext->bandGaindB[i] = 1617 EQNB_5BandSoftPresets[i + preset * FIVEBAND_NUMBANDS]; 1618 } 1619 1620 EqualizerLimitBandLevels(pContext); 1621 1622 //ALOGV("\tEqualizerSetPreset Succesfully called LVM_SetControlParameters\n"); 1623 return; 1624} 1625 1626int32_t EqualizerGetNumPresets(){ 1627 return sizeof(gEqualizerPresets) / sizeof(PresetConfig); 1628} 1629 1630//---------------------------------------------------------------------------- 1631// EqualizerGetPresetName( 1632//---------------------------------------------------------------------------- 1633// Purpose: 1634// Gets a human-readable name for a preset ID. Will return "Custom" if 1635// PRESET_CUSTOM is passed. 1636// 1637// Inputs: 1638// preset The preset ID. Must be less than number of presets. 1639// 1640//------------------------------------------------------------------------- 1641const char * EqualizerGetPresetName(int32_t preset){ 1642 //ALOGV("\tEqualizerGetPresetName start(%d)", preset); 1643 if (preset == PRESET_CUSTOM) { 1644 return "Custom"; 1645 } else { 1646 return gEqualizerPresets[preset].name; 1647 } 1648 //ALOGV("\tEqualizerGetPresetName end(%d)", preset); 1649 return 0; 1650} 1651 1652//---------------------------------------------------------------------------- 1653// VolumeSetVolumeLevel() 1654//---------------------------------------------------------------------------- 1655// Purpose: 1656// 1657// Inputs: 1658// pContext: effect engine context 1659// level level to be applied 1660// 1661//---------------------------------------------------------------------------- 1662 1663int VolumeSetVolumeLevel(EffectContext *pContext, int16_t level){ 1664 1665 if (level > 0 || level < -9600) { 1666 return -EINVAL; 1667 } 1668 1669 if (pContext->pBundledContext->bMuteEnabled == LVM_TRUE) { 1670 pContext->pBundledContext->levelSaved = level / 100; 1671 } else { 1672 pContext->pBundledContext->volume = level / 100; 1673 } 1674 1675 EqualizerLimitBandLevels(pContext); 1676 1677 return 0; 1678} /* end VolumeSetVolumeLevel */ 1679 1680//---------------------------------------------------------------------------- 1681// VolumeGetVolumeLevel() 1682//---------------------------------------------------------------------------- 1683// Purpose: 1684// 1685// Inputs: 1686// pContext: effect engine context 1687// 1688//---------------------------------------------------------------------------- 1689 1690int VolumeGetVolumeLevel(EffectContext *pContext, int16_t *level){ 1691 1692 if (pContext->pBundledContext->bMuteEnabled == LVM_TRUE) { 1693 *level = pContext->pBundledContext->levelSaved * 100; 1694 } else { 1695 *level = pContext->pBundledContext->volume * 100; 1696 } 1697 return 0; 1698} /* end VolumeGetVolumeLevel */ 1699 1700//---------------------------------------------------------------------------- 1701// VolumeSetMute() 1702//---------------------------------------------------------------------------- 1703// Purpose: 1704// 1705// Inputs: 1706// pContext: effect engine context 1707// mute: enable/disable flag 1708// 1709//---------------------------------------------------------------------------- 1710 1711int32_t VolumeSetMute(EffectContext *pContext, uint32_t mute){ 1712 //ALOGV("\tVolumeSetMute start(%d)", mute); 1713 1714 pContext->pBundledContext->bMuteEnabled = mute; 1715 1716 /* Set appropriate volume level */ 1717 if(pContext->pBundledContext->bMuteEnabled == LVM_TRUE){ 1718 pContext->pBundledContext->levelSaved = pContext->pBundledContext->volume; 1719 pContext->pBundledContext->volume = -96; 1720 }else{ 1721 pContext->pBundledContext->volume = pContext->pBundledContext->levelSaved; 1722 } 1723 1724 EqualizerLimitBandLevels(pContext); 1725 1726 return 0; 1727} /* end setMute */ 1728 1729//---------------------------------------------------------------------------- 1730// VolumeGetMute() 1731//---------------------------------------------------------------------------- 1732// Purpose: 1733// 1734// Inputs: 1735// pContext: effect engine context 1736// 1737// Ourputs: 1738// mute: enable/disable flag 1739//---------------------------------------------------------------------------- 1740 1741int32_t VolumeGetMute(EffectContext *pContext, uint32_t *mute){ 1742 //ALOGV("\tVolumeGetMute start"); 1743 if((pContext->pBundledContext->bMuteEnabled == LVM_FALSE)|| 1744 (pContext->pBundledContext->bMuteEnabled == LVM_TRUE)){ 1745 *mute = pContext->pBundledContext->bMuteEnabled; 1746 return 0; 1747 }else{ 1748 ALOGV("\tLVM_ERROR : VolumeGetMute read an invalid value from context %d", 1749 pContext->pBundledContext->bMuteEnabled); 1750 return -EINVAL; 1751 } 1752 //ALOGV("\tVolumeGetMute end"); 1753} /* end getMute */ 1754 1755int16_t VolumeConvertStereoPosition(int16_t position){ 1756 int16_t convertedPosition = 0; 1757 1758 convertedPosition = (int16_t)(((float)position/1000)*96); 1759 return convertedPosition; 1760 1761} 1762 1763//---------------------------------------------------------------------------- 1764// VolumeSetStereoPosition() 1765//---------------------------------------------------------------------------- 1766// Purpose: 1767// 1768// Inputs: 1769// pContext: effect engine context 1770// position: stereo position 1771// 1772// Outputs: 1773//---------------------------------------------------------------------------- 1774 1775int VolumeSetStereoPosition(EffectContext *pContext, int16_t position){ 1776 1777 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1778 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1779 LVM_INT16 Balance = 0; 1780 1781 1782 1783 pContext->pBundledContext->positionSaved = position; 1784 Balance = VolumeConvertStereoPosition(pContext->pBundledContext->positionSaved); 1785 1786 //ALOGV("\tVolumeSetStereoPosition start pContext->pBundledContext->positionSaved = %d", 1787 //pContext->pBundledContext->positionSaved); 1788 1789 if(pContext->pBundledContext->bStereoPositionEnabled == LVM_TRUE){ 1790 1791 //ALOGV("\tVolumeSetStereoPosition Position to be set is %d %d\n", position, Balance); 1792 pContext->pBundledContext->positionSaved = position; 1793 /* Get the current settings */ 1794 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1795 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetStereoPosition") 1796 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1797 //ALOGV("\tVolumeSetStereoPosition Succesfully returned from LVM_GetControlParameters got:" 1798 // " %d\n", ActiveParams.VC_Balance); 1799 1800 /* Volume parameters */ 1801 ActiveParams.VC_Balance = Balance; 1802 //ALOGV("\tVolumeSetStereoPosition() (-96dB -> +96dB) -> %d\n", ActiveParams.VC_Balance ); 1803 1804 /* Activate the initial settings */ 1805 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1806 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeSetStereoPosition") 1807 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1808 1809 //ALOGV("\tVolumeSetStereoPosition Succesfully called LVM_SetControlParameters\n"); 1810 1811 /* Get the current settings */ 1812 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1813 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetStereoPosition") 1814 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1815 //ALOGV("\tVolumeSetStereoPosition Succesfully returned from LVM_GetControlParameters got: " 1816 // "%d\n", ActiveParams.VC_Balance); 1817 } 1818 else{ 1819 //ALOGV("\tVolumeSetStereoPosition Position attempting to set, but not enabled %d %d\n", 1820 //position, Balance); 1821 } 1822 //ALOGV("\tVolumeSetStereoPosition end pContext->pBundledContext->positionSaved = %d\n", 1823 //pContext->pBundledContext->positionSaved); 1824 return 0; 1825} /* end VolumeSetStereoPosition */ 1826 1827 1828//---------------------------------------------------------------------------- 1829// VolumeGetStereoPosition() 1830//---------------------------------------------------------------------------- 1831// Purpose: 1832// 1833// Inputs: 1834// pContext: effect engine context 1835// 1836// Outputs: 1837// position: stereo position 1838//---------------------------------------------------------------------------- 1839 1840int32_t VolumeGetStereoPosition(EffectContext *pContext, int16_t *position){ 1841 //ALOGV("\tVolumeGetStereoPosition start"); 1842 1843 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1844 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 1845 LVM_INT16 balance; 1846 1847 //ALOGV("\tVolumeGetStereoPosition start pContext->pBundledContext->positionSaved = %d", 1848 //pContext->pBundledContext->positionSaved); 1849 1850 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1851 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeGetStereoPosition") 1852 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1853 1854 //ALOGV("\tVolumeGetStereoPosition -> %d\n", ActiveParams.VC_Balance); 1855 //ALOGV("\tVolumeGetStereoPosition Succesfully returned from LVM_GetControlParameters\n"); 1856 1857 balance = VolumeConvertStereoPosition(pContext->pBundledContext->positionSaved); 1858 1859 if(pContext->pBundledContext->bStereoPositionEnabled == LVM_TRUE){ 1860 if(balance != ActiveParams.VC_Balance){ 1861 return -EINVAL; 1862 } 1863 } 1864 *position = (LVM_INT16)pContext->pBundledContext->positionSaved; // Convert dB to millibels 1865 //ALOGV("\tVolumeGetStereoPosition end returning pContext->pBundledContext->positionSaved =%d\n", 1866 //pContext->pBundledContext->positionSaved); 1867 return 0; 1868} /* end VolumeGetStereoPosition */ 1869 1870//---------------------------------------------------------------------------- 1871// VolumeEnableStereoPosition() 1872//---------------------------------------------------------------------------- 1873// Purpose: 1874// 1875// Inputs: 1876// pContext: effect engine context 1877// mute: enable/disable flag 1878// 1879//---------------------------------------------------------------------------- 1880 1881int32_t VolumeEnableStereoPosition(EffectContext *pContext, uint32_t enabled){ 1882 //ALOGV("\tVolumeEnableStereoPosition start()"); 1883 1884 pContext->pBundledContext->bStereoPositionEnabled = enabled; 1885 1886 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 1887 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 1888 1889 /* Get the current settings */ 1890 LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1891 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeEnableStereoPosition") 1892 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1893 1894 //ALOGV("\tVolumeEnableStereoPosition Succesfully returned from LVM_GetControlParameters\n"); 1895 //ALOGV("\tVolumeEnableStereoPosition to %d, position was %d\n", 1896 // enabled, ActiveParams.VC_Balance ); 1897 1898 /* Set appropriate stereo position */ 1899 if(pContext->pBundledContext->bStereoPositionEnabled == LVM_FALSE){ 1900 ActiveParams.VC_Balance = 0; 1901 }else{ 1902 ActiveParams.VC_Balance = 1903 VolumeConvertStereoPosition(pContext->pBundledContext->positionSaved); 1904 } 1905 1906 /* Activate the initial settings */ 1907 LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams); 1908 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeEnableStereoPosition") 1909 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 1910 1911 //ALOGV("\tVolumeEnableStereoPosition Succesfully called LVM_SetControlParameters\n"); 1912 //ALOGV("\tVolumeEnableStereoPosition end()\n"); 1913 return 0; 1914} /* end VolumeEnableStereoPosition */ 1915 1916//---------------------------------------------------------------------------- 1917// BassBoost_getParameter() 1918//---------------------------------------------------------------------------- 1919// Purpose: 1920// Get a BassBoost parameter 1921// 1922// Inputs: 1923// pBassBoost - handle to instance data 1924// pParam - pointer to parameter 1925// pValue - pointer to variable to hold retrieved value 1926// pValueSize - pointer to value size: maximum size as input 1927// 1928// Outputs: 1929// *pValue updated with parameter value 1930// *pValueSize updated with actual value size 1931// 1932// 1933// Side Effects: 1934// 1935//---------------------------------------------------------------------------- 1936 1937int BassBoost_getParameter(EffectContext *pContext, 1938 void *pParam, 1939 uint32_t *pValueSize, 1940 void *pValue){ 1941 int status = 0; 1942 int32_t *pParamTemp = (int32_t *)pParam; 1943 int32_t param = *pParamTemp++; 1944 int32_t param2; 1945 char *name; 1946 1947 //ALOGV("\tBassBoost_getParameter start"); 1948 1949 switch (param){ 1950 case BASSBOOST_PARAM_STRENGTH_SUPPORTED: 1951 if (*pValueSize != sizeof(uint32_t)){ 1952 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid pValueSize1 %d", *pValueSize); 1953 return -EINVAL; 1954 } 1955 *pValueSize = sizeof(uint32_t); 1956 break; 1957 case BASSBOOST_PARAM_STRENGTH: 1958 if (*pValueSize != sizeof(int16_t)){ 1959 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid pValueSize2 %d", *pValueSize); 1960 return -EINVAL; 1961 } 1962 *pValueSize = sizeof(int16_t); 1963 break; 1964 1965 default: 1966 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid param %d", param); 1967 return -EINVAL; 1968 } 1969 1970 switch (param){ 1971 case BASSBOOST_PARAM_STRENGTH_SUPPORTED: 1972 *(uint32_t *)pValue = 1; 1973 1974 //ALOGV("\tBassBoost_getParameter() BASSBOOST_PARAM_STRENGTH_SUPPORTED Value is %d", 1975 // *(uint32_t *)pValue); 1976 break; 1977 1978 case BASSBOOST_PARAM_STRENGTH: 1979 *(int16_t *)pValue = BassGetStrength(pContext); 1980 1981 //ALOGV("\tBassBoost_getParameter() BASSBOOST_PARAM_STRENGTH Value is %d", 1982 // *(int16_t *)pValue); 1983 break; 1984 1985 default: 1986 ALOGV("\tLVM_ERROR : BassBoost_getParameter() invalid param %d", param); 1987 status = -EINVAL; 1988 break; 1989 } 1990 1991 //ALOGV("\tBassBoost_getParameter end"); 1992 return status; 1993} /* end BassBoost_getParameter */ 1994 1995//---------------------------------------------------------------------------- 1996// BassBoost_setParameter() 1997//---------------------------------------------------------------------------- 1998// Purpose: 1999// Set a BassBoost parameter 2000// 2001// Inputs: 2002// pBassBoost - handle to instance data 2003// pParam - pointer to parameter 2004// pValue - pointer to value 2005// 2006// Outputs: 2007// 2008//---------------------------------------------------------------------------- 2009 2010int BassBoost_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2011 int status = 0; 2012 int16_t strength; 2013 int32_t *pParamTemp = (int32_t *)pParam; 2014 2015 //ALOGV("\tBassBoost_setParameter start"); 2016 2017 switch (*pParamTemp){ 2018 case BASSBOOST_PARAM_STRENGTH: 2019 strength = *(int16_t *)pValue; 2020 //ALOGV("\tBassBoost_setParameter() BASSBOOST_PARAM_STRENGTH value is %d", strength); 2021 //ALOGV("\tBassBoost_setParameter() Calling pBassBoost->BassSetStrength"); 2022 BassSetStrength(pContext, (int32_t)strength); 2023 //ALOGV("\tBassBoost_setParameter() Called pBassBoost->BassSetStrength"); 2024 break; 2025 default: 2026 ALOGV("\tLVM_ERROR : BassBoost_setParameter() invalid param %d", *pParamTemp); 2027 break; 2028 } 2029 2030 //ALOGV("\tBassBoost_setParameter end"); 2031 return status; 2032} /* end BassBoost_setParameter */ 2033 2034//---------------------------------------------------------------------------- 2035// Virtualizer_getParameter() 2036//---------------------------------------------------------------------------- 2037// Purpose: 2038// Get a Virtualizer parameter 2039// 2040// Inputs: 2041// pVirtualizer - handle to instance data 2042// pParam - pointer to parameter 2043// pValue - pointer to variable to hold retrieved value 2044// pValueSize - pointer to value size: maximum size as input 2045// 2046// Outputs: 2047// *pValue updated with parameter value 2048// *pValueSize updated with actual value size 2049// 2050// 2051// Side Effects: 2052// 2053//---------------------------------------------------------------------------- 2054 2055int Virtualizer_getParameter(EffectContext *pContext, 2056 void *pParam, 2057 uint32_t *pValueSize, 2058 void *pValue){ 2059 int status = 0; 2060 int32_t *pParamTemp = (int32_t *)pParam; 2061 int32_t param = *pParamTemp++; 2062 char *name; 2063 2064 //ALOGV("\tVirtualizer_getParameter start"); 2065 2066 switch (param){ 2067 case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: 2068 if (*pValueSize != sizeof(uint32_t)){ 2069 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize %d",*pValueSize); 2070 return -EINVAL; 2071 } 2072 *pValueSize = sizeof(uint32_t); 2073 break; 2074 case VIRTUALIZER_PARAM_STRENGTH: 2075 if (*pValueSize != sizeof(int16_t)){ 2076 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize2 %d",*pValueSize); 2077 return -EINVAL; 2078 } 2079 *pValueSize = sizeof(int16_t); 2080 break; 2081 case VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES: 2082 // return value size can only be interpreted as relative to input value, 2083 // deferring validity check to below 2084 break; 2085 case VIRTUALIZER_PARAM_VIRTUALIZATION_MODE: 2086 if (*pValueSize != sizeof(uint32_t)){ 2087 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize %d",*pValueSize); 2088 return -EINVAL; 2089 } 2090 *pValueSize = sizeof(uint32_t); 2091 break; 2092 default: 2093 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid param %d", param); 2094 return -EINVAL; 2095 } 2096 2097 switch (param){ 2098 case VIRTUALIZER_PARAM_STRENGTH_SUPPORTED: 2099 *(uint32_t *)pValue = 1; 2100 2101 //ALOGV("\tVirtualizer_getParameter() VIRTUALIZER_PARAM_STRENGTH_SUPPORTED Value is %d", 2102 // *(uint32_t *)pValue); 2103 break; 2104 2105 case VIRTUALIZER_PARAM_STRENGTH: 2106 *(int16_t *)pValue = VirtualizerGetStrength(pContext); 2107 2108 //ALOGV("\tVirtualizer_getParameter() VIRTUALIZER_PARAM_STRENGTH Value is %d", 2109 // *(int16_t *)pValue); 2110 break; 2111 2112 case VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES: { 2113 const audio_channel_mask_t channelMask = (audio_channel_mask_t) *pParamTemp++; 2114 const audio_devices_t deviceType = (audio_devices_t) *pParamTemp; 2115 uint32_t nbChannels = audio_channel_count_from_out_mask(channelMask); 2116 if (*pValueSize < 3 * nbChannels * sizeof(int32_t)){ 2117 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize %d",*pValueSize); 2118 return -EINVAL; 2119 } 2120 // verify the configuration is supported 2121 status = VirtualizerIsConfigurationSupported(channelMask, deviceType); 2122 if (status == 0) { 2123 ALOGV("VIRTUALIZER_PARAM_VIRTUAL_SPEAKER_ANGLES supports mask=0x%x device=0x%x", 2124 channelMask, deviceType); 2125 // configuration is supported, get the angles 2126 VirtualizerGetSpeakerAngles(channelMask, deviceType, (int32_t *)pValue); 2127 } 2128 } 2129 break; 2130 2131 case VIRTUALIZER_PARAM_VIRTUALIZATION_MODE: 2132 *(uint32_t *)pValue = (uint32_t) VirtualizerGetVirtualizationMode(pContext); 2133 break; 2134 2135 default: 2136 ALOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid param %d", param); 2137 status = -EINVAL; 2138 break; 2139 } 2140 2141 ALOGV("\tVirtualizer_getParameter end returning status=%d", status); 2142 return status; 2143} /* end Virtualizer_getParameter */ 2144 2145//---------------------------------------------------------------------------- 2146// Virtualizer_setParameter() 2147//---------------------------------------------------------------------------- 2148// Purpose: 2149// Set a Virtualizer parameter 2150// 2151// Inputs: 2152// pVirtualizer - handle to instance data 2153// pParam - pointer to parameter 2154// pValue - pointer to value 2155// 2156// Outputs: 2157// 2158//---------------------------------------------------------------------------- 2159 2160int Virtualizer_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2161 int status = 0; 2162 int16_t strength; 2163 int32_t *pParamTemp = (int32_t *)pParam; 2164 int32_t param = *pParamTemp++; 2165 2166 //ALOGV("\tVirtualizer_setParameter start"); 2167 2168 switch (param){ 2169 case VIRTUALIZER_PARAM_STRENGTH: 2170 strength = *(int16_t *)pValue; 2171 //ALOGV("\tVirtualizer_setParameter() VIRTUALIZER_PARAM_STRENGTH value is %d", strength); 2172 //ALOGV("\tVirtualizer_setParameter() Calling pVirtualizer->setStrength"); 2173 VirtualizerSetStrength(pContext, (int32_t)strength); 2174 //ALOGV("\tVirtualizer_setParameter() Called pVirtualizer->setStrength"); 2175 break; 2176 2177 case VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE: { 2178 const audio_devices_t deviceType = *(audio_devices_t *) pValue; 2179 status = VirtualizerForceVirtualizationMode(pContext, deviceType); 2180 //ALOGV("VIRTUALIZER_PARAM_FORCE_VIRTUALIZATION_MODE device=0x%x result=%d", 2181 // deviceType, status); 2182 } 2183 break; 2184 2185 default: 2186 ALOGV("\tLVM_ERROR : Virtualizer_setParameter() invalid param %d", param); 2187 break; 2188 } 2189 2190 //ALOGV("\tVirtualizer_setParameter end"); 2191 return status; 2192} /* end Virtualizer_setParameter */ 2193 2194//---------------------------------------------------------------------------- 2195// Equalizer_getParameter() 2196//---------------------------------------------------------------------------- 2197// Purpose: 2198// Get a Equalizer parameter 2199// 2200// Inputs: 2201// pEqualizer - handle to instance data 2202// pParam - pointer to parameter 2203// pValue - pointer to variable to hold retrieved value 2204// pValueSize - pointer to value size: maximum size as input 2205// 2206// Outputs: 2207// *pValue updated with parameter value 2208// *pValueSize updated with actual value size 2209// 2210// 2211// Side Effects: 2212// 2213//---------------------------------------------------------------------------- 2214int Equalizer_getParameter(EffectContext *pContext, 2215 void *pParam, 2216 uint32_t *pValueSize, 2217 void *pValue){ 2218 int status = 0; 2219 int bMute = 0; 2220 int32_t *pParamTemp = (int32_t *)pParam; 2221 int32_t param = *pParamTemp++; 2222 int32_t param2; 2223 char *name; 2224 2225 //ALOGV("\tEqualizer_getParameter start"); 2226 2227 switch (param) { 2228 case EQ_PARAM_NUM_BANDS: 2229 case EQ_PARAM_CUR_PRESET: 2230 case EQ_PARAM_GET_NUM_OF_PRESETS: 2231 case EQ_PARAM_BAND_LEVEL: 2232 case EQ_PARAM_GET_BAND: 2233 if (*pValueSize < sizeof(int16_t)) { 2234 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 1 %d", *pValueSize); 2235 return -EINVAL; 2236 } 2237 *pValueSize = sizeof(int16_t); 2238 break; 2239 2240 case EQ_PARAM_LEVEL_RANGE: 2241 if (*pValueSize < 2 * sizeof(int16_t)) { 2242 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 2 %d", *pValueSize); 2243 return -EINVAL; 2244 } 2245 *pValueSize = 2 * sizeof(int16_t); 2246 break; 2247 case EQ_PARAM_BAND_FREQ_RANGE: 2248 if (*pValueSize < 2 * sizeof(int32_t)) { 2249 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 3 %d", *pValueSize); 2250 return -EINVAL; 2251 } 2252 *pValueSize = 2 * sizeof(int32_t); 2253 break; 2254 2255 case EQ_PARAM_CENTER_FREQ: 2256 if (*pValueSize < sizeof(int32_t)) { 2257 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 5 %d", *pValueSize); 2258 return -EINVAL; 2259 } 2260 *pValueSize = sizeof(int32_t); 2261 break; 2262 2263 case EQ_PARAM_GET_PRESET_NAME: 2264 break; 2265 2266 case EQ_PARAM_PROPERTIES: 2267 if (*pValueSize < (2 + FIVEBAND_NUMBANDS) * sizeof(uint16_t)) { 2268 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 1 %d", *pValueSize); 2269 return -EINVAL; 2270 } 2271 *pValueSize = (2 + FIVEBAND_NUMBANDS) * sizeof(uint16_t); 2272 break; 2273 2274 default: 2275 ALOGV("\tLVM_ERROR : Equalizer_getParameter unknown param %d", param); 2276 return -EINVAL; 2277 } 2278 2279 switch (param) { 2280 case EQ_PARAM_NUM_BANDS: 2281 *(uint16_t *)pValue = (uint16_t)FIVEBAND_NUMBANDS; 2282 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_NUM_BANDS %d", *(int16_t *)pValue); 2283 break; 2284 2285 case EQ_PARAM_LEVEL_RANGE: 2286 *(int16_t *)pValue = -1500; 2287 *((int16_t *)pValue + 1) = 1500; 2288 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_LEVEL_RANGE min %d, max %d", 2289 // *(int16_t *)pValue, *((int16_t *)pValue + 1)); 2290 break; 2291 2292 case EQ_PARAM_BAND_LEVEL: 2293 param2 = *pParamTemp; 2294 if (param2 >= FIVEBAND_NUMBANDS) { 2295 status = -EINVAL; 2296 break; 2297 } 2298 *(int16_t *)pValue = (int16_t)EqualizerGetBandLevel(pContext, param2); 2299 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", 2300 // param2, *(int32_t *)pValue); 2301 break; 2302 2303 case EQ_PARAM_CENTER_FREQ: 2304 param2 = *pParamTemp; 2305 if (param2 >= FIVEBAND_NUMBANDS) { 2306 status = -EINVAL; 2307 break; 2308 } 2309 *(int32_t *)pValue = EqualizerGetCentreFrequency(pContext, param2); 2310 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_CENTER_FREQ band %d, frequency %d", 2311 // param2, *(int32_t *)pValue); 2312 break; 2313 2314 case EQ_PARAM_BAND_FREQ_RANGE: 2315 param2 = *pParamTemp; 2316 if (param2 >= FIVEBAND_NUMBANDS) { 2317 status = -EINVAL; 2318 break; 2319 } 2320 EqualizerGetBandFreqRange(pContext, param2, (uint32_t *)pValue, ((uint32_t *)pValue + 1)); 2321 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_BAND_FREQ_RANGE band %d, min %d, max %d", 2322 // param2, *(int32_t *)pValue, *((int32_t *)pValue + 1)); 2323 break; 2324 2325 case EQ_PARAM_GET_BAND: 2326 param2 = *pParamTemp; 2327 *(uint16_t *)pValue = (uint16_t)EqualizerGetBand(pContext, param2); 2328 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_GET_BAND frequency %d, band %d", 2329 // param2, *(uint16_t *)pValue); 2330 break; 2331 2332 case EQ_PARAM_CUR_PRESET: 2333 *(uint16_t *)pValue = (uint16_t)EqualizerGetPreset(pContext); 2334 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_CUR_PRESET %d", *(int32_t *)pValue); 2335 break; 2336 2337 case EQ_PARAM_GET_NUM_OF_PRESETS: 2338 *(uint16_t *)pValue = (uint16_t)EqualizerGetNumPresets(); 2339 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_GET_NUM_OF_PRESETS %d", *(int16_t *)pValue); 2340 break; 2341 2342 case EQ_PARAM_GET_PRESET_NAME: 2343 param2 = *pParamTemp; 2344 if (param2 >= EqualizerGetNumPresets()) { 2345 //if (param2 >= 20) { // AGO FIX 2346 status = -EINVAL; 2347 break; 2348 } 2349 name = (char *)pValue; 2350 strncpy(name, EqualizerGetPresetName(param2), *pValueSize - 1); 2351 name[*pValueSize - 1] = 0; 2352 *pValueSize = strlen(name) + 1; 2353 //ALOGV("\tEqualizer_getParameter() EQ_PARAM_GET_PRESET_NAME preset %d, name %s len %d", 2354 // param2, gEqualizerPresets[param2].name, *pValueSize); 2355 break; 2356 2357 case EQ_PARAM_PROPERTIES: { 2358 int16_t *p = (int16_t *)pValue; 2359 ALOGV("\tEqualizer_getParameter() EQ_PARAM_PROPERTIES"); 2360 p[0] = (int16_t)EqualizerGetPreset(pContext); 2361 p[1] = (int16_t)FIVEBAND_NUMBANDS; 2362 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 2363 p[2 + i] = (int16_t)EqualizerGetBandLevel(pContext, i); 2364 } 2365 } break; 2366 2367 default: 2368 ALOGV("\tLVM_ERROR : Equalizer_getParameter() invalid param %d", param); 2369 status = -EINVAL; 2370 break; 2371 } 2372 2373 //GV("\tEqualizer_getParameter end\n"); 2374 return status; 2375} /* end Equalizer_getParameter */ 2376 2377//---------------------------------------------------------------------------- 2378// Equalizer_setParameter() 2379//---------------------------------------------------------------------------- 2380// Purpose: 2381// Set a Equalizer parameter 2382// 2383// Inputs: 2384// pEqualizer - handle to instance data 2385// pParam - pointer to parameter 2386// pValue - pointer to value 2387// 2388// Outputs: 2389// 2390//---------------------------------------------------------------------------- 2391int Equalizer_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2392 int status = 0; 2393 int32_t preset; 2394 int32_t band; 2395 int32_t level; 2396 int32_t *pParamTemp = (int32_t *)pParam; 2397 int32_t param = *pParamTemp++; 2398 2399 2400 //ALOGV("\tEqualizer_setParameter start"); 2401 switch (param) { 2402 case EQ_PARAM_CUR_PRESET: 2403 preset = (int32_t)(*(uint16_t *)pValue); 2404 2405 //ALOGV("\tEqualizer_setParameter() EQ_PARAM_CUR_PRESET %d", preset); 2406 if ((preset >= EqualizerGetNumPresets())||(preset < 0)) { 2407 status = -EINVAL; 2408 break; 2409 } 2410 EqualizerSetPreset(pContext, preset); 2411 break; 2412 case EQ_PARAM_BAND_LEVEL: 2413 band = *pParamTemp; 2414 level = (int32_t)(*(int16_t *)pValue); 2415 //ALOGV("\tEqualizer_setParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", band, level); 2416 if (band >= FIVEBAND_NUMBANDS) { 2417 status = -EINVAL; 2418 break; 2419 } 2420 EqualizerSetBandLevel(pContext, band, level); 2421 break; 2422 case EQ_PARAM_PROPERTIES: { 2423 //ALOGV("\tEqualizer_setParameter() EQ_PARAM_PROPERTIES"); 2424 int16_t *p = (int16_t *)pValue; 2425 if ((int)p[0] >= EqualizerGetNumPresets()) { 2426 status = -EINVAL; 2427 break; 2428 } 2429 if (p[0] >= 0) { 2430 EqualizerSetPreset(pContext, (int)p[0]); 2431 } else { 2432 if ((int)p[1] != FIVEBAND_NUMBANDS) { 2433 status = -EINVAL; 2434 break; 2435 } 2436 for (int i = 0; i < FIVEBAND_NUMBANDS; i++) { 2437 EqualizerSetBandLevel(pContext, i, (int)p[2 + i]); 2438 } 2439 } 2440 } break; 2441 default: 2442 ALOGV("\tLVM_ERROR : Equalizer_setParameter() invalid param %d", param); 2443 status = -EINVAL; 2444 break; 2445 } 2446 2447 //ALOGV("\tEqualizer_setParameter end"); 2448 return status; 2449} /* end Equalizer_setParameter */ 2450 2451//---------------------------------------------------------------------------- 2452// Volume_getParameter() 2453//---------------------------------------------------------------------------- 2454// Purpose: 2455// Get a Volume parameter 2456// 2457// Inputs: 2458// pVolume - handle to instance data 2459// pParam - pointer to parameter 2460// pValue - pointer to variable to hold retrieved value 2461// pValueSize - pointer to value size: maximum size as input 2462// 2463// Outputs: 2464// *pValue updated with parameter value 2465// *pValueSize updated with actual value size 2466// 2467// 2468// Side Effects: 2469// 2470//---------------------------------------------------------------------------- 2471 2472int Volume_getParameter(EffectContext *pContext, 2473 void *pParam, 2474 uint32_t *pValueSize, 2475 void *pValue){ 2476 int status = 0; 2477 int bMute = 0; 2478 int32_t *pParamTemp = (int32_t *)pParam; 2479 int32_t param = *pParamTemp++;; 2480 char *name; 2481 2482 //ALOGV("\tVolume_getParameter start"); 2483 2484 switch (param){ 2485 case VOLUME_PARAM_LEVEL: 2486 case VOLUME_PARAM_MAXLEVEL: 2487 case VOLUME_PARAM_STEREOPOSITION: 2488 if (*pValueSize != sizeof(int16_t)){ 2489 ALOGV("\tLVM_ERROR : Volume_getParameter() invalid pValueSize 1 %d", *pValueSize); 2490 return -EINVAL; 2491 } 2492 *pValueSize = sizeof(int16_t); 2493 break; 2494 2495 case VOLUME_PARAM_MUTE: 2496 case VOLUME_PARAM_ENABLESTEREOPOSITION: 2497 if (*pValueSize < sizeof(int32_t)){ 2498 ALOGV("\tLVM_ERROR : Volume_getParameter() invalid pValueSize 2 %d", *pValueSize); 2499 return -EINVAL; 2500 } 2501 *pValueSize = sizeof(int32_t); 2502 break; 2503 2504 default: 2505 ALOGV("\tLVM_ERROR : Volume_getParameter unknown param %d", param); 2506 return -EINVAL; 2507 } 2508 2509 switch (param){ 2510 case VOLUME_PARAM_LEVEL: 2511 status = VolumeGetVolumeLevel(pContext, (int16_t *)(pValue)); 2512 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_LEVEL Value is %d", 2513 // *(int16_t *)pValue); 2514 break; 2515 2516 case VOLUME_PARAM_MAXLEVEL: 2517 *(int16_t *)pValue = 0; 2518 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_MAXLEVEL Value is %d", 2519 // *(int16_t *)pValue); 2520 break; 2521 2522 case VOLUME_PARAM_STEREOPOSITION: 2523 VolumeGetStereoPosition(pContext, (int16_t *)pValue); 2524 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_STEREOPOSITION Value is %d", 2525 // *(int16_t *)pValue); 2526 break; 2527 2528 case VOLUME_PARAM_MUTE: 2529 status = VolumeGetMute(pContext, (uint32_t *)pValue); 2530 ALOGV("\tVolume_getParameter() VOLUME_PARAM_MUTE Value is %d", 2531 *(uint32_t *)pValue); 2532 break; 2533 2534 case VOLUME_PARAM_ENABLESTEREOPOSITION: 2535 *(int32_t *)pValue = pContext->pBundledContext->bStereoPositionEnabled; 2536 //ALOGV("\tVolume_getParameter() VOLUME_PARAM_ENABLESTEREOPOSITION Value is %d", 2537 // *(uint32_t *)pValue); 2538 break; 2539 2540 default: 2541 ALOGV("\tLVM_ERROR : Volume_getParameter() invalid param %d", param); 2542 status = -EINVAL; 2543 break; 2544 } 2545 2546 //ALOGV("\tVolume_getParameter end"); 2547 return status; 2548} /* end Volume_getParameter */ 2549 2550 2551//---------------------------------------------------------------------------- 2552// Volume_setParameter() 2553//---------------------------------------------------------------------------- 2554// Purpose: 2555// Set a Volume parameter 2556// 2557// Inputs: 2558// pVolume - handle to instance data 2559// pParam - pointer to parameter 2560// pValue - pointer to value 2561// 2562// Outputs: 2563// 2564//---------------------------------------------------------------------------- 2565 2566int Volume_setParameter (EffectContext *pContext, void *pParam, void *pValue){ 2567 int status = 0; 2568 int16_t level; 2569 int16_t position; 2570 uint32_t mute; 2571 uint32_t positionEnabled; 2572 int32_t *pParamTemp = (int32_t *)pParam; 2573 int32_t param = *pParamTemp++; 2574 2575 //ALOGV("\tVolume_setParameter start"); 2576 2577 switch (param){ 2578 case VOLUME_PARAM_LEVEL: 2579 level = *(int16_t *)pValue; 2580 //ALOGV("\tVolume_setParameter() VOLUME_PARAM_LEVEL value is %d", level); 2581 //ALOGV("\tVolume_setParameter() Calling pVolume->setVolumeLevel"); 2582 status = VolumeSetVolumeLevel(pContext, (int16_t)level); 2583 //ALOGV("\tVolume_setParameter() Called pVolume->setVolumeLevel"); 2584 break; 2585 2586 case VOLUME_PARAM_MUTE: 2587 mute = *(uint32_t *)pValue; 2588 //ALOGV("\tVolume_setParameter() Calling pVolume->setMute, mute is %d", mute); 2589 //ALOGV("\tVolume_setParameter() Calling pVolume->setMute"); 2590 status = VolumeSetMute(pContext, mute); 2591 //ALOGV("\tVolume_setParameter() Called pVolume->setMute"); 2592 break; 2593 2594 case VOLUME_PARAM_ENABLESTEREOPOSITION: 2595 positionEnabled = *(uint32_t *)pValue; 2596 status = VolumeEnableStereoPosition(pContext, positionEnabled); 2597 status = VolumeSetStereoPosition(pContext, pContext->pBundledContext->positionSaved); 2598 //ALOGV("\tVolume_setParameter() VOLUME_PARAM_ENABLESTEREOPOSITION called"); 2599 break; 2600 2601 case VOLUME_PARAM_STEREOPOSITION: 2602 position = *(int16_t *)pValue; 2603 //ALOGV("\tVolume_setParameter() VOLUME_PARAM_STEREOPOSITION value is %d", position); 2604 //ALOGV("\tVolume_setParameter() Calling pVolume->VolumeSetStereoPosition"); 2605 status = VolumeSetStereoPosition(pContext, (int16_t)position); 2606 //ALOGV("\tVolume_setParameter() Called pVolume->VolumeSetStereoPosition"); 2607 break; 2608 2609 default: 2610 ALOGV("\tLVM_ERROR : Volume_setParameter() invalid param %d", param); 2611 break; 2612 } 2613 2614 //ALOGV("\tVolume_setParameter end"); 2615 return status; 2616} /* end Volume_setParameter */ 2617 2618/**************************************************************************************** 2619 * Name : LVC_ToDB_s32Tos16() 2620 * Input : Signed 32-bit integer 2621 * Output : Signed 16-bit integer 2622 * MSB (16) = sign bit 2623 * (15->05) = integer part 2624 * (04->01) = decimal part 2625 * Returns : Db value with respect to full scale 2626 * Description : 2627 * Remarks : 2628 ****************************************************************************************/ 2629 2630LVM_INT16 LVC_ToDB_s32Tos16(LVM_INT32 Lin_fix) 2631{ 2632 LVM_INT16 db_fix; 2633 LVM_INT16 Shift; 2634 LVM_INT16 SmallRemainder; 2635 LVM_UINT32 Remainder = (LVM_UINT32)Lin_fix; 2636 2637 /* Count leading bits, 1 cycle in assembly*/ 2638 for (Shift = 0; Shift<32; Shift++) 2639 { 2640 if ((Remainder & 0x80000000U)!=0) 2641 { 2642 break; 2643 } 2644 Remainder = Remainder << 1; 2645 } 2646 2647 /* 2648 * Based on the approximation equation (for Q11.4 format): 2649 * 2650 * dB = -96 * Shift + 16 * (8 * Remainder - 2 * Remainder^2) 2651 */ 2652 db_fix = (LVM_INT16)(-96 * Shift); /* Six dB steps in Q11.4 format*/ 2653 SmallRemainder = (LVM_INT16)((Remainder & 0x7fffffff) >> 24); 2654 db_fix = (LVM_INT16)(db_fix + SmallRemainder ); 2655 SmallRemainder = (LVM_INT16)(SmallRemainder * SmallRemainder); 2656 db_fix = (LVM_INT16)(db_fix - (LVM_INT16)((LVM_UINT16)SmallRemainder >> 9)); 2657 2658 /* Correct for small offset */ 2659 db_fix = (LVM_INT16)(db_fix - 5); 2660 2661 return db_fix; 2662} 2663 2664//---------------------------------------------------------------------------- 2665// Effect_setEnabled() 2666//---------------------------------------------------------------------------- 2667// Purpose: 2668// Enable or disable effect 2669// 2670// Inputs: 2671// pContext - pointer to effect context 2672// enabled - true if enabling the effect, false otherwise 2673// 2674// Outputs: 2675// 2676//---------------------------------------------------------------------------- 2677 2678int Effect_setEnabled(EffectContext *pContext, bool enabled) 2679{ 2680 ALOGV("\tEffect_setEnabled() type %d, enabled %d", pContext->EffectType, enabled); 2681 2682 if (enabled) { 2683 // Bass boost or Virtualizer can be temporarily disabled if playing over device speaker due 2684 // to their nature. 2685 bool tempDisabled = false; 2686 switch (pContext->EffectType) { 2687 case LVM_BASS_BOOST: 2688 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 2689 ALOGV("\tEffect_setEnabled() LVM_BASS_BOOST is already enabled"); 2690 return -EINVAL; 2691 } 2692 if(pContext->pBundledContext->SamplesToExitCountBb <= 0){ 2693 pContext->pBundledContext->NumberEffectsEnabled++; 2694 } 2695 pContext->pBundledContext->SamplesToExitCountBb = 2696 (LVM_INT32)(pContext->pBundledContext->SamplesPerSecond*0.1); 2697 pContext->pBundledContext->bBassEnabled = LVM_TRUE; 2698 tempDisabled = pContext->pBundledContext->bBassTempDisabled; 2699 break; 2700 case LVM_EQUALIZER: 2701 if (pContext->pBundledContext->bEqualizerEnabled == LVM_TRUE) { 2702 ALOGV("\tEffect_setEnabled() LVM_EQUALIZER is already enabled"); 2703 return -EINVAL; 2704 } 2705 if(pContext->pBundledContext->SamplesToExitCountEq <= 0){ 2706 pContext->pBundledContext->NumberEffectsEnabled++; 2707 } 2708 pContext->pBundledContext->SamplesToExitCountEq = 2709 (LVM_INT32)(pContext->pBundledContext->SamplesPerSecond*0.1); 2710 pContext->pBundledContext->bEqualizerEnabled = LVM_TRUE; 2711 break; 2712 case LVM_VIRTUALIZER: 2713 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) { 2714 ALOGV("\tEffect_setEnabled() LVM_VIRTUALIZER is already enabled"); 2715 return -EINVAL; 2716 } 2717 if(pContext->pBundledContext->SamplesToExitCountVirt <= 0){ 2718 pContext->pBundledContext->NumberEffectsEnabled++; 2719 } 2720 pContext->pBundledContext->SamplesToExitCountVirt = 2721 (LVM_INT32)(pContext->pBundledContext->SamplesPerSecond*0.1); 2722 pContext->pBundledContext->bVirtualizerEnabled = LVM_TRUE; 2723 tempDisabled = pContext->pBundledContext->bVirtualizerTempDisabled; 2724 break; 2725 case LVM_VOLUME: 2726 if (pContext->pBundledContext->bVolumeEnabled == LVM_TRUE) { 2727 ALOGV("\tEffect_setEnabled() LVM_VOLUME is already enabled"); 2728 return -EINVAL; 2729 } 2730 pContext->pBundledContext->NumberEffectsEnabled++; 2731 pContext->pBundledContext->bVolumeEnabled = LVM_TRUE; 2732 break; 2733 default: 2734 ALOGV("\tEffect_setEnabled() invalid effect type"); 2735 return -EINVAL; 2736 } 2737 if (!tempDisabled) { 2738 LvmEffect_enable(pContext); 2739 } 2740 } else { 2741 switch (pContext->EffectType) { 2742 case LVM_BASS_BOOST: 2743 if (pContext->pBundledContext->bBassEnabled == LVM_FALSE) { 2744 ALOGV("\tEffect_setEnabled() LVM_BASS_BOOST is already disabled"); 2745 return -EINVAL; 2746 } 2747 pContext->pBundledContext->bBassEnabled = LVM_FALSE; 2748 break; 2749 case LVM_EQUALIZER: 2750 if (pContext->pBundledContext->bEqualizerEnabled == LVM_FALSE) { 2751 ALOGV("\tEffect_setEnabled() LVM_EQUALIZER is already disabled"); 2752 return -EINVAL; 2753 } 2754 pContext->pBundledContext->bEqualizerEnabled = LVM_FALSE; 2755 break; 2756 case LVM_VIRTUALIZER: 2757 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_FALSE) { 2758 ALOGV("\tEffect_setEnabled() LVM_VIRTUALIZER is already disabled"); 2759 return -EINVAL; 2760 } 2761 pContext->pBundledContext->bVirtualizerEnabled = LVM_FALSE; 2762 break; 2763 case LVM_VOLUME: 2764 if (pContext->pBundledContext->bVolumeEnabled == LVM_FALSE) { 2765 ALOGV("\tEffect_setEnabled() LVM_VOLUME is already disabled"); 2766 return -EINVAL; 2767 } 2768 pContext->pBundledContext->bVolumeEnabled = LVM_FALSE; 2769 break; 2770 default: 2771 ALOGV("\tEffect_setEnabled() invalid effect type"); 2772 return -EINVAL; 2773 } 2774 LvmEffect_disable(pContext); 2775 } 2776 2777 return 0; 2778} 2779 2780//---------------------------------------------------------------------------- 2781// LVC_Convert_VolToDb() 2782//---------------------------------------------------------------------------- 2783// Purpose: 2784// Convery volume in Q24 to dB 2785// 2786// Inputs: 2787// vol: Q.24 volume dB 2788// 2789//----------------------------------------------------------------------- 2790 2791int16_t LVC_Convert_VolToDb(uint32_t vol){ 2792 int16_t dB; 2793 2794 dB = LVC_ToDB_s32Tos16(vol <<7); 2795 dB = (dB +8)>>4; 2796 dB = (dB <-96) ? -96 : dB ; 2797 2798 return dB; 2799} 2800 2801} // namespace 2802} // namespace 2803 2804extern "C" { 2805/* Effect Control Interface Implementation: Process */ 2806int Effect_process(effect_handle_t self, 2807 audio_buffer_t *inBuffer, 2808 audio_buffer_t *outBuffer){ 2809 EffectContext * pContext = (EffectContext *) self; 2810 LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */ 2811 int status = 0; 2812 int lvmStatus = 0; 2813 LVM_INT16 *in = (LVM_INT16 *)inBuffer->raw; 2814 LVM_INT16 *out = (LVM_INT16 *)outBuffer->raw; 2815 2816//ALOGV("\tEffect_process Start : Enabled = %d Called = %d (%8d %8d %8d)", 2817//pContext->pBundledContext->NumberEffectsEnabled,pContext->pBundledContext->NumberEffectsCalled, 2818// pContext->pBundledContext->SamplesToExitCountBb, 2819// pContext->pBundledContext->SamplesToExitCountVirt, 2820// pContext->pBundledContext->SamplesToExitCountEq); 2821 2822 if (pContext == NULL){ 2823 ALOGV("\tLVM_ERROR : Effect_process() ERROR pContext == NULL"); 2824 return -EINVAL; 2825 } 2826 2827 //if(pContext->EffectType == LVM_BASS_BOOST){ 2828 // ALOGV("\tEffect_process: Effect type is BASS_BOOST"); 2829 //}else if(pContext->EffectType == LVM_EQUALIZER){ 2830 // ALOGV("\tEffect_process: Effect type is LVM_EQUALIZER"); 2831 //}else if(pContext->EffectType == LVM_VIRTUALIZER){ 2832 // ALOGV("\tEffect_process: Effect type is LVM_VIRTUALIZER"); 2833 //} 2834 2835 if (inBuffer == NULL || inBuffer->raw == NULL || 2836 outBuffer == NULL || outBuffer->raw == NULL || 2837 inBuffer->frameCount != outBuffer->frameCount){ 2838 ALOGV("\tLVM_ERROR : Effect_process() ERROR NULL INPUT POINTER OR FRAME COUNT IS WRONG"); 2839 return -EINVAL; 2840 } 2841 if ((pContext->pBundledContext->bBassEnabled == LVM_FALSE)&& 2842 (pContext->EffectType == LVM_BASS_BOOST)){ 2843 //ALOGV("\tEffect_process() LVM_BASS_BOOST Effect is not enabled"); 2844 if(pContext->pBundledContext->SamplesToExitCountBb > 0){ 2845 pContext->pBundledContext->SamplesToExitCountBb -= outBuffer->frameCount * 2; // STEREO 2846 //ALOGV("\tEffect_process: Waiting to turn off BASS_BOOST, %d samples left", 2847 // pContext->pBundledContext->SamplesToExitCountBb); 2848 } 2849 if(pContext->pBundledContext->SamplesToExitCountBb <= 0) { 2850 status = -ENODATA; 2851 pContext->pBundledContext->NumberEffectsEnabled--; 2852 ALOGV("\tEffect_process() this is the last frame for LVM_BASS_BOOST"); 2853 } 2854 } 2855 if ((pContext->pBundledContext->bVolumeEnabled == LVM_FALSE)&& 2856 (pContext->EffectType == LVM_VOLUME)){ 2857 //ALOGV("\tEffect_process() LVM_VOLUME Effect is not enabled"); 2858 status = -ENODATA; 2859 pContext->pBundledContext->NumberEffectsEnabled--; 2860 } 2861 if ((pContext->pBundledContext->bEqualizerEnabled == LVM_FALSE)&& 2862 (pContext->EffectType == LVM_EQUALIZER)){ 2863 //ALOGV("\tEffect_process() LVM_EQUALIZER Effect is not enabled"); 2864 if(pContext->pBundledContext->SamplesToExitCountEq > 0){ 2865 pContext->pBundledContext->SamplesToExitCountEq -= outBuffer->frameCount * 2; // STEREO 2866 //ALOGV("\tEffect_process: Waiting to turn off EQUALIZER, %d samples left", 2867 // pContext->pBundledContext->SamplesToExitCountEq); 2868 } 2869 if(pContext->pBundledContext->SamplesToExitCountEq <= 0) { 2870 status = -ENODATA; 2871 pContext->pBundledContext->NumberEffectsEnabled--; 2872 ALOGV("\tEffect_process() this is the last frame for LVM_EQUALIZER"); 2873 } 2874 } 2875 if ((pContext->pBundledContext->bVirtualizerEnabled == LVM_FALSE)&& 2876 (pContext->EffectType == LVM_VIRTUALIZER)){ 2877 //ALOGV("\tEffect_process() LVM_VIRTUALIZER Effect is not enabled"); 2878 if(pContext->pBundledContext->SamplesToExitCountVirt > 0){ 2879 pContext->pBundledContext->SamplesToExitCountVirt -= outBuffer->frameCount * 2;// STEREO 2880 //ALOGV("\tEffect_process: Waiting for to turn off VIRTUALIZER, %d samples left", 2881 // pContext->pBundledContext->SamplesToExitCountVirt); 2882 } 2883 if(pContext->pBundledContext->SamplesToExitCountVirt <= 0) { 2884 status = -ENODATA; 2885 pContext->pBundledContext->NumberEffectsEnabled--; 2886 ALOGV("\tEffect_process() this is the last frame for LVM_VIRTUALIZER"); 2887 } 2888 } 2889 2890 if(status != -ENODATA){ 2891 pContext->pBundledContext->NumberEffectsCalled++; 2892 } 2893 2894 if(pContext->pBundledContext->NumberEffectsCalled == 2895 pContext->pBundledContext->NumberEffectsEnabled){ 2896 //ALOGV("\tEffect_process Calling process with %d effects enabled, %d called: Effect %d", 2897 //pContext->pBundledContext->NumberEffectsEnabled, 2898 //pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType); 2899 2900 if(status == -ENODATA){ 2901 ALOGV("\tEffect_process() processing last frame"); 2902 } 2903 pContext->pBundledContext->NumberEffectsCalled = 0; 2904 /* Process all the available frames, block processing is 2905 handled internalLY by the LVM bundle */ 2906 lvmStatus = android::LvmBundle_process( (LVM_INT16 *)inBuffer->raw, 2907 (LVM_INT16 *)outBuffer->raw, 2908 outBuffer->frameCount, 2909 pContext); 2910 if(lvmStatus != LVM_SUCCESS){ 2911 ALOGV("\tLVM_ERROR : LvmBundle_process returned error %d", lvmStatus); 2912 return lvmStatus; 2913 } 2914 } else { 2915 //ALOGV("\tEffect_process Not Calling process with %d effects enabled, %d called: Effect %d", 2916 //pContext->pBundledContext->NumberEffectsEnabled, 2917 //pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType); 2918 // 2 is for stereo input 2919 if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) { 2920 for (size_t i=0; i < outBuffer->frameCount*2; i++){ 2921 outBuffer->s16[i] = 2922 clamp16((LVM_INT32)outBuffer->s16[i] + (LVM_INT32)inBuffer->s16[i]); 2923 } 2924 } else if (outBuffer->raw != inBuffer->raw) { 2925 memcpy(outBuffer->raw, inBuffer->raw, outBuffer->frameCount*sizeof(LVM_INT16)*2); 2926 } 2927 } 2928 2929 return status; 2930} /* end Effect_process */ 2931 2932/* Effect Control Interface Implementation: Command */ 2933int Effect_command(effect_handle_t self, 2934 uint32_t cmdCode, 2935 uint32_t cmdSize, 2936 void *pCmdData, 2937 uint32_t *replySize, 2938 void *pReplyData){ 2939 EffectContext * pContext = (EffectContext *) self; 2940 int retsize; 2941 2942 //ALOGV("\t\nEffect_command start"); 2943 2944 if(pContext->EffectType == LVM_BASS_BOOST){ 2945 //ALOGV("\tEffect_command setting command for LVM_BASS_BOOST"); 2946 } 2947 if(pContext->EffectType == LVM_VIRTUALIZER){ 2948 //ALOGV("\tEffect_command setting command for LVM_VIRTUALIZER"); 2949 } 2950 if(pContext->EffectType == LVM_EQUALIZER){ 2951 //ALOGV("\tEffect_command setting command for LVM_EQUALIZER"); 2952 } 2953 if(pContext->EffectType == LVM_VOLUME){ 2954 //ALOGV("\tEffect_command setting command for LVM_VOLUME"); 2955 } 2956 2957 if (pContext == NULL){ 2958 ALOGV("\tLVM_ERROR : Effect_command ERROR pContext == NULL"); 2959 return -EINVAL; 2960 } 2961 2962 //ALOGV("\tEffect_command INPUTS are: command %d cmdSize %d",cmdCode, cmdSize); 2963 2964 // Incase we disable an effect, next time process is 2965 // called the number of effect called could be greater 2966 // pContext->pBundledContext->NumberEffectsCalled = 0; 2967 2968 //ALOGV("\tEffect_command NumberEffectsCalled = %d, NumberEffectsEnabled = %d", 2969 // pContext->pBundledContext->NumberEffectsCalled, 2970 // pContext->pBundledContext->NumberEffectsEnabled); 2971 2972 switch (cmdCode){ 2973 case EFFECT_CMD_INIT: 2974 if (pReplyData == NULL || *replySize != sizeof(int)){ 2975 ALOGV("\tLVM_ERROR, EFFECT_CMD_INIT: ERROR for effect type %d", 2976 pContext->EffectType); 2977 return -EINVAL; 2978 } 2979 *(int *) pReplyData = 0; 2980 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT start"); 2981 if(pContext->EffectType == LVM_BASS_BOOST){ 2982 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_BASS_BOOST"); 2983 android::BassSetStrength(pContext, 0); 2984 } 2985 if(pContext->EffectType == LVM_VIRTUALIZER){ 2986 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_VIRTUALIZER"); 2987 android::VirtualizerSetStrength(pContext, 0); 2988 } 2989 if(pContext->EffectType == LVM_EQUALIZER){ 2990 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_EQUALIZER"); 2991 android::EqualizerSetPreset(pContext, 0); 2992 } 2993 if(pContext->EffectType == LVM_VOLUME){ 2994 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_VOLUME"); 2995 *(int *) pReplyData = android::VolumeSetVolumeLevel(pContext, 0); 2996 } 2997 break; 2998 2999 case EFFECT_CMD_SET_CONFIG: 3000 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_CONFIG start"); 3001 if (pCmdData == NULL|| 3002 cmdSize != sizeof(effect_config_t)|| 3003 pReplyData == NULL|| 3004 *replySize != sizeof(int)){ 3005 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: " 3006 "EFFECT_CMD_SET_CONFIG: ERROR"); 3007 return -EINVAL; 3008 } 3009 *(int *) pReplyData = android::Effect_setConfig(pContext, (effect_config_t *) pCmdData); 3010 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_CONFIG end"); 3011 break; 3012 3013 case EFFECT_CMD_GET_CONFIG: 3014 if (pReplyData == NULL || 3015 *replySize != sizeof(effect_config_t)) { 3016 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: " 3017 "EFFECT_CMD_GET_CONFIG: ERROR"); 3018 return -EINVAL; 3019 } 3020 3021 android::Effect_getConfig(pContext, (effect_config_t *)pReplyData); 3022 break; 3023 3024 case EFFECT_CMD_RESET: 3025 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_RESET start"); 3026 android::Effect_setConfig(pContext, &pContext->config); 3027 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_RESET end"); 3028 break; 3029 3030 case EFFECT_CMD_GET_PARAM:{ 3031 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_GET_PARAM start"); 3032 3033 if(pContext->EffectType == LVM_BASS_BOOST){ 3034 if (pCmdData == NULL || 3035 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3036 pReplyData == NULL || 3037 *replySize < (sizeof(effect_param_t) + sizeof(int32_t))){ 3038 ALOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: " 3039 "EFFECT_CMD_GET_PARAM: ERROR"); 3040 return -EINVAL; 3041 } 3042 effect_param_t *p = (effect_param_t *)pCmdData; 3043 3044 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3045 3046 p = (effect_param_t *)pReplyData; 3047 3048 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3049 3050 p->status = android::BassBoost_getParameter(pContext, 3051 p->data, 3052 &p->vsize, 3053 p->data + voffset); 3054 3055 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3056 3057 //ALOGV("\tBassBoost_command EFFECT_CMD_GET_PARAM " 3058 // "*pCmdData %d, *replySize %d, *pReplyData %d ", 3059 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3060 // *replySize, 3061 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset)); 3062 } 3063 3064 if(pContext->EffectType == LVM_VIRTUALIZER){ 3065 if (pCmdData == NULL || 3066 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3067 pReplyData == NULL || 3068 *replySize < (sizeof(effect_param_t) + sizeof(int32_t))){ 3069 ALOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: " 3070 "EFFECT_CMD_GET_PARAM: ERROR"); 3071 return -EINVAL; 3072 } 3073 effect_param_t *p = (effect_param_t *)pCmdData; 3074 3075 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3076 3077 p = (effect_param_t *)pReplyData; 3078 3079 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3080 3081 p->status = android::Virtualizer_getParameter(pContext, 3082 (void *)p->data, 3083 &p->vsize, 3084 p->data + voffset); 3085 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3086 3087 //ALOGV("\tVirtualizer_command EFFECT_CMD_GET_PARAM " 3088 // "*pCmdData %d, *replySize %d, *pReplyData %d ", 3089 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3090 // *replySize, 3091 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset)); 3092 } 3093 if(pContext->EffectType == LVM_EQUALIZER){ 3094 //ALOGV("\tEqualizer_command cmdCode Case: " 3095 // "EFFECT_CMD_GET_PARAM start"); 3096 if (pCmdData == NULL || 3097 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3098 pReplyData == NULL || 3099 *replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))) { 3100 ALOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: " 3101 "EFFECT_CMD_GET_PARAM"); 3102 return -EINVAL; 3103 } 3104 effect_param_t *p = (effect_param_t *)pCmdData; 3105 3106 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3107 3108 p = (effect_param_t *)pReplyData; 3109 3110 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3111 3112 p->status = android::Equalizer_getParameter(pContext, 3113 p->data, 3114 &p->vsize, 3115 p->data + voffset); 3116 3117 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3118 3119 //ALOGV("\tEqualizer_command EFFECT_CMD_GET_PARAM *pCmdData %d, *replySize %d, " 3120 // "*pReplyData %08x %08x", 3121 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), *replySize, 3122 // *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset), 3123 // *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset + 3124 // sizeof(int32_t))); 3125 } 3126 if(pContext->EffectType == LVM_VOLUME){ 3127 //ALOGV("\tVolume_command cmdCode Case: EFFECT_CMD_GET_PARAM start"); 3128 if (pCmdData == NULL || 3129 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3130 pReplyData == NULL || 3131 *replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))){ 3132 ALOGV("\tLVM_ERROR : Volume_command cmdCode Case: " 3133 "EFFECT_CMD_GET_PARAM: ERROR"); 3134 return -EINVAL; 3135 } 3136 effect_param_t *p = (effect_param_t *)pCmdData; 3137 3138 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize); 3139 3140 p = (effect_param_t *)pReplyData; 3141 3142 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t); 3143 3144 p->status = android::Volume_getParameter(pContext, 3145 (void *)p->data, 3146 &p->vsize, 3147 p->data + voffset); 3148 3149 *replySize = sizeof(effect_param_t) + voffset + p->vsize; 3150 3151 //ALOGV("\tVolume_command EFFECT_CMD_GET_PARAM " 3152 // "*pCmdData %d, *replySize %d, *pReplyData %d ", 3153 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3154 // *replySize, 3155 // *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset)); 3156 } 3157 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_GET_PARAM end"); 3158 } break; 3159 case EFFECT_CMD_SET_PARAM:{ 3160 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_PARAM start"); 3161 if(pContext->EffectType == LVM_BASS_BOOST){ 3162 //ALOGV("\tBassBoost_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d", 3163 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3164 // *replySize, 3165 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t))); 3166 3167 if (pCmdData == NULL|| 3168 cmdSize != (sizeof(effect_param_t) + sizeof(int32_t) +sizeof(int16_t))|| 3169 pReplyData == NULL|| 3170 *replySize != sizeof(int32_t)){ 3171 ALOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: " 3172 "EFFECT_CMD_SET_PARAM: ERROR"); 3173 return -EINVAL; 3174 } 3175 effect_param_t *p = (effect_param_t *) pCmdData; 3176 3177 if (p->psize != sizeof(int32_t)){ 3178 ALOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: " 3179 "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)"); 3180 return -EINVAL; 3181 } 3182 3183 //ALOGV("\tnBassBoost_command cmdSize is %d\n" 3184 // "\tsizeof(effect_param_t) is %d\n" 3185 // "\tp->psize is %d\n" 3186 // "\tp->vsize is %d" 3187 // "\n", 3188 // cmdSize, sizeof(effect_param_t), p->psize, p->vsize ); 3189 3190 *(int *)pReplyData = android::BassBoost_setParameter(pContext, 3191 (void *)p->data, 3192 p->data + p->psize); 3193 } 3194 if(pContext->EffectType == LVM_VIRTUALIZER){ 3195 // Warning this log will fail to properly read an int32_t value, assumes int16_t 3196 //ALOGV("\tVirtualizer_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d", 3197 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3198 // *replySize, 3199 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t))); 3200 3201 if (pCmdData == NULL || 3202 // legal parameters are int16_t or int32_t 3203 cmdSize > (sizeof(effect_param_t) + sizeof(int32_t) +sizeof(int32_t)) || 3204 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t) +sizeof(int16_t)) || 3205 pReplyData == NULL || 3206 *replySize != sizeof(int32_t)){ 3207 ALOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: " 3208 "EFFECT_CMD_SET_PARAM: ERROR"); 3209 return -EINVAL; 3210 } 3211 effect_param_t *p = (effect_param_t *) pCmdData; 3212 3213 if (p->psize != sizeof(int32_t)){ 3214 ALOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: " 3215 "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)"); 3216 return -EINVAL; 3217 } 3218 3219 //ALOGV("\tnVirtualizer_command cmdSize is %d\n" 3220 // "\tsizeof(effect_param_t) is %d\n" 3221 // "\tp->psize is %d\n" 3222 // "\tp->vsize is %d" 3223 // "\n", 3224 // cmdSize, sizeof(effect_param_t), p->psize, p->vsize ); 3225 3226 *(int *)pReplyData = android::Virtualizer_setParameter(pContext, 3227 (void *)p->data, 3228 p->data + p->psize); 3229 } 3230 if(pContext->EffectType == LVM_EQUALIZER){ 3231 //ALOGV("\tEqualizer_command cmdCode Case: " 3232 // "EFFECT_CMD_SET_PARAM start"); 3233 //ALOGV("\tEqualizer_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ", 3234 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3235 // *replySize, 3236 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t))); 3237 3238 if (pCmdData == NULL || cmdSize < (sizeof(effect_param_t) + sizeof(int32_t)) || 3239 pReplyData == NULL || *replySize != sizeof(int32_t)) { 3240 ALOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: " 3241 "EFFECT_CMD_SET_PARAM: ERROR"); 3242 return -EINVAL; 3243 } 3244 effect_param_t *p = (effect_param_t *) pCmdData; 3245 3246 *(int *)pReplyData = android::Equalizer_setParameter(pContext, 3247 (void *)p->data, 3248 p->data + p->psize); 3249 } 3250 if(pContext->EffectType == LVM_VOLUME){ 3251 //ALOGV("\tVolume_command cmdCode Case: EFFECT_CMD_SET_PARAM start"); 3252 //ALOGV("\tVolume_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ", 3253 // *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), 3254 // *replySize, 3255 // *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) +sizeof(int32_t))); 3256 3257 if ( pCmdData == NULL|| 3258 cmdSize < (sizeof(effect_param_t) + sizeof(int32_t))|| 3259 pReplyData == NULL|| 3260 *replySize != sizeof(int32_t)){ 3261 ALOGV("\tLVM_ERROR : Volume_command cmdCode Case: " 3262 "EFFECT_CMD_SET_PARAM: ERROR"); 3263 return -EINVAL; 3264 } 3265 effect_param_t *p = (effect_param_t *) pCmdData; 3266 3267 *(int *)pReplyData = android::Volume_setParameter(pContext, 3268 (void *)p->data, 3269 p->data + p->psize); 3270 } 3271 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_PARAM end"); 3272 } break; 3273 3274 case EFFECT_CMD_ENABLE: 3275 ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE start"); 3276 if (pReplyData == NULL || *replySize != sizeof(int)){ 3277 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: EFFECT_CMD_ENABLE: ERROR"); 3278 return -EINVAL; 3279 } 3280 3281 *(int *)pReplyData = android::Effect_setEnabled(pContext, LVM_TRUE); 3282 break; 3283 3284 case EFFECT_CMD_DISABLE: 3285 //ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE start"); 3286 if (pReplyData == NULL || *replySize != sizeof(int)){ 3287 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: EFFECT_CMD_DISABLE: ERROR"); 3288 return -EINVAL; 3289 } 3290 *(int *)pReplyData = android::Effect_setEnabled(pContext, LVM_FALSE); 3291 break; 3292 3293 case EFFECT_CMD_SET_DEVICE: 3294 { 3295 ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_DEVICE start"); 3296 uint32_t device = *(uint32_t *)pCmdData; 3297 pContext->pBundledContext->nOutputDevice = (audio_devices_t) device; 3298 3299 if (pContext->EffectType == LVM_BASS_BOOST) { 3300 if((device == AUDIO_DEVICE_OUT_SPEAKER) || 3301 (device == AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT) || 3302 (device == AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER)){ 3303 ALOGV("\tEFFECT_CMD_SET_DEVICE device is invalid for LVM_BASS_BOOST %d", 3304 *(int32_t *)pCmdData); 3305 ALOGV("\tEFFECT_CMD_SET_DEVICE temporary disable LVM_BAS_BOOST"); 3306 3307 // If a device doesnt support bassboost the effect must be temporarily disabled 3308 // the effect must still report its original state as this can only be changed 3309 // by the ENABLE/DISABLE command 3310 3311 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 3312 ALOGV("\tEFFECT_CMD_SET_DEVICE disable LVM_BASS_BOOST %d", 3313 *(int32_t *)pCmdData); 3314 android::LvmEffect_disable(pContext); 3315 } 3316 pContext->pBundledContext->bBassTempDisabled = LVM_TRUE; 3317 } else { 3318 ALOGV("\tEFFECT_CMD_SET_DEVICE device is valid for LVM_BASS_BOOST %d", 3319 *(int32_t *)pCmdData); 3320 3321 // If a device supports bassboost and the effect has been temporarily disabled 3322 // previously then re-enable it 3323 3324 if (pContext->pBundledContext->bBassEnabled == LVM_TRUE) { 3325 ALOGV("\tEFFECT_CMD_SET_DEVICE re-enable LVM_BASS_BOOST %d", 3326 *(int32_t *)pCmdData); 3327 android::LvmEffect_enable(pContext); 3328 } 3329 pContext->pBundledContext->bBassTempDisabled = LVM_FALSE; 3330 } 3331 } 3332 if (pContext->EffectType == LVM_VIRTUALIZER) { 3333 if (pContext->pBundledContext->nVirtualizerForcedDevice == AUDIO_DEVICE_NONE) { 3334 // default case unless configuration is forced 3335 if (android::VirtualizerIsDeviceSupported(device) != 0) { 3336 ALOGV("\tEFFECT_CMD_SET_DEVICE device is invalid for LVM_VIRTUALIZER %d", 3337 *(int32_t *)pCmdData); 3338 ALOGV("\tEFFECT_CMD_SET_DEVICE temporary disable LVM_VIRTUALIZER"); 3339 3340 //If a device doesnt support virtualizer the effect must be temporarily 3341 // disabled the effect must still report its original state as this can 3342 // only be changed by the ENABLE/DISABLE command 3343 3344 if (pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE) { 3345 ALOGV("\tEFFECT_CMD_SET_DEVICE disable LVM_VIRTUALIZER %d", 3346 *(int32_t *)pCmdData); 3347 android::LvmEffect_disable(pContext); 3348 } 3349 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_TRUE; 3350 } else { 3351 ALOGV("\tEFFECT_CMD_SET_DEVICE device is valid for LVM_VIRTUALIZER %d", 3352 *(int32_t *)pCmdData); 3353 3354 // If a device supports virtualizer and the effect has been temporarily 3355 // disabled previously then re-enable it 3356 3357 if(pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE){ 3358 ALOGV("\tEFFECT_CMD_SET_DEVICE re-enable LVM_VIRTUALIZER %d", 3359 *(int32_t *)pCmdData); 3360 android::LvmEffect_enable(pContext); 3361 } 3362 pContext->pBundledContext->bVirtualizerTempDisabled = LVM_FALSE; 3363 } 3364 } // else virtualization mode is forced to a certain device, nothing to do 3365 } 3366 ALOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_DEVICE end"); 3367 break; 3368 } 3369 case EFFECT_CMD_SET_VOLUME: 3370 { 3371 uint32_t leftVolume, rightVolume; 3372 int16_t leftdB, rightdB; 3373 int16_t maxdB, pandB; 3374 int32_t vol_ret[2] = {1<<24,1<<24}; // Apply no volume 3375 int status = 0; 3376 LVM_ControlParams_t ActiveParams; /* Current control Parameters */ 3377 LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */ 3378 3379 // if pReplyData is NULL, VOL_CTRL is delegated to another effect 3380 if(pReplyData == LVM_NULL){ 3381 break; 3382 } 3383 3384 if (pCmdData == NULL || 3385 cmdSize != 2 * sizeof(uint32_t)) { 3386 ALOGV("\tLVM_ERROR : Effect_command cmdCode Case: " 3387 "EFFECT_CMD_SET_VOLUME: ERROR"); 3388 return -EINVAL; 3389 } 3390 3391 leftVolume = ((*(uint32_t *)pCmdData)); 3392 rightVolume = ((*((uint32_t *)pCmdData + 1))); 3393 3394 if(leftVolume == 0x1000000){ 3395 leftVolume -= 1; 3396 } 3397 if(rightVolume == 0x1000000){ 3398 rightVolume -= 1; 3399 } 3400 3401 // Convert volume to dB 3402 leftdB = android::LVC_Convert_VolToDb(leftVolume); 3403 rightdB = android::LVC_Convert_VolToDb(rightVolume); 3404 3405 pandB = rightdB - leftdB; 3406 3407 // Calculate max volume in dB 3408 maxdB = leftdB; 3409 if(rightdB > maxdB){ 3410 maxdB = rightdB; 3411 } 3412 //ALOGV("\tEFFECT_CMD_SET_VOLUME Session: %d, SessionID: %d VOLUME is %d dB (%d), " 3413 // "effect is %d", 3414 //pContext->pBundledContext->SessionNo, pContext->pBundledContext->SessionId, 3415 //(int32_t)maxdB, maxVol<<7, pContext->EffectType); 3416 //ALOGV("\tEFFECT_CMD_SET_VOLUME: Left is %d, Right is %d", leftVolume, rightVolume); 3417 //ALOGV("\tEFFECT_CMD_SET_VOLUME: Left %ddB, Right %ddB, Position %ddB", 3418 // leftdB, rightdB, pandB); 3419 3420 memcpy(pReplyData, vol_ret, sizeof(int32_t)*2); 3421 android::VolumeSetVolumeLevel(pContext, (int16_t)(maxdB*100)); 3422 3423 /* Get the current settings */ 3424 LvmStatus =LVM_GetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams); 3425 LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetStereoPosition") 3426 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 3427 3428 /* Volume parameters */ 3429 ActiveParams.VC_Balance = pandB; 3430 ALOGV("\t\tVolumeSetStereoPosition() (-96dB -> +96dB)-> %d\n", ActiveParams.VC_Balance ); 3431 3432 /* Activate the initial settings */ 3433 LvmStatus =LVM_SetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams); 3434 LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeSetStereoPosition") 3435 if(LvmStatus != LVM_SUCCESS) return -EINVAL; 3436 break; 3437 } 3438 case EFFECT_CMD_SET_AUDIO_MODE: 3439 break; 3440 default: 3441 return -EINVAL; 3442 } 3443 3444 //ALOGV("\tEffect_command end...\n\n"); 3445 return 0; 3446} /* end Effect_command */ 3447 3448/* Effect Control Interface Implementation: get_descriptor */ 3449int Effect_getDescriptor(effect_handle_t self, 3450 effect_descriptor_t *pDescriptor) 3451{ 3452 EffectContext * pContext = (EffectContext *) self; 3453 const effect_descriptor_t *desc; 3454 3455 if (pContext == NULL || pDescriptor == NULL) { 3456 ALOGV("Effect_getDescriptor() invalid param"); 3457 return -EINVAL; 3458 } 3459 3460 switch(pContext->EffectType) { 3461 case LVM_BASS_BOOST: 3462 desc = &android::gBassBoostDescriptor; 3463 break; 3464 case LVM_VIRTUALIZER: 3465 desc = &android::gVirtualizerDescriptor; 3466 break; 3467 case LVM_EQUALIZER: 3468 desc = &android::gEqualizerDescriptor; 3469 break; 3470 case LVM_VOLUME: 3471 desc = &android::gVolumeDescriptor; 3472 break; 3473 default: 3474 return -EINVAL; 3475 } 3476 3477 *pDescriptor = *desc; 3478 3479 return 0; 3480} /* end Effect_getDescriptor */ 3481 3482// effect_handle_t interface implementation for effect 3483const struct effect_interface_s gLvmEffectInterface = { 3484 Effect_process, 3485 Effect_command, 3486 Effect_getDescriptor, 3487 NULL, 3488}; /* end gLvmEffectInterface */ 3489 3490// This is the only symbol that needs to be exported 3491__attribute__ ((visibility ("default"))) 3492audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = { 3493 .tag = AUDIO_EFFECT_LIBRARY_TAG, 3494 .version = EFFECT_LIBRARY_API_VERSION, 3495 .name = "Effect Bundle Library", 3496 .implementor = "NXP Software Ltd.", 3497 .create_effect = android::EffectCreate, 3498 .release_effect = android::EffectRelease, 3499 .get_descriptor = android::EffectGetDescriptor, 3500}; 3501 3502} 3503