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