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