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