First submission of audio effect library from NXP software.
This CL contains the first open sourceable version of the audio effect library from NXP software.
The effects implemented are:
- Bass boost
- Virtualizer (stereo widening)
- Equalizer
- Spectrum analyzer
Source file for the effect engines are located under libeffects/lvm/lib
The wrapper implementing the interface with the audio effect framework in under libeffects/lvm/wrapper
The code of other effect libraries has also been reorganized fo clarity:
- the effect factory is now under libeffects/factory
- the test equalizer and reverb effects are under libeffect/testlibs
- the visualizer is under libeffects/virtualizer
Change-Id: I8d91e2181f81b89f8fc0c1e1e6bf552c5809b2eb
diff --git a/media/libeffects/lvm/wrapper/Android.mk b/media/libeffects/lvm/wrapper/Android.mk
new file mode 100644
index 0000000..4ebc443
--- /dev/null
+++ b/media/libeffects/lvm/wrapper/Android.mk
@@ -0,0 +1,30 @@
+LOCAL_PATH:= $(call my-dir)
+
+# music bundle wrapper
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_SRC_FILES:= \
+ Bundle/EffectBundle.cpp
+
+LOCAL_MODULE:= libbundlewrapper
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/soundfx
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_STATIC_LIBRARIES += libmusicbundle
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils \
+ libdl
+
+LOCAL_C_INCLUDES += \
+ $(LOCAL_PATH)/Bundle \
+ $(LOCAL_PATH)/../lib/Common/lib/ \
+ $(LOCAL_PATH)/../lib/Bundle/lib/
+
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp
new file mode 100644
index 0000000..3bbcf55
--- /dev/null
+++ b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp
@@ -0,0 +1,2609 @@
+/*
+ * Copyright (C) 2010-2010 NXP Software
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "Bundle"
+#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
+#define LVM_BUNDLE // Include all the bundle code
+#define LOG_NDEBUG 0
+
+#include <cutils/log.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <new>
+#include <EffectBundle.h>
+
+#ifdef LVM_BUNDLE
+#define LVM_MAX_SESSIONS 32
+#define MAX_NUM_BANDS 5
+#define MAX_CALL_SIZE 256
+#endif /* end LVM_BUNDLE */
+
+
+int framecountag = 0;
+// effect_interface_t interface implementation for bass boost
+extern "C" const struct effect_interface_s gLvmEffectInterface;
+
+#define LVM_ERROR_CHECK(LvmStatus, callingFunc, calledFunc){\
+ if (LvmStatus == LVM_NULLADDRESS){\
+ LOGV("\tLVM_ERROR : Parameter error - "\
+ "null pointer returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\
+ }\
+ if (LvmStatus == LVM_ALIGNMENTERROR){\
+ LOGV("\tLVM_ERROR : Parameter error - "\
+ "bad alignment returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\
+ }\
+ if (LvmStatus == LVM_INVALIDNUMSAMPLES){\
+ LOGV("\tLVM_ERROR : Parameter error - "\
+ "bad number of samples returned by %s in %s\n\n\n\n", callingFunc, calledFunc);\
+ }\
+ if (LvmStatus == LVM_OUTOFRANGE){\
+ LOGV("\tLVM_ERROR : Parameter error - "\
+ "out of range returned by %s in %s\n", callingFunc, calledFunc);\
+ }\
+ }
+
+
+
+
+
+// Namespaces
+namespace android {
+namespace {
+
+/* local functions */
+#define CHECK_ARG(cond) { \
+ if (!(cond)) { \
+ LOGV("\tLVM_ERROR : Invalid argument: "#cond); \
+ return -EINVAL; \
+ } \
+}
+
+int LvmInitFlag = LVM_FALSE;
+SessionContext GlobalSessionMemory[32];
+
+// NXP SW BassBoost UUID
+const effect_descriptor_t gBassBoostDescriptor = {
+ {0x0634f220, 0xddd4, 0x11db, 0xa0fc, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }},
+ {0x8631f300, 0x72e2, 0x11df, 0xb57e, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
+ EFFECT_API_VERSION,
+ (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST),
+ 0, // TODO
+ 1,
+ "Dynamic Bass Boost",
+ "NXP Software Ltd.",
+};
+
+// NXP SW Virtualizer UUID
+const effect_descriptor_t gVirtualizerDescriptor = {
+ {0x37cc2c00, 0xdddd, 0x11db, 0x8577, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // Virtualizer ID
+ {0x1d4033c0, 0x8557, 0x11df, 0x9f2d, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // NXP SW UUID gen july 01 2010
+ EFFECT_API_VERSION,
+ (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST),
+ 0, // TODO
+ 1,
+ "Virtualizer",
+ "NXP Software Ltd.",
+};
+
+// NXP SW Equalizer UUID
+const effect_descriptor_t gEqualizerDescriptor = {
+ {0x0bed4300, 0xddd6, 0x11db, 0x8f34, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // type
+ {0xce772f20, 0x847d, 0x11df, 0xbb17, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid Eq NXP
+ EFFECT_API_VERSION,
+ (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST),
+ 0, // TODO
+ 1,
+ "Equalizer",
+ "NXP Software Ltd.",
+};
+
+// NXP SW Volume UUID
+const effect_descriptor_t gVolumeDescriptor = {
+ {0x09e8ede0, 0xddde, 0x11db, 0xb4f6, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }},
+ //{0x8631f300, 0x72e2, 0x11df, 0xb57e, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }}, // uuid
+ {0x119341a0, 0x8469, 0x11df, 0x81f9, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b }}, //uuid VOL NXP
+ EFFECT_API_VERSION,
+ (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST),
+ 0, // TODO
+ 1,
+ "Volume",
+ "NXP Software Ltd.",
+};
+
+//--- local function prototypes
+void LvmGlobalBundle_init (void);
+int LvmBundle_init (EffectContext *pContext);
+int LvmEffect_enable (EffectContext *pContext);
+int LvmEffect_disable (EffectContext *pContext);
+void LvmEffect_free (EffectContext *pContext);
+int Effect_configure (EffectContext *pContext, effect_config_t *pConfig);
+int BassBoost_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue);
+int BassBoost_getParameter (EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue);
+int Virtualizer_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue);
+int Virtualizer_getParameter (EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue);
+int Equalizer_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue);
+int Equalizer_getParameter (EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue);
+int Volume_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue);
+int Volume_getParameter (EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Effect Library Interface Implementation */
+extern "C" int EffectQueryNumberEffects(uint32_t *pNumEffects){
+ LOGV("\n\tEffectQueryNumberEffects start");
+ *pNumEffects = 4;
+ LOGV("\tEffectQueryNumberEffects creating %d effects", *pNumEffects);
+ LOGV("\tEffectQueryNumberEffects end\n");
+ return 0;
+} /* end EffectQueryNumberEffects */
+
+
+extern "C" int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor){
+ LOGV("\n\tEffectQueryEffect start");
+ LOGV("\tEffectQueryEffect processing index %d", index);
+
+ if (pDescriptor == NULL){
+ LOGV("\tLVM_ERROR : EffectQueryEffect was passed NULL pointer");
+ return -EINVAL;
+ }
+ if (index > 3){
+ LOGV("\tLVM_ERROR : EffectQueryEffect index out of range %d", index);
+ return -ENOENT;
+ }
+ if(index == LVM_BASS_BOOST){
+ LOGV("\tEffectQueryEffect processing LVM_BASS_BOOST");
+ memcpy(pDescriptor, &gBassBoostDescriptor, sizeof(effect_descriptor_t));
+ }else if(index == LVM_VIRTUALIZER){
+ LOGV("\tEffectQueryEffect processing LVM_VIRTUALIZER");
+ memcpy(pDescriptor, &gVirtualizerDescriptor, sizeof(effect_descriptor_t));
+ } else if(index == LVM_EQUALIZER){
+ LOGV("\tEffectQueryEffect processing LVM_EQUALIZER");
+ memcpy(pDescriptor, &gEqualizerDescriptor, sizeof(effect_descriptor_t));
+ } else if(index == LVM_VOLUME){
+ LOGV("\tEffectQueryEffect processing LVM_VOLUME");
+ memcpy(pDescriptor, &gVolumeDescriptor, sizeof(effect_descriptor_t));
+ }
+ LOGV("\tEffectQueryEffect end\n");
+ return 0;
+} /* end EffectQueryEffect */
+
+
+extern "C" int EffectCreate(effect_uuid_t *uuid,
+ int32_t sessionId,
+ int32_t ioId,
+ effect_interface_t *pInterface){
+ int ret;
+ int i;
+ EffectContext *pContext = new EffectContext;
+
+ LOGV("\n\tEffectCreate start session %d", sessionId);
+
+ if (pInterface == NULL || uuid == NULL){
+ LOGV("\tLVM_ERROR : EffectCreate() called with NULL pointer");
+ return -EINVAL;
+ }
+
+ if((sessionId < 0)||(sessionId >= LVM_MAX_SESSIONS)){
+ LOGV("\tLVM_ERROR : EffectCreate sessionId is less than 0");
+ return -EINVAL;
+ }
+
+ if(LvmInitFlag == LVM_FALSE){
+ LvmInitFlag = LVM_TRUE;
+ LOGV("\tEffectCreate - Initializing all global memory");
+ LvmGlobalBundle_init();
+ }
+
+ // If this is the first create in this session
+ if(GlobalSessionMemory[sessionId].bBundledEffectsEnabled == LVM_FALSE){
+ LOGV("\tEffectCreate - This is the first effect in current session %d", sessionId);
+ LOGV("\tEffectCreate - Setting up Bundled Effects Instance for session %d", sessionId);
+ GlobalSessionMemory[sessionId].bBundledEffectsEnabled = LVM_TRUE;
+ GlobalSessionMemory[sessionId].pBundledContext = new BundledEffectContext;
+
+ pContext->pBundledContext = GlobalSessionMemory[sessionId].pBundledContext;
+ pContext->pBundledContext->SessionNo = sessionId;
+ pContext->pBundledContext->hInstance = NULL;
+ pContext->pBundledContext->bVolumeEnabled = LVM_FALSE;
+ pContext->pBundledContext->bEqualizerEnabled = LVM_FALSE;
+ pContext->pBundledContext->bBassEnabled = LVM_FALSE;
+ pContext->pBundledContext->bVirtualizerEnabled = LVM_FALSE;
+ pContext->pBundledContext->NumberEffectsEnabled = 0;
+ pContext->pBundledContext->NumberEffectsCalled = 0;
+
+ /* Saved strength is used to return the exact strength that was used in the set to the get
+ * because we map the original strength range of 0:1000 to 1:15, and this will avoid
+ * quantisation like effect when returning
+ */
+ pContext->pBundledContext->BassStrengthSaved = 0;
+ pContext->pBundledContext->VirtStrengthSaved = 0;
+ pContext->pBundledContext->CurPreset = PRESET_CUSTOM;
+ pContext->pBundledContext->levelSaved = 0;
+ pContext->pBundledContext->bMuteEnabled = LVM_FALSE;
+
+ LOGV("\tEffectCreate - Calling LvmBundle_init");
+ ret = LvmBundle_init(pContext);
+
+ if (ret < 0){
+ LOGV("\tLVM_ERROR : EffectCreate() Bundle init failed");
+ delete pContext->pBundledContext;
+ delete pContext;
+ return ret;
+ }
+ }
+ else{
+ pContext->pBundledContext = GlobalSessionMemory[sessionId].pBundledContext;
+ }
+
+ LOGV("\tEffectCreate - pBundledContext is %p", pContext->pBundledContext);
+
+ // Create each Effect
+ if (memcmp(uuid, &gBassBoostDescriptor.uuid, sizeof(effect_uuid_t)) == 0){
+ // Create Bass Boost
+ LOGV("\tEffectCreate - Effect to be created is LVM_BASS_BOOST");
+ GlobalSessionMemory[sessionId].bBassInstantiated = LVM_TRUE;
+
+ pContext->itfe = &gLvmEffectInterface;
+ pContext->EffectType = LVM_BASS_BOOST;
+ } else if (memcmp(uuid, &gVirtualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0){
+ // Create Virtualizer
+ LOGV("\tEffectCreate - Effect to be created is LVM_VIRTUALIZER");
+ GlobalSessionMemory[sessionId].bVirtualizerInstantiated = LVM_TRUE;
+
+ pContext->itfe = &gLvmEffectInterface;
+ pContext->EffectType = LVM_VIRTUALIZER;
+ } else if (memcmp(uuid, &gEqualizerDescriptor.uuid, sizeof(effect_uuid_t)) == 0){
+ // Create Equalizer
+ LOGV("\tEffectCreate - Effect to be created is LVM_EQUALIZER");
+ GlobalSessionMemory[sessionId].bEqualizerInstantiated = LVM_TRUE;
+
+ pContext->itfe = &gLvmEffectInterface;
+ pContext->EffectType = LVM_EQUALIZER;
+ } else if (memcmp(uuid, &gVolumeDescriptor.uuid, sizeof(effect_uuid_t)) == 0){
+ // Create Volume
+ LOGV("\tEffectCreate - Effect to be created is LVM_VOLUME");
+ GlobalSessionMemory[sessionId].bVolumeInstantiated = LVM_TRUE;
+
+ pContext->itfe = &gLvmEffectInterface;
+ pContext->EffectType = LVM_VOLUME;
+ }
+ else{
+ LOGV("\tLVM_ERROR : EffectCreate() invalid UUID");
+ return -EINVAL;
+ }
+
+ *pInterface = (effect_interface_t)pContext;
+ LOGV("\tEffectCreate end..\n\n");
+ return 0;
+} /* end EffectCreate */
+
+
+
+extern "C" int EffectRelease(effect_interface_t interface){
+ LOGV("\n\tEffectRelease start %p", interface);
+ EffectContext * pContext = (EffectContext *)interface;
+
+ if (pContext == NULL){
+ LOGV("\tLVM_ERROR : EffectRelease called with NULL pointer");
+ return -EINVAL;
+ }
+
+ // Clear the instantiated flag for the effect
+ if(pContext->EffectType == LVM_BASS_BOOST) {
+ LOGV("\tEffectRelease LVM_BASS_BOOST Clearing global intstantiated flag");
+ GlobalSessionMemory[pContext->pBundledContext->SessionNo].bBassInstantiated = LVM_FALSE;
+ } else if(pContext->EffectType == LVM_VIRTUALIZER) {
+ LOGV("\tEffectRelease LVM_VIRTUALIZER Clearing global intstantiated flag");
+ GlobalSessionMemory[pContext->pBundledContext->SessionNo].bVirtualizerInstantiated = LVM_FALSE;
+ } else if(pContext->EffectType == LVM_EQUALIZER) {
+ LOGV("\tEffectRelease LVM_EQUALIZER Clearing global intstantiated flag");
+ GlobalSessionMemory[pContext->pBundledContext->SessionNo].bEqualizerInstantiated = LVM_FALSE;
+ } else if(pContext->EffectType == LVM_VOLUME) {
+ LOGV("\tEffectRelease LVM_VOLUME Clearing global intstantiated flag");
+ GlobalSessionMemory[pContext->pBundledContext->SessionNo].bVolumeInstantiated = LVM_FALSE;
+ } else {
+ LOGV("\tLVM_ERROR : EffectRelease : Unsupported effect\n\n\n\n\n\n\n");
+ }
+
+ // if all effects are no longer instantiaed free the lvm memory and delete BundledEffectContext
+ if((GlobalSessionMemory[pContext->pBundledContext->SessionNo].bBassInstantiated == LVM_FALSE)&&
+ (GlobalSessionMemory[pContext->pBundledContext->SessionNo].bVolumeInstantiated == LVM_FALSE)&&
+ (GlobalSessionMemory[pContext->pBundledContext->SessionNo].bEqualizerInstantiated == LVM_FALSE)&&
+ (GlobalSessionMemory[pContext->pBundledContext->SessionNo].bVirtualizerInstantiated == LVM_FALSE))
+ {
+ LOGV("\tEffectRelease: All effects are no longer instantiated\n");
+ GlobalSessionMemory[pContext->pBundledContext->SessionNo].bBundledEffectsEnabled = LVM_FALSE;
+ GlobalSessionMemory[pContext->pBundledContext->SessionNo].pBundledContext = LVM_NULL;
+ LOGV("\tEffectRelease: Freeing LVM Bundle memory\n");
+ LvmEffect_free(pContext);
+ LOGV("\tEffectRelease: Deleting LVM Bundle context\n");
+ delete pContext->pBundledContext;
+ }
+
+ // free the effect context for current effect
+ delete pContext;
+
+ LOGV("\tEffectRelease end\n");
+ return 0;
+
+} /* end EffectRelease */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void LvmGlobalBundle_init(){
+ LOGV("\tLvmGlobalBundle_init start");
+ for(int i=0; i<LVM_MAX_SESSIONS; i++){
+ GlobalSessionMemory[i].bBundledEffectsEnabled = LVM_FALSE;
+ GlobalSessionMemory[i].bVolumeInstantiated = LVM_FALSE;
+ GlobalSessionMemory[i].bEqualizerInstantiated = LVM_FALSE;
+ GlobalSessionMemory[i].bBassInstantiated = LVM_FALSE;
+ GlobalSessionMemory[i].bVirtualizerInstantiated = LVM_FALSE;
+ GlobalSessionMemory[i].pBundledContext = LVM_NULL;
+ }
+ return;
+}
+//----------------------------------------------------------------------------
+// LvmBundle_init()
+//----------------------------------------------------------------------------
+// Purpose: Initialize engine with default configuration, creates instance
+// with all effects disabled.
+//
+// Inputs:
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int LvmBundle_init(EffectContext *pContext){
+ int status;
+
+ LOGV("\tLvmBundle_init start");
+
+ pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
+ pContext->config.inputCfg.channels = CHANNEL_STEREO;
+ pContext->config.inputCfg.format = SAMPLE_FORMAT_PCM_S15;
+ pContext->config.inputCfg.samplingRate = 44100;
+ pContext->config.inputCfg.bufferProvider.getBuffer = NULL;
+ pContext->config.inputCfg.bufferProvider.releaseBuffer = NULL;
+ pContext->config.inputCfg.bufferProvider.cookie = NULL;
+ pContext->config.inputCfg.mask = EFFECT_CONFIG_ALL;
+ pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
+ pContext->config.outputCfg.channels = CHANNEL_STEREO;
+ pContext->config.outputCfg.format = SAMPLE_FORMAT_PCM_S15;
+ pContext->config.outputCfg.samplingRate = 44100;
+ pContext->config.outputCfg.bufferProvider.getBuffer = NULL;
+ pContext->config.outputCfg.bufferProvider.releaseBuffer = NULL;
+ pContext->config.outputCfg.bufferProvider.cookie = NULL;
+ pContext->config.outputCfg.mask = EFFECT_CONFIG_ALL;
+
+ CHECK_ARG(pContext != NULL);
+
+ if (pContext->pBundledContext->hInstance != NULL){
+ LOGV("\tLvmBundle_init pContext->pBassBoost != NULL "
+ "-> Calling pContext->pBassBoost->free()");
+
+ LvmEffect_free(pContext);
+
+ LOGV("\tLvmBundle_init pContext->pBassBoost != NULL "
+ "-> Called pContext->pBassBoost->free()");
+ }
+
+ #ifdef LVM_BUNDLE
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+ LVM_ControlParams_t params; /* Control Parameters */
+ LVM_InstParams_t InstParams; /* Instance parameters */
+ LVM_EQNB_BandDef_t BandDefs[MAX_NUM_BANDS]; /* Equaliser band definitions */
+ LVM_HeadroomParams_t HeadroomParams; /* Headroom parameters */
+ LVM_HeadroomBandDef_t HeadroomBandDef[LVM_HEADROOM_MAX_NBANDS];
+ LVM_MemTab_t MemTab; /* Memory allocation table */
+ bool bMallocFailure = LVM_FALSE;
+
+ /* Set the capabilities */
+ InstParams.BufferMode = LVM_MANAGED_BUFFERS;
+ InstParams.MaxBlockSize = MAX_CALL_SIZE;
+ InstParams.EQNB_NumBands = MAX_NUM_BANDS;
+ InstParams.PSA_Included = LVM_PSA_ON;
+
+ /* Allocate memory, forcing alignment */
+ LvmStatus = LVM_GetMemoryTable(LVM_NULL,
+ &MemTab,
+ &InstParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetMemoryTable", "LvmBundle_init")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tCreateInstance Succesfully called LVM_GetMemoryTable\n");
+
+ /* Allocate memory */
+ for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){
+ if (MemTab.Region[i].Size != 0){
+ MemTab.Region[i].pBaseAddress = malloc(MemTab.Region[i].Size);
+
+ if (MemTab.Region[i].pBaseAddress == LVM_NULL){
+ LOGV("\tLVM_ERROR : CreateInstance Failed to allocate %ld bytes for region %u\n",
+ MemTab.Region[i].Size, i );
+ bMallocFailure = LVM_TRUE;
+ }else{
+ LOGV("\tCreateInstance allocated %ld bytes for region %u at %p\n",
+ MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
+ }
+ }
+ }
+
+ /* If one or more of the memory regions failed to allocate, free the regions that were
+ * succesfully allocated and return with an error
+ */
+ if(bMallocFailure == LVM_TRUE){
+ for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){
+ if (MemTab.Region[i].pBaseAddress == LVM_NULL){
+ LOGV("\tLVM_ERROR : CreateInstance Failed to allocate %ld bytes for region %u - Not freeing\n",
+ MemTab.Region[i].Size, i );
+ }else{
+ LOGV("\tLVM_ERROR : CreateInstance Failed: but allocated %ld bytes for region %u at %p- free\n",
+ MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
+ free(MemTab.Region[i].pBaseAddress);
+ }
+ }
+ return -EINVAL;
+ }
+ LOGV("\tCreateInstance Succesfully malloc'd memory\n");
+
+ /* Initialise */
+ pContext->pBundledContext->hInstance = LVM_NULL; /* Initialise to NULL */
+
+ LvmStatus = LVM_GetInstanceHandle(&pContext->pBundledContext->hInstance,/* Init sets the instance handle */
+ &MemTab,
+ &InstParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetInstanceHandle", "LvmBundle_init")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tCreateInstance Succesfully called LVM_GetInstanceHandle\n");
+
+ /* Set the initial process parameters */
+ /* General parameters */
+ params.OperatingMode = LVM_MODE_ON;
+ params.SampleRate = LVM_FS_44100;
+ params.SourceFormat = LVM_STEREO;
+ params.SpeakerType = LVM_HEADPHONES;
+
+ /* Concert Sound parameters */
+ params.VirtualizerOperatingMode = LVM_MODE_OFF;
+ params.VirtualizerType = LVM_CONCERTSOUND;
+ params.VirtualizerReverbLevel = 100;
+ params.CS_EffectLevel = LVM_CS_EFFECT_HIGH;
+
+ /* N-Band Equaliser parameters */
+ params.EQNB_OperatingMode = LVM_EQNB_OFF;
+ params.EQNB_NBands = FIVEBAND_NUMBANDS;
+ params.pEQNB_BandDefinition = &BandDefs[0];
+ for (int i=0; i<FIVEBAND_NUMBANDS; i++)
+ {
+ BandDefs[i].Frequency = EQNB_5BandPresetsFrequencies[i];
+ BandDefs[i].QFactor = EQNB_5BandPresetsQFactors[i];
+ BandDefs[i].Gain = EQNB_5BandNormalPresets[i];
+ }
+
+ /* Volume Control parameters */
+ params.VC_EffectLevel = 0;
+ params.VC_Balance = 0;
+
+ /* Treble Enhancement parameters */
+ params.TE_OperatingMode = LVM_TE_OFF;
+ params.TE_EffectLevel = 0;
+
+ /* PSA Control parameters */
+ params.PSA_Enable = LVM_PSA_OFF;
+ params.PSA_PeakDecayRate = (LVM_PSA_DecaySpeed_en)0;
+
+ /* Bass Enhancement parameters */
+ params.BE_OperatingMode = LVM_BE_OFF;
+ params.BE_EffectLevel = 0;
+ params.BE_CentreFreq = LVM_BE_CENTRE_90Hz;
+ params.BE_HPF = LVM_BE_HPF_ON;
+
+ /* PSA Control parameters */
+ params.PSA_Enable = LVM_PSA_OFF;
+ params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM;
+
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, /* Activate the initial settings */
+ ¶ms);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmBundle_init")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tCreateInstance Succesfully called LVM_SetControlParameters\n");
+
+ /* Set the headroom parameters */
+ HeadroomBandDef[0].Limit_Low = 20;
+ HeadroomBandDef[0].Limit_High = 4999;
+ HeadroomBandDef[0].Headroom_Offset = 3;
+ HeadroomBandDef[1].Limit_Low = 5000;
+ HeadroomBandDef[1].Limit_High = 24000;
+ HeadroomBandDef[1].Headroom_Offset = 4;
+ HeadroomParams.pHeadroomDefinition = &HeadroomBandDef[0];
+ HeadroomParams.Headroom_OperatingMode = LVM_HEADROOM_ON;
+ HeadroomParams.NHeadroomBands = 2;
+
+ LvmStatus = LVM_SetHeadroomParams(pContext->pBundledContext->hInstance,
+ &HeadroomParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetHeadroomParams", "LvmBundle_init")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tCreateInstance Succesfully called LVM_SetHeadroomParams\n");
+ #endif /* end LVM_BUNDLE */
+
+ LOGV("\tLvmBundle_init End");
+ return 0;
+} /* end LvmBundle_init */
+
+
+
+//----------------------------------------------------------------------------
+// LvmBundle_process()
+//----------------------------------------------------------------------------
+// Purpose:
+// Apply LVM Bundle effects
+//
+// Inputs:
+// pIn: pointer to stereo 16 bit input data
+// pOut: pointer to stereo 16 bit output data
+// frameCount: Frames to process
+// pContext: effect engine context
+// strength strength to be applied
+//
+// Outputs:
+// pOut: pointer to updated stereo 16 bit output data
+//
+//----------------------------------------------------------------------------
+
+int LvmBundle_process(LVM_INT16 *pIn,
+ LVM_INT16 *pOut,
+ int frameCount,
+ EffectContext *pContext){
+
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+
+
+ #ifdef LVM_BUNDLE
+ LVM_INT16 *pOutTmp;
+ if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE){
+ //LOGV("\tprocess: mBehavior is EFFECT_BUFFER_ACCESS_WRITE %d\n",
+ // pContext->config.outputCfg.accessMode);
+ pOutTmp = pOut;
+ }else if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE){
+ //LOGV("\tprocess: mBehavior is EFFECT_BUFFER_ACCESS_ACCUMULATE %d\n",
+ // pContext->config.outputCfg.accessMode);
+ pOutTmp = (LVM_INT16 *)malloc(frameCount * sizeof(LVM_INT16) * 2);
+ if(pOutTmp == NULL){
+ LOGV("\tLVM_ERROR : LvmBundle_process failed to allocate memory for EFFECT_BUFFER_ACCESS_ACCUMULATE mode");
+ return -EINVAL;
+ }
+ }else{
+ LOGV("LVM_ERROR : LvmBundle_process invalid access mode");
+ return -EINVAL;
+ }
+
+ /* Process the samples */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, /* Get the current settings */
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_enable")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+ LOGV("\t%d %d %d\n",ActiveParams.BE_OperatingMode, ActiveParams.VirtualizerOperatingMode, ActiveParams.EQNB_OperatingMode);
+
+
+ LvmStatus = LVM_Process(pContext->pBundledContext->hInstance, /* Instance handle */
+ pIn, /* Input buffer */
+ pOutTmp, /* Output buffer */
+ (LVM_UINT16)frameCount, /* Number of samples to read */
+ 0); /* Audo Time */
+ LVM_ERROR_CHECK(LvmStatus, "LVM_Process", "LvmBundle_process")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ if (pContext->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE){
+ for (int i=0; i<frameCount*2; i++){
+ pOut[i] += pOutTmp[i];
+ }
+ free(pOutTmp);
+ }
+ #else
+ memcpy(pOut, pIn, frameCount*sizeof(LVM_INT16)*2); // 2 is for stereo input
+ #endif /* end LVM_BUNDLE */
+ return 0;
+} /* end LvmBundle_process */
+
+//----------------------------------------------------------------------------
+// LvmEffect_enable()
+//----------------------------------------------------------------------------
+// Purpose: Enable the effect in the bundle
+//
+// Inputs:
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int LvmEffect_enable(EffectContext *pContext){
+ LOGV("\tLvmEffect_enable start");
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, /* Get the current settings */
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_enable")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+ LOGV("\tLvmEffect_enable Succesfully called LVM_GetControlParameters\n");
+
+ if(pContext->EffectType == LVM_BASS_BOOST) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_BASS_BOOST");
+ ActiveParams.BE_OperatingMode = LVM_BE_ON;
+ }
+ if(pContext->EffectType == LVM_VIRTUALIZER) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_VIRTUALIZER");
+ ActiveParams.VirtualizerOperatingMode = LVM_MODE_ON;
+ }
+ if(pContext->EffectType == LVM_EQUALIZER) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_EQUALIZER");
+ ActiveParams.EQNB_OperatingMode = LVM_EQNB_ON;
+ }
+ if(pContext->EffectType == LVM_VOLUME) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_VOLUME");
+ }
+
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_enable")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+ LOGV("\tLvmEffect_enable Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ LOGV("\tLvmEffect_enable end");
+ return 0;
+}
+
+
+//----------------------------------------------------------------------------
+// LvmEffect_disable()
+//----------------------------------------------------------------------------
+// Purpose: Disable the effect in the bundle
+//
+// Inputs:
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int LvmEffect_disable(EffectContext *pContext){
+ LOGV("\tLvmEffect_disable start");
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, /* Get the current settings */
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "LvmEffect_disable")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+ LOGV("\tLvmEffect_disable Succesfully called LVM_GetControlParameters\n");
+
+ if(pContext->EffectType == LVM_BASS_BOOST) {
+ LOGV("\tLvmEffect_disable : Disabling LVM_BASS_BOOST");
+ ActiveParams.BE_OperatingMode = LVM_BE_OFF;
+ }
+ if(pContext->EffectType == LVM_VIRTUALIZER) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_VIRTUALIZER");
+ ActiveParams.VirtualizerOperatingMode = LVM_MODE_OFF;
+ }
+ if(pContext->EffectType == LVM_EQUALIZER) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_EQUALIZER");
+ ActiveParams.EQNB_OperatingMode = LVM_EQNB_OFF;
+ }
+ if(pContext->EffectType == LVM_VOLUME) {
+ LOGV("\tLvmEffect_enable : Enabling LVM_VOLUME");
+ }
+
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "LvmEffect_disable")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+ LOGV("\tLvmEffect_enable Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ LOGV("\tLvmEffect_enable end");
+ return 0;
+}
+
+
+//----------------------------------------------------------------------------
+// LvmEffect_free()
+//----------------------------------------------------------------------------
+// Purpose: Free all memory associated with the Bundle.
+//
+// Inputs:
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+void LvmEffect_free(EffectContext *pContext){
+ #ifdef LVM_BUNDLE
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+ LVM_ControlParams_t params; /* Control Parameters */
+ LVM_MemTab_t MemTab;
+
+ /* Free the algorithm memory */
+ LvmStatus = LVM_GetMemoryTable(pContext->pBundledContext->hInstance,
+ &MemTab,
+ LVM_NULL);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetMemoryTable", "LvmEffect_free")
+
+ for (int i=0; i<LVM_NR_MEMORY_REGIONS; i++){
+ if (MemTab.Region[i].Size != 0){
+ if (MemTab.Region[i].pBaseAddress != NULL){
+ LOGV("\tfree() - START freeing %ld bytes for region %u at %p\n",
+ MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
+
+ free(MemTab.Region[i].pBaseAddress);
+
+ LOGV("\tfree() - END freeing %ld bytes for region %u at %p\n",
+ MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
+ }else{
+ LOGV("\tLVM_ERROR : free() - trying to free with NULL pointer %ld bytes "
+ "for region %u at %p ERROR\n",
+ MemTab.Region[i].Size, i, MemTab.Region[i].pBaseAddress);
+ }
+ }
+ }
+ #endif /* end LVM_BUNDLE */
+} /* end LvmEffect_free */
+
+//----------------------------------------------------------------------------
+// Effect_configure()
+//----------------------------------------------------------------------------
+// Purpose: Set input and output audio configuration.
+//
+// Inputs:
+// pContext: effect engine context
+// pConfig: pointer to effect_config_t structure holding input and output
+// configuration parameters
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int Effect_configure(EffectContext *pContext, effect_config_t *pConfig){
+ LOGV("\tEffect_configure start");
+
+ CHECK_ARG(pContext != NULL);
+ CHECK_ARG(pConfig != NULL);
+
+ CHECK_ARG(pConfig->inputCfg.samplingRate == pConfig->outputCfg.samplingRate);
+ CHECK_ARG(pConfig->inputCfg.channels == pConfig->outputCfg.channels);
+ CHECK_ARG(pConfig->inputCfg.format == pConfig->outputCfg.format);
+ CHECK_ARG(pConfig->inputCfg.channels == CHANNEL_STEREO);
+ CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE
+ || pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
+ CHECK_ARG(pConfig->inputCfg.format == SAMPLE_FORMAT_PCM_S15);
+
+ LOGV("\tEffect_configure calling memcpy");
+ memcpy(&pContext->config, pConfig, sizeof(effect_config_t));
+ LOGV("\tEffect_configure End");
+ return 0;
+} /* end Effect_configure */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//----------------------------------------------------------------------------
+// BassGetStrength()
+//----------------------------------------------------------------------------
+// Purpose:
+// get the effect strength currently being used, what is actually returned is the strengh that was
+// previously used in the set, this is because the app uses a strength in the range 0-1000 while
+// the bassboost uses 1-15, so to avoid a quantisation the original set value is used. However the
+// actual used value is checked to make sure it corresponds to the one being returned
+//
+// Inputs:
+// pContext: effect engine context
+//
+//----------------------------------------------------------------------------
+
+uint32_t BassGetStrength(EffectContext *pContext){
+ LOGV("\tBassGetStrength() (0-1000) -> %d\n", pContext->pBundledContext->BassStrengthSaved);
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, /* Get the current settings */
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "BassGetStrength")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tBassGetStrength Succesfully returned from LVM_GetControlParameters\n");
+
+ /* Check that the strength returned matches the strength that was set earlier */
+ if(ActiveParams.BE_EffectLevel != (LVM_INT16)((15*pContext->pBundledContext->BassStrengthSaved)/1000)){
+ LOGV("\tLVM_ERROR : BassGetStrength module strength does not match savedStrength %d %d\n",
+ ActiveParams.BE_EffectLevel, pContext->pBundledContext->BassStrengthSaved);
+ return -EINVAL;
+ }
+
+ LOGV("\tBassGetStrength() (0-15) -> %d\n", ActiveParams.BE_EffectLevel );
+ #endif /* end LVM_BUNDLE */
+
+ LOGV("\tBassGetStrength() (saved) -> %d\n", pContext->pBundledContext->BassStrengthSaved );
+ return pContext->pBundledContext->BassStrengthSaved;
+} /* end BassGetStrength */
+
+//----------------------------------------------------------------------------
+// BassSetStrength()
+//----------------------------------------------------------------------------
+// Purpose:
+// Apply the strength to the BassBosst. Must first be converted from the range 0-1000 to 1-15
+//
+// Inputs:
+// pContext: effect engine context
+// strength strength to be applied
+//
+//----------------------------------------------------------------------------
+
+void BassSetStrength(EffectContext *pContext, uint32_t strength){
+ LOGV("\tBassSetStrength(%d)", strength);
+
+ pContext->pBundledContext->BassStrengthSaved = (int)strength;
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+
+ /* Get the current settings */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance,
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "BassSetStrength")
+ LOGV("\tsetStrength Succesfully returned from LVM_GetControlParameters\n");
+
+ /* Bass Enhancement parameters */
+// ActiveParams.BE_OperatingMode = LVM_BE_ON;
+ ActiveParams.BE_EffectLevel = (LVM_INT16)((15*strength)/1000);
+ ActiveParams.BE_CentreFreq = LVM_BE_CENTRE_90Hz;
+
+ LOGV("\tBassSetStrength() (0-15) -> %d\n", ActiveParams.BE_EffectLevel );
+
+ /* Activate the initial settings */
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "BassSetStrength")
+ LOGV("\tBassSetStrength Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+} /* end BassSetStrength */
+
+//----------------------------------------------------------------------------
+// VirtualizerGetStrength()
+//----------------------------------------------------------------------------
+// Purpose:
+// get the effect strength currently being used, what is actually returned is the strengh that was
+// previously used in the set, this is because the app uses a strength in the range 0-1000 while
+// the Virtualizer uses 1-100, so to avoid a quantisation the original set value is used. However the
+// actual used value is checked to make sure it corresponds to the one being returned
+//
+// Inputs:
+// pContext: effect engine context
+//
+//----------------------------------------------------------------------------
+
+uint32_t VirtualizerGetStrength(EffectContext *pContext){
+ LOGV("\tVirtualizerGetStrength() (0-1000) -> %d\n", pContext->pBundledContext->VirtStrengthSaved );
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VirtualizerGetStrength")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tVirtualizerGetStrength Succesfully returned from LVM_GetControlParameters\n");
+ LOGV("\tVirtualizerGetStrength() (0-100) -> %d\n", ActiveParams.VirtualizerReverbLevel*10);
+ #endif /* end LVM_BUNDLE */
+
+ return ActiveParams.VirtualizerReverbLevel*10;
+} /* end getStrength */
+
+//----------------------------------------------------------------------------
+// VirtualizerSetStrength()
+//----------------------------------------------------------------------------
+// Purpose:
+// Apply the strength to the Virtualizer. Must first be converted from the range 0-1000 to 1-15
+//
+// Inputs:
+// pContext: effect engine context
+// strength strength to be applied
+//
+//----------------------------------------------------------------------------
+
+void VirtualizerSetStrength(EffectContext *pContext, uint32_t strength){
+ LOGV("\tVirtualizerSetStrength(%d)", strength);
+
+ pContext->pBundledContext->VirtStrengthSaved = (int)strength;
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+
+ /* Get the current settings */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance,&ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VirtualizerSetStrength")
+ LOGV("\tVirtualizerSetStrength Succesfully returned from LVM_GetControlParameters\n");
+
+ /* Virtualizer parameters */
+ ActiveParams.VirtualizerReverbLevel = (LVM_INT16)(strength/10);
+
+ LOGV("\tVirtualizerSetStrength() (0-1000) -> %d\n", strength );
+ LOGV("\tVirtualizerSetStrength() (0- 100) -> %d\n", ActiveParams.VirtualizerReverbLevel );
+
+ /* Activate the initial settings */
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VirtualizerSetStrength")
+ LOGV("\tVirtualizerSetStrength Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+} /* end setStrength */
+
+//----------------------------------------------------------------------------
+// EqualizerGetBandLevel()
+//----------------------------------------------------------------------------
+// Purpose: Retrieve the gain currently being used for the band passed in
+//
+// Inputs:
+// band: band number
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+int32_t EqualizerGetBandLevel(EffectContext *pContext, int32_t band){
+
+ int32_t Gain =0;
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+ LVM_EQNB_BandDef_t *BandDef;
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, /* Get the current settings */
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "getBandLevel")
+
+ BandDef = ActiveParams.pEQNB_BandDefinition;
+ Gain = (int32_t)BandDef[band].Gain*100; // Convert to millibels
+
+ LOGV("\tgetBandLevel() -> %d\n", Gain );
+ LOGV("\tgetBandLevel Succesfully returned from LVM_GetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ return Gain;
+}
+
+//----------------------------------------------------------------------------
+// EqualizerSetBandLevel()
+//----------------------------------------------------------------------------
+// Purpose:
+// Sets gain value for the given band.
+//
+// Inputs:
+// band: band number
+// Gain: Gain to be applied in millibels
+// pContext: effect engine context
+//
+// Outputs:
+//
+//---------------------------------------------------------------------------
+void EqualizerSetBandLevel(EffectContext *pContext, int band, int Gain){
+ int gainRounded;
+ if(Gain > 0){
+ gainRounded = (int)((Gain+50)/100);
+ }else{
+ gainRounded = (int)((Gain-50)/100);
+ }
+ LOGV("\tsetBandLevel(%d)->(%d)", Gain, gainRounded);
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+ LVM_EQNB_BandDef_t *BandDef;
+
+ /* Get the current settings */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "setBandLevel")
+ LOGV("\tsetBandLevel Succesfully returned from LVM_GetControlParameters\n");
+ LOGV("\tsetBandLevel() just Got -> %d\n", ActiveParams.pEQNB_BandDefinition[band].Gain);
+
+ /* Set local EQ parameters */
+ BandDef = ActiveParams.pEQNB_BandDefinition;
+ ActiveParams.pEQNB_BandDefinition[band].Gain = gainRounded;
+
+ /* Activate the initial settings */
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "setBandLevel")
+ LOGV("\tsetBandLevel() just Set -> %d\n", ActiveParams.pEQNB_BandDefinition[band].Gain);
+
+ /* Get the current settings to check they were applied ok, might not work as process not called*/
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "setBandLevel")
+ LOGV("\tLVM_ERROR : remove this test setBandLevel Succesfully returned from LVM_GetControlParameters\n");
+ LOGV("\tsetBandLevel() just Got -> %d\n", ActiveParams.pEQNB_BandDefinition[band].Gain);
+ LOGV("\tsetBandLevel Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ pContext->pBundledContext->CurPreset = PRESET_CUSTOM;
+ return;
+}
+//----------------------------------------------------------------------------
+// EqualizerGetCentreFrequency()
+//----------------------------------------------------------------------------
+// Purpose: Retrieve the frequency being used for the band passed in
+//
+// Inputs:
+// band: band number
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+int32_t EqualizerGetCentreFrequency(EffectContext *pContext, int32_t band){
+ int32_t Frequency =0;
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+ LVM_EQNB_BandDef_t *BandDef;
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, /* Get the current settings */
+ &ActiveParams);
+
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "getCentreFrequency")
+
+ BandDef = ActiveParams.pEQNB_BandDefinition;
+ Frequency = (int32_t)BandDef[band].Frequency*1000; // Convert to millibels
+
+ LOGV("\tgetCentreFrequency() -> %d\n", Frequency );
+ LOGV("\tgetCentreFrequency Succesfully returned from LVM_GetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ return Frequency;
+}
+
+//----------------------------------------------------------------------------
+// EqualizerGetBandFreqRange(
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Gets lower and upper boundaries of a band.
+// For the high shelf, the low bound is the band frequency and the high
+// bound is Nyquist.
+// For the peaking filters, they are the gain[dB]/2 points.
+//
+// Inputs:
+// band: band number
+// pContext: effect engine context
+//
+// Outputs:
+// pLow: lower band range
+// pLow: upper band range
+//----------------------------------------------------------------------------
+int32_t EqualizerGetBandFreqRange(EffectContext *pContext, int32_t band, uint32_t *pLow, uint32_t *pHi){
+ *pLow = bandFreqRange[band][0];
+ *pHi = bandFreqRange[band][1];
+ return 0;
+}
+
+//----------------------------------------------------------------------------
+// EqualizerGetBand(
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Returns the band with the maximum influence on a given frequency.
+// Result is unaffected by whether EQ is enabled or not, or by whether
+// changes have been committed or not.
+//
+// Inputs:
+// targetFreq The target frequency, in millihertz.
+// pContext: effect engine context
+//
+// Outputs:
+// pLow: lower band range
+// pLow: upper band range
+//----------------------------------------------------------------------------
+int32_t EqualizerGetBand(EffectContext *pContext, uint32_t targetFreq){
+ int band = 0;
+
+ if(targetFreq < bandFreqRange[0][0]){
+ return -EINVAL;
+ }else if(targetFreq == bandFreqRange[0][0]){
+ return 0;
+ }
+ for(int i=0; i<FIVEBAND_NUMBANDS;i++){
+ if((targetFreq > bandFreqRange[i][0])&&(targetFreq <= bandFreqRange[i][1])){
+ band = i;
+ }
+ }
+ return band;
+}
+
+//----------------------------------------------------------------------------
+// EqualizerGetPreset(
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Gets the currently set preset ID.
+// Will return PRESET_CUSTOM in case the EQ parameters have been modified
+// manually since a preset was set.
+//
+// Inputs:
+// pContext: effect engine context
+//
+//----------------------------------------------------------------------------
+int32_t EqualizerGetPreset(EffectContext *pContext){
+ return pContext->pBundledContext->CurPreset;
+}
+
+//----------------------------------------------------------------------------
+// EqualizerSetPreset(
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Sets the current preset by ID.
+// All the band parameters will be overridden.
+//
+// Inputs:
+// pContext: effect engine context
+// preset The preset ID.
+//
+//----------------------------------------------------------------------------
+void EqualizerSetPreset(EffectContext *pContext, int preset){
+
+ LOGV("\tsetPreset(%d)", preset);
+ pContext->pBundledContext->CurPreset = preset;
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+
+ /* Get the current settings */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "setPreset")
+ LOGV("\tsetPreset Succesfully returned from LVM_GetControlParameters\n");
+
+ //ActiveParams.pEQNB_BandDefinition = &BandDefs[0];
+ for (int i=0; i<FIVEBAND_NUMBANDS; i++)
+ {
+ ActiveParams.pEQNB_BandDefinition[i].Frequency = EQNB_5BandPresetsFrequencies[i];
+ ActiveParams.pEQNB_BandDefinition[i].QFactor = EQNB_5BandPresetsQFactors[i];
+ ActiveParams.pEQNB_BandDefinition[i].Gain
+ = EQNB_5BandNormalPresets[i + preset * FIVEBAND_NUMBANDS];
+ }
+ /* Activate the new settings */
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "setPreset")
+ LOGV("\tsetPreset Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ return;
+}
+int32_t EqualizerGetNumPresets(){
+ return 10;
+}
+
+//----------------------------------------------------------------------------
+// EqualizerGetPresetName(
+//----------------------------------------------------------------------------
+// Purpose:
+// Gets a human-readable name for a preset ID. Will return "Custom" if
+// PRESET_CUSTOM is passed.
+//
+// Inputs:
+// preset The preset ID. Must be less than number of presets.
+//
+//-------------------------------------------------------------------------
+const char * EqualizerGetPresetName(int32_t preset){
+ LOGV("\tEqualizerGetPresetName start(%d)", preset);
+ if (preset == PRESET_CUSTOM) {
+ return "Custom";
+ } else {
+ return gEqualizerPresets[preset].name;
+ }
+ LOGV("\tEqualizerGetPresetName end(%d)", preset);
+ return 0;
+}
+
+//----------------------------------------------------------------------------
+// VolumeSetVolumeLevel()
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Inputs:
+// pContext: effect engine context
+// level level to be applied
+//
+//----------------------------------------------------------------------------
+
+int VolumeSetVolumeLevel(EffectContext *pContext, int16_t level){
+ LOGV("\tVolumeSetVolumeLevel start(%d)", level);
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+
+ /* Get the current settings */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetVolumeLevel")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+ LOGV("\tVolumeSetVolumeLevel Succesfully returned from LVM_GetControlParameters\n");
+
+ /* Volume parameters */
+ ActiveParams.VC_EffectLevel = (LVM_INT16)(level/100);
+ LOGV("\tVolumeSetVolumeLevel() (-96dB -> 0dB) -> %d\n", ActiveParams.VC_EffectLevel );
+
+ /* Activate the initial settings */
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeSetVolumeLevel")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tVolumeSetVolumeLevel Succesfully called LVM_SetControlParameters\n");
+ LOGV("\tVolumeSetVolumeLevel end");
+ #endif /* end LVM_BUNDLE */
+ return 0;
+} /* end setVolumeLevel */
+
+//----------------------------------------------------------------------------
+// VolumeGetVolumeLevel()
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Inputs:
+// pContext: effect engine context
+//
+//----------------------------------------------------------------------------
+
+int VolumeGetVolumeLevel(EffectContext *pContext, int16_t *level){
+
+ LOGV("\tVolumeGetVolumeLevel start");
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus = LVM_SUCCESS; /* Function call status */
+
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeGetVolumeLevel")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tVolumeGetVolumeLevel() (-96dB -> 0dB) -> %d\n", ActiveParams.VC_EffectLevel );
+ LOGV("\tVolumeGetVolumeLevel Succesfully returned from LVM_GetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+
+ *level = ActiveParams.VC_EffectLevel*100; // Convert dB to millibels
+ LOGV("\tVolumeGetVolumeLevel end");
+ return 0;
+} /* end VolumeGetVolumeLevel */
+
+//----------------------------------------------------------------------------
+// VolumeSetMute()
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Inputs:
+// pContext: effect engine context
+// mute: enable/disable flag
+//
+//----------------------------------------------------------------------------
+
+int32_t VolumeSetMute(EffectContext *pContext, uint32_t mute){
+ LOGV("\tVolumeSetMute start()");
+
+ pContext->pBundledContext->bMuteEnabled = mute;
+
+ #ifdef LVM_BUNDLE
+ LVM_ControlParams_t ActiveParams; /* Current control Parameters */
+ LVM_ReturnStatus_en LvmStatus=LVM_SUCCESS; /* Function call status */
+
+ /* Get the current settings */
+ LvmStatus = LVM_GetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_GetControlParameters", "VolumeSetMute")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tVolumeSetMute Succesfully returned from LVM_GetControlParameters\n");
+ LOGV("\tVolumeSetMute() to %d, level was %d\n", mute, ActiveParams.BE_EffectLevel );
+
+ /* Set appropriate volume level */
+ if(pContext->pBundledContext->bMuteEnabled == LVM_TRUE){
+ pContext->pBundledContext->levelSaved = ActiveParams.VC_EffectLevel;
+ ActiveParams.VC_EffectLevel = -96;
+ }else{
+ ActiveParams.VC_EffectLevel = pContext->pBundledContext->levelSaved;
+ }
+
+ /* Activate the initial settings */
+ LvmStatus = LVM_SetControlParameters(pContext->pBundledContext->hInstance, &ActiveParams);
+ LVM_ERROR_CHECK(LvmStatus, "LVM_SetControlParameters", "VolumeSetMute")
+ if(LvmStatus != LVM_SUCCESS) return -EINVAL;
+
+ LOGV("\tVolumeSetMute Succesfully called LVM_SetControlParameters\n");
+ #endif /* end LVM_BUNDLE */
+ LOGV("\tVolumeSetMute start()");
+ return 0;
+} /* end setMute */
+
+//----------------------------------------------------------------------------
+// VolumeSetMute()
+//----------------------------------------------------------------------------
+// Purpose:
+//
+// Inputs:
+// pContext: effect engine context
+//
+// Ourputs:
+// mute: enable/disable flag
+//----------------------------------------------------------------------------
+
+int32_t VolumeGetMute(EffectContext *pContext, uint32_t *mute){
+ LOGV("\tVolumeGetMute start");
+ if((pContext->pBundledContext->bMuteEnabled == LVM_FALSE)||(pContext->pBundledContext->bMuteEnabled == LVM_TRUE)){
+ *mute = pContext->pBundledContext->bMuteEnabled;
+ return 0;
+ }else{
+ LOGV("\tLVM_ERROR : VolumeGetMute read an invalid value from context %d", pContext->pBundledContext->bMuteEnabled);
+ return -EINVAL;
+ }
+ LOGV("\tVolumeGetMute start");
+} /* end getMute */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//----------------------------------------------------------------------------
+// BassBoost_getParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Get a BassBoost parameter
+//
+// Inputs:
+// pBassBoost - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to variable to hold retrieved value
+// pValueSize - pointer to value size: maximum size as input
+//
+// Outputs:
+// *pValue updated with parameter value
+// *pValueSize updated with actual value size
+//
+//
+// Side Effects:
+//
+//----------------------------------------------------------------------------
+
+int BassBoost_getParameter(EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue){
+ int status = 0;
+ int32_t param = *pParam++;
+ int32_t param2;
+ char *name;
+
+ LOGV("\tBassBoost_getParameter start");
+
+ switch (param){
+ case BASSBOOST_PARAM_STRENGTH_SUP:
+ //if (*pValueSize != sizeof(uint32_t)){
+ // LOGV("\tLVM_ERROR : BassBoost_getParameter() invalid pValueSize1 %d", *pValueSize);
+ // return -EINVAL;
+ //}
+ //*pValueSize = sizeof(uint32_t);
+ //break;
+ case BASSBOOST_PARAM_STRENGTH:
+ if (*pValueSize != sizeof(int16_t)){
+ LOGV("\tLVM_ERROR : BassBoost_getParameter() invalid pValueSize2 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int16_t);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : BassBoost_getParameter() invalid param %d", param);
+ return -EINVAL;
+ }
+
+ switch (param){
+ case BASSBOOST_PARAM_STRENGTH_SUP:
+ *(uint32_t *)pValue = 1;
+
+ LOGV("\tBassBoost_getParameter() BASSBOOST_PARAM_STRENGTH_SUP Value is %d",
+ *(uint32_t *)pValue);
+ break;
+
+ case BASSBOOST_PARAM_STRENGTH:
+ *(int16_t *)pValue = BassGetStrength(pContext);
+
+ LOGV("\tBassBoost_getParameter() BASSBOOST_PARAM_STRENGTH Value is %d",
+ *(int16_t *)pValue);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : BassBoost_getParameter() invalid param %d", param);
+ status = -EINVAL;
+ break;
+ }
+
+ LOGV("\tBassBoost_getParameter end");
+ return status;
+} /* end BassBoost_getParameter */
+
+
+//----------------------------------------------------------------------------
+// BassBoost_setParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Set a BassBoost parameter
+//
+// Inputs:
+// pBassBoost - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to value
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int BassBoost_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue){
+ int status = 0;
+ int16_t strength;
+
+ LOGV("\tBassBoost_setParameter start");
+
+ switch (*pParam){
+ case BASSBOOST_PARAM_STRENGTH:
+ strength = *(int16_t *)pValue;
+ LOGV("\tBassBoost_setParameter() BASSBOOST_PARAM_STRENGTH value is %d", strength);
+ LOGV("\tBassBoost_setParameter() Calling pBassBoost->BassSetStrength");
+ BassSetStrength(pContext, (int32_t)strength);
+ LOGV("\tBassBoost_setParameter() Called pBassBoost->BassSetStrength");
+ break;
+ default:
+ LOGV("\tLVM_ERROR : BassBoost_setParameter() invalid param %d", *pParam);
+ break;
+ }
+
+ LOGV("\tBassBoost_setParameter end");
+ return status;
+} /* end BassBoost_setParameter */
+
+//----------------------------------------------------------------------------
+// Virtualizer_getParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Get a Virtualizer parameter
+//
+// Inputs:
+// pVirtualizer - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to variable to hold retrieved value
+// pValueSize - pointer to value size: maximum size as input
+//
+// Outputs:
+// *pValue updated with parameter value
+// *pValueSize updated with actual value size
+//
+//
+// Side Effects:
+//
+//----------------------------------------------------------------------------
+
+int Virtualizer_getParameter(EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue){
+ int status = 0;
+ int32_t param = *pParam++;
+ int32_t param2;
+ char *name;
+
+ LOGV("\tVirtualizer_getParameter start");
+
+ switch (param){
+ case VIRTUALIZER_PARAM_STRENGTH_SUP:
+ //if (*pValueSize != sizeof(uint32_t)){
+ // LOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize1 %d", *pValueSize);
+ // return -EINVAL;
+ //}
+ //*pValueSize = sizeof(uint32_t);
+ //break;
+ case VIRTUALIZER_PARAM_STRENGTH:
+ if (*pValueSize != sizeof(int16_t)){
+ LOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid pValueSize2 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int16_t);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid param %d", param);
+ return -EINVAL;
+ }
+
+ switch (param){
+ case VIRTUALIZER_PARAM_STRENGTH_SUP:
+ *(uint32_t *)pValue = 1;
+
+ LOGV("\tVirtualizer_getParameter() VIRTUALIZER_PARAM_STRENGTH_SUP Value is %d",
+ *(uint32_t *)pValue);
+ break;
+
+ case VIRTUALIZER_PARAM_STRENGTH:
+ *(int16_t *)pValue = VirtualizerGetStrength(pContext);
+
+ LOGV("\tVirtualizer_getParameter() VIRTUALIZER_PARAM_STRENGTH Value is %d",
+ *(int16_t *)pValue);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Virtualizer_getParameter() invalid param %d", param);
+ status = -EINVAL;
+ break;
+ }
+
+ LOGV("\tVirtualizer_getParameter end");
+ return status;
+} /* end Virtualizer_getParameter */
+
+
+//----------------------------------------------------------------------------
+// Virtualizer_setParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Set a Virtualizer parameter
+//
+// Inputs:
+// pVirtualizer - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to value
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int Virtualizer_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue){
+ int status = 0;
+ int16_t strength;
+
+ LOGV("\tVirtualizer_setParameter start");
+
+ switch (*pParam){
+ case VIRTUALIZER_PARAM_STRENGTH:
+ strength = *(int16_t *)pValue;
+ LOGV("\tVirtualizer_setParameter() VIRTUALIZER_PARAM_STRENGTH value is %d", strength);
+ LOGV("\tVirtualizer_setParameter() Calling pVirtualizer->setStrength");
+ VirtualizerSetStrength(pContext, (int32_t)strength);
+ LOGV("\tVirtualizer_setParameter() Called pVirtualizer->setStrength");
+ break;
+ default:
+ LOGV("\tLVM_ERROR : Virtualizer_setParameter() invalid param %d", *pParam);
+ break;
+ }
+
+ LOGV("\tVirtualizer_setParameter end");
+ return status;
+} /* end Virtualizer_setParameter */
+
+//----------------------------------------------------------------------------
+// Equalizer_getParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Get a Equalizer parameter
+//
+// Inputs:
+// pEqualizer - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to variable to hold retrieved value
+// pValueSize - pointer to value size: maximum size as input
+//
+// Outputs:
+// *pValue updated with parameter value
+// *pValueSize updated with actual value size
+//
+//
+// Side Effects:
+//
+//----------------------------------------------------------------------------
+int Equalizer_getParameter(EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue){
+ int status = 0;
+ int bMute = 0;
+ int32_t param = *pParam++;
+ int32_t param2;
+ char *name;
+
+ LOGV("\tEqualizer_getParameter start");
+
+ switch (param) {
+ case EQ_PARAM_NUM_BANDS:
+ case EQ_PARAM_CUR_PRESET:
+ case EQ_PARAM_GET_NUM_OF_PRESETS:
+ if (*pValueSize < sizeof(int16_t)) {
+ LOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 1 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int16_t);
+ break;
+
+ case EQ_PARAM_LEVEL_RANGE:
+ case EQ_PARAM_BAND_FREQ_RANGE:
+ if (*pValueSize < 2 * sizeof(int32_t)) {
+ LOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 2 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = 2 * sizeof(int32_t);
+ break;
+ case EQ_PARAM_BAND_LEVEL:
+ case EQ_PARAM_GET_BAND:
+ case EQ_PARAM_CENTER_FREQ:
+ if (*pValueSize < sizeof(int32_t)) {
+ LOGV("\tLVM_ERROR : Equalizer_getParameter() invalid pValueSize 1 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int32_t);
+ break;
+
+ case EQ_PARAM_GET_PRESET_NAME:
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Equalizer_getParameter unknown param %d", param);
+ return -EINVAL;
+ }
+
+ switch (param) {
+ case EQ_PARAM_NUM_BANDS:
+ *(int16_t *)pValue = FIVEBAND_NUMBANDS;
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_NUM_BANDS %d", *(int16_t *)pValue);
+ break;
+
+ case EQ_PARAM_LEVEL_RANGE:
+ *(int32_t *)pValue = -1500;
+ *((int32_t *)pValue + 1) = 1500;
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_LEVEL_RANGE min %d, max %d", *(int32_t *)pValue, *((int32_t *)pValue + 1));
+ break;
+
+ case EQ_PARAM_BAND_LEVEL:
+ param2 = *pParam;
+ if (param2 >= FIVEBAND_NUMBANDS) {
+ status = -EINVAL;
+ break;
+ }
+ *(int32_t *)pValue = EqualizerGetBandLevel(pContext, param2);
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", param2, *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_CENTER_FREQ:
+ param2 = *pParam;
+ if (param2 >= FIVEBAND_NUMBANDS) {
+ status = -EINVAL;
+ break;
+ }
+ *(int32_t *)pValue = EqualizerGetCentreFrequency(pContext, param2);
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_CENTER_FREQ band %d, frequency %d", param2, *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_BAND_FREQ_RANGE:
+ param2 = *pParam;
+ if (param2 >= FIVEBAND_NUMBANDS) {
+ status = -EINVAL;
+ break;
+ }
+ EqualizerGetBandFreqRange(pContext, param2, (uint32_t *)pValue, ((uint32_t *)pValue + 1));
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_BAND_FREQ_RANGE band %d, min %d, max %d", param2, *(int32_t *)pValue, *((int32_t *)pValue + 1));
+ break;
+
+ case EQ_PARAM_GET_BAND:
+ param2 = *pParam;
+ *(int32_t *)pValue = EqualizerGetBand(pContext, param2);
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_GET_BAND frequency %d, band %d", param2, *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_CUR_PRESET:
+ *(int16_t *)pValue = EqualizerGetPreset(pContext);
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_CUR_PRESET %d", *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_GET_NUM_OF_PRESETS:
+ *(int16_t *)pValue = EqualizerGetNumPresets();
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_GET_NUM_OF_PRESETS %d", *(int16_t *)pValue);
+ break;
+
+ case EQ_PARAM_GET_PRESET_NAME:
+ param2 = *pParam;
+ if (param2 >= EqualizerGetNumPresets()) {
+ //if (param2 >= 20) { // AGO FIX
+ status = -EINVAL;
+ break;
+ }
+ name = (char *)pValue;
+ strncpy(name, EqualizerGetPresetName(param2), *pValueSize - 1);
+ name[*pValueSize - 1] = 0;
+ *pValueSize = strlen(name) + 1;
+ LOGV("\tEqualizer_getParameter() EQ_PARAM_GET_PRESET_NAME preset %d, name %s len %d", param2, gEqualizerPresets[param2].name, *pValueSize);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Equalizer_getParameter() invalid param %d", param);
+ status = -EINVAL;
+ break;
+ }
+
+ LOGV("\tEqualizer_getParameter end");
+ return status;
+} /* end Equalizer_getParameter */
+
+//----------------------------------------------------------------------------
+// Equalizer_setParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Set a Equalizer parameter
+//
+// Inputs:
+// pEqualizer - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to value
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+int Equalizer_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue){
+ int status = 0;
+ int32_t preset;
+ int32_t band;
+ int32_t level;
+ int32_t param = *pParam++;
+
+ LOGV("\tEqualizer_setParameter start");
+ switch (param) {
+ case EQ_PARAM_CUR_PRESET:
+ preset = *(int16_t *)pValue;
+
+ LOGV("\tEqualizer_setParameter() EQ_PARAM_CUR_PRESET %d", preset);
+ if ((preset >= EqualizerGetNumPresets())||(preset < 0)) {
+ status = -EINVAL;
+ break;
+ }
+ EqualizerSetPreset(pContext, preset);
+ break;
+ case EQ_PARAM_BAND_LEVEL:
+ band = *pParam;
+ level = *(int32_t *)pValue;
+ LOGV("\tEqualizer_setParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", band, level);
+ if (band >= FIVEBAND_NUMBANDS) {
+ status = -EINVAL;
+ break;
+ }
+ EqualizerSetBandLevel(pContext, band, level);
+ break;
+ default:
+ LOGV("\tLVM_ERROR : setParameter() invalid param %d", param);
+ break;
+ }
+
+ LOGV("\tEqualizer_setParameter end");
+ return status;
+} /* end Equalizer_setParameter */
+
+//----------------------------------------------------------------------------
+// Volume_getParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Get a Volume parameter
+//
+// Inputs:
+// pVolume - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to variable to hold retrieved value
+// pValueSize - pointer to value size: maximum size as input
+//
+// Outputs:
+// *pValue updated with parameter value
+// *pValueSize updated with actual value size
+//
+//
+// Side Effects:
+//
+//----------------------------------------------------------------------------
+
+int Volume_getParameter(EffectContext *pContext,
+ int32_t *pParam,
+ size_t *pValueSize,
+ void *pValue){
+ int status = 0;
+ int bMute = 0;
+ int32_t param = *pParam++;
+ int32_t param2;
+ char *name;
+
+ LOGV("\tVolume_getParameter start");
+
+ switch (param){
+ case VOLUME_PARAM_LEVEL:
+ case VOLUME_PARAM_MAXLEVEL:
+ case VOLUME_PARAM_STEREOPOSITION:
+ if (*pValueSize < sizeof(int16_t)){
+ LOGV("\tLVM_ERROR : Volume_getParameter() invalid pValueSize 1 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int16_t);
+ break;
+
+ case VOLUME_PARAM_MUTE:
+ case VOLUME_PARAM_ENABLESTEREOPOSITION:
+ if (*pValueSize < sizeof(int32_t)){
+ LOGV("\tLVM_ERROR : Volume_getParameter() invalid pValueSize 2 %d", *pValueSize);
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int32_t);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : EVolume_getParameter unknown param %d", param);
+ return -EINVAL;
+ }
+
+ switch (param){
+ case VOLUME_PARAM_LEVEL:
+ status = VolumeGetVolumeLevel(pContext, (int16_t *)(pValue));
+ LOGV("\tVolume_getParameter() VOLUME_PARAM_LEVEL Value is %d",
+ *(int16_t *)pValue);
+ break;
+
+ case VOLUME_PARAM_MAXLEVEL:
+ *(int16_t *)pValue = 0;
+ LOGV("\tVolume_getParameter() VOLUME_PARAM_MAXLEVEL Value is %d",
+ *(int16_t *)pValue);
+ break;
+
+ case VOLUME_PARAM_STEREOPOSITION:
+ *(int16_t *)pValue = 0;
+ LOGV("\tVolume_getParameter() VOLUME_PARAM_STEREOPOSITION Value is %d",
+ *(int16_t *)pValue);
+ break;
+
+ case VOLUME_PARAM_MUTE:
+ status = VolumeGetMute(pContext, (uint32_t *)pValue);
+ LOGV("\tVolume_getParameter() VOLUME_PARAM_MUTE Value is %d",
+ *(uint32_t *)pValue);
+ break;
+
+ case VOLUME_PARAM_ENABLESTEREOPOSITION:
+ *(int32_t *)pValue = 0;
+ LOGV("\tVolume_getParameter() VOLUME_PARAM_ENABLESTEREOPOSITION Value is %d",
+ *(uint32_t *)pValue);
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Volume_getParameter() invalid param %d", param);
+ status = -EINVAL;
+ break;
+ }
+
+ LOGV("\tVolume_getParameter end");
+ return status;
+} /* end Volume_getParameter */
+
+
+//----------------------------------------------------------------------------
+// Volume_setParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Set a Volume parameter
+//
+// Inputs:
+// pVolume - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to value
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int Volume_setParameter (EffectContext *pContext, int32_t *pParam, void *pValue){
+ int status = 0;
+ int16_t level;
+ uint32_t mute;
+
+ LOGV("\tVolume_setParameter start");
+
+ switch (*pParam){
+ case VOLUME_PARAM_LEVEL:
+ level = *(int16_t *)pValue;
+ LOGV("\tVolume_setParameter() VOLUME_PARAM_LEVEL value is %d", level);
+ LOGV("\tVolume_setParameter() Calling pVolume->setVolumeLevel");
+ status = VolumeSetVolumeLevel(pContext, (int16_t)level);
+ LOGV("\tVolume_setParameter() Called pVolume->setVolumeLevel");
+ break;
+
+ case VOLUME_PARAM_MUTE:
+ mute = *(uint32_t *)pValue;
+ LOGV("\tVolume_setParameter() Calling pVolume->setMute, mute is %d", mute);
+ LOGV("\tVolume_setParameter() Calling pVolume->setMute");
+ status = VolumeSetMute(pContext, mute);
+ LOGV("\tVolume_setParameter() Called pVolume->setMute");
+ break;
+
+ case VOLUME_PARAM_ENABLESTEREOPOSITION:
+ LOGV("\tVolume_setParameter() VOLUME_PARAM_ENABLESTEREOPOSITION called");
+ break;
+
+ case VOLUME_PARAM_STEREOPOSITION:
+ LOGV("\tVolume_setParameter() VOLUME_PARAM_STEREOPOSITION called");
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Volume_setParameter() invalid param %d", *pParam);
+ break;
+ }
+
+ LOGV("\tVolume_setParameter end");
+ return status;
+} /* end Volume_setParameter */
+} // namespace
+} // namespace
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Effect Control Interface Implementation: Process */
+extern "C" int Effect_process(effect_interface_t self,
+ audio_buffer_t *inBuffer,
+ audio_buffer_t *outBuffer){
+ EffectContext * pContext = (EffectContext *) self;
+ int status = 0;
+
+ //LOGV("\tIn Effect_process");
+
+ if (pContext == NULL){
+ LOGV("\tLVM_ERROR : Effect_process() ERROR pContext == NULL");
+ return -EINVAL;
+ }
+ if (inBuffer == NULL || inBuffer->raw == NULL ||
+ outBuffer == NULL || outBuffer->raw == NULL ||
+ inBuffer->frameCount != outBuffer->frameCount){
+ LOGV("\tLVM_ERROR : Effect_process() ERROR NULL INPUT POINTER OR FRAME COUNT IS WRONG");
+ return -EINVAL;
+ }
+
+ if ((pContext->pBundledContext->bBassEnabled == LVM_FALSE)&&(pContext->EffectType == LVM_BASS_BOOST)){
+ LOGV("\tLVM_ERROR : Effect_process() ERROR LVM_BASS_BOOST Effect is not enabled");
+ return -ENODATA;
+ }
+ if ((pContext->pBundledContext->bVolumeEnabled == LVM_FALSE)&&(pContext->EffectType == LVM_VOLUME)){
+ LOGV("\tLVM_ERROR : Effect_process() ERROR LVM_VOLUME Effect is not enabled");
+ return -ENODATA;
+ }
+ if ((pContext->pBundledContext->bEqualizerEnabled == LVM_FALSE)&&(pContext->EffectType == LVM_EQUALIZER)){
+ LOGV("\tLVM_ERROR : Effect_process() ERROR LVM_EQUALIZER Effect is not enabled");
+ return -ENODATA;
+ }
+ if ((pContext->pBundledContext->bVirtualizerEnabled == LVM_FALSE)&&(pContext->EffectType == LVM_VIRTUALIZER)){
+ LOGV("\tLVM_ERROR : Effect_process() ERROR LVM_VIRTUALIZER Effect is not enabled");
+ return -ENODATA;
+ }
+
+ pContext->pBundledContext->NumberEffectsCalled++;
+
+ if(pContext->pBundledContext->NumberEffectsCalled == pContext->pBundledContext->NumberEffectsEnabled){
+ LOGV("\tEffect_process() Calling process with %d frames, %d effects enabled, %d called: Effect %d", outBuffer->frameCount, pContext->pBundledContext->NumberEffectsEnabled, pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType);
+ pContext->pBundledContext->NumberEffectsCalled = 0;
+ /* Process all the available frames, block processing is handled internalLY by the LVM bundle */
+ status = android::LvmBundle_process( (LVM_INT16 *)inBuffer->raw,
+ (LVM_INT16 *)outBuffer->raw,
+ outBuffer->frameCount,
+ pContext);
+ //LOGV("\tEffect_process() Called process with %d frames, %d effects enabled, %d called: Effect %d", outBuffer->frameCount, pContext->pBundledContext->NumberEffectsEnabled, pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType);
+ }else{
+ LOGV("\tEffect_process() Not Calling process with %d frames, %d effects enabled, %d called: Effect %d", outBuffer->frameCount, pContext->pBundledContext->NumberEffectsEnabled, pContext->pBundledContext->NumberEffectsCalled, pContext->EffectType);
+ memcpy(outBuffer->raw, inBuffer->raw, outBuffer->frameCount*sizeof(LVM_INT16)*2); // 2 is for stereo input
+ }
+ return status;
+} /* end Effect_process */
+
+/* Effect Control Interface Implementation: Command */
+extern "C" int Effect_command(effect_interface_t self,
+ int cmdCode,
+ int cmdSize,
+ void *pCmdData,
+ int *replySize,
+ void *pReplyData){
+ EffectContext * pContext = (EffectContext *) self;
+ int retsize;
+ int status = 0;
+
+ LOGV("\t\nEffect_command start");
+
+ if(pContext->EffectType == LVM_BASS_BOOST){
+ LOGV("\tEffect_command setting command for LVM_BASS_BOOST");
+ }
+ if(pContext->EffectType == LVM_VIRTUALIZER){
+ LOGV("\tEffect_command setting command for LVM_VIRTUALIZER");
+ }
+ if(pContext->EffectType == LVM_EQUALIZER){
+ LOGV("\tEffect_command setting command for LVM_EQUALIZER");
+ }
+ if(pContext->EffectType == LVM_VOLUME){
+ LOGV("\tEffect_command setting command for LVM_VOLUME");
+ }
+
+ if (pContext == NULL){
+ LOGV("\tLVM_ERROR : Effect_command ERROR pContext == NULL");
+ return -EINVAL;
+ }
+
+ LOGV("\tEffect_command INPUTS are: command %d cmdSize %d",cmdCode, cmdSize);
+
+ // Incase we disable an effect, next time process is called the number of effect called could be greater
+ pContext->pBundledContext->NumberEffectsCalled = 0;
+
+ LOGV("\tEffect_command NumberEffectsCalled = %d, NumberEffectsEnabled = %d", pContext->pBundledContext->NumberEffectsCalled, pContext->pBundledContext->NumberEffectsEnabled);
+
+ switch (cmdCode){
+ case EFFECT_CMD_INIT:
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT start");
+ if(pContext->EffectType == LVM_BASS_BOOST){
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_BASS_BOOST");
+
+ if (pReplyData == NULL || *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: "
+ "EFFECT_CMD_INIT: ERROR");
+ return -EINVAL;
+ }
+
+ android::BassSetStrength(pContext, 0);
+ }
+ if(pContext->EffectType == LVM_VIRTUALIZER){
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_VIRTUALIZER");
+
+ if (pReplyData == NULL || *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: "
+ "EFFECT_CMD_INIT: ERROR");
+ return -EINVAL;
+ }
+
+ android::VirtualizerSetStrength(pContext, 0);
+ }
+ if(pContext->EffectType == LVM_EQUALIZER){
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_INIT for LVM_EQUALIZER");
+
+ if (pReplyData == NULL || *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: "
+ "EFFECT_CMD_INIT: ERROR");
+ return -EINVAL;
+ }
+
+ android::EqualizerSetPreset(pContext, 0);
+ }
+ if(pContext->EffectType == LVM_VOLUME){
+ LOGV("\tEffect_command cmdCode Case: "
+ "EFFECT_CMD_INIT start");
+
+ if (pReplyData == NULL || *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : Volume_command cmdCode Case: "
+ "EFFECT_CMD_INIT: ERROR");
+ return -EINVAL;
+ }
+
+ status = android::VolumeSetVolumeLevel(pContext, 0);
+ if(status == -EINVAL){
+ return -EINVAL;
+ }
+ }
+ break;
+
+ case EFFECT_CMD_CONFIGURE:
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_CONFIGURE start");
+ if (pCmdData == NULL||
+ cmdSize != sizeof(effect_config_t)||
+ pReplyData == NULL||
+ *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : Effect_command cmdCode Case: "
+ "EFFECT_CMD_CONFIGURE: ERROR");
+ return -EINVAL;
+ }
+ *(int *) pReplyData = android::Effect_configure(pContext, (effect_config_t *) pCmdData);
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_CONFIGURE end");
+ break;
+
+ case EFFECT_CMD_RESET:
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_RESET start");
+ android::Effect_configure(pContext, &pContext->config);
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_RESET end");
+ break;
+
+ case EFFECT_CMD_GET_PARAM:{
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_GET_PARAM start");
+
+ if(pContext->EffectType == LVM_BASS_BOOST){
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL ||*replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))){
+ LOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: "
+ "EFFECT_CMD_GET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *)pCmdData;
+
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
+
+ p = (effect_param_t *)pReplyData;
+
+ int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+
+ p->status = android::BassBoost_getParameter(pContext,
+ (int32_t *)p->data,
+ (size_t *)&p->vsize,
+ p->data + voffset);
+
+ *replySize = sizeof(effect_param_t) + voffset + p->vsize;
+
+ LOGV("\tBassBoost_command EFFECT_CMD_GET_PARAM "
+ "*pCmdData %d, *replySize %d, *pReplyData %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset));
+ }
+
+ if(pContext->EffectType == LVM_VIRTUALIZER){
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL ||*replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))){
+ LOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: "
+ "EFFECT_CMD_GET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *)pCmdData;
+
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
+
+ p = (effect_param_t *)pReplyData;
+
+ int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+
+ p->status = android::Virtualizer_getParameter(pContext,
+ (int32_t *)p->data,
+ (size_t *)&p->vsize,
+ p->data + voffset);
+
+ *replySize = sizeof(effect_param_t) + voffset + p->vsize;
+
+ LOGV("\tVirtualizer_command EFFECT_CMD_GET_PARAM "
+ "*pCmdData %d, *replySize %d, *pReplyData %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset));
+ }
+ if(pContext->EffectType == LVM_EQUALIZER){
+ LOGV("\tEqualizer_command cmdCode Case: "
+ "EFFECT_CMD_GET_PARAM start");
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL || *replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))) {
+ LOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: "
+ "EFFECT_CMD_GET_PARAM");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *)pCmdData;
+
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
+
+ p = (effect_param_t *)pReplyData;
+
+ int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+
+ p->status = android::Equalizer_getParameter(pContext, (int32_t *)p->data, &p->vsize,
+ p->data + voffset);
+
+ *replySize = sizeof(effect_param_t) + voffset + p->vsize;
+
+ LOGV("\tEqualizer_command EFFECT_CMD_GET_PARAM *pCmdData %d, *replySize %d, *pReplyData %08x %08x",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), *replySize,
+ *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset),
+ *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset + sizeof(int32_t)));
+ }
+ if(pContext->EffectType == LVM_VOLUME){
+ LOGV("\tVolume_command cmdCode Case: "
+ "EFFECT_CMD_GET_PARAM start");
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL ||*replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))){
+ LOGV("\tLVM_ERROR : Volume_command cmdCode Case: "
+ "EFFECT_CMD_GET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *)pCmdData;
+
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
+
+ p = (effect_param_t *)pReplyData;
+
+ int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+
+ p->status = android::Volume_getParameter(pContext,
+ (int32_t *)p->data,
+ (size_t *)&p->vsize,
+ p->data + voffset);
+
+ *replySize = sizeof(effect_param_t) + voffset + p->vsize;
+
+ LOGV("\tVolume_command EFFECT_CMD_GET_PARAM "
+ "*pCmdData %d, *replySize %d, *pReplyData %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset));
+ }
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_GET_PARAM end");
+ } break;
+ case EFFECT_CMD_SET_PARAM:{
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_PARAM start");
+ if(pContext->EffectType == LVM_BASS_BOOST){
+ LOGV("\tBassBoost_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t)));
+
+ if ( pCmdData == NULL||
+ cmdSize != (int)(sizeof(effect_param_t) + sizeof(int32_t) + sizeof(int16_t))||
+ pReplyData == NULL||
+ *replySize != sizeof(int32_t)){
+ LOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *) pCmdData;
+
+ if (p->psize != sizeof(int32_t)){
+ LOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)");
+ return -EINVAL;
+ }
+
+ LOGV("\tnBassBoost_command cmdSize is %d\n"
+ "\tsizeof(effect_param_t) is %d\n"
+ "\tp->psize is %d\n"
+ "\tp->vsize is %d"
+ "\n",
+ cmdSize, sizeof(effect_param_t), p->psize, p->vsize );
+
+ *(int *)pReplyData = android::BassBoost_setParameter(pContext,
+ (int32_t *)p->data,
+ p->data + p->psize);
+ }
+ if(pContext->EffectType == LVM_VIRTUALIZER){
+ LOGV("\tVirtualizer_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t)));
+
+ if ( pCmdData == NULL||
+ cmdSize != (int)(sizeof(effect_param_t) + sizeof(int32_t) + sizeof(int16_t))||
+ pReplyData == NULL||
+ *replySize != sizeof(int32_t)){
+ LOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *) pCmdData;
+
+ if (p->psize != sizeof(int32_t)){
+ LOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)");
+ return -EINVAL;
+ }
+
+ LOGV("\tnVirtualizer_command cmdSize is %d\n"
+ "\tsizeof(effect_param_t) is %d\n"
+ "\tp->psize is %d\n"
+ "\tp->vsize is %d"
+ "\n",
+ cmdSize, sizeof(effect_param_t), p->psize, p->vsize );
+
+ *(int *)pReplyData = android::Virtualizer_setParameter(pContext,
+ (int32_t *)p->data,
+ p->data + p->psize);
+ }
+ if(pContext->EffectType == LVM_EQUALIZER){
+ LOGV("\tEqualizer_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM start");
+ LOGV("\tEqualizer_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t)));
+
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL || *replySize != sizeof(int32_t)) {
+ LOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *) pCmdData;
+
+ *(int *)pReplyData = android::Equalizer_setParameter(pContext,
+ (int32_t *)p->data,
+ p->data + p->psize);
+ }
+ if(pContext->EffectType == LVM_VOLUME){
+ LOGV("\tVolume_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM start");
+ LOGV("\tVolume_command EFFECT_CMD_SET_PARAM param %d, *replySize %d, value %d ",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)),
+ *replySize,
+ *(int16_t *)((char *)pCmdData + sizeof(effect_param_t) + sizeof(int32_t)));
+
+ if ( pCmdData == NULL||
+ cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t))||
+ pReplyData == NULL||
+ *replySize != sizeof(int32_t)){
+ LOGV("\tLVM_ERROR : Volume_command cmdCode Case: "
+ "EFFECT_CMD_SET_PARAM: ERROR");
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *) pCmdData;
+
+ *(int *)pReplyData = android::Volume_setParameter(pContext,
+ (int32_t *)p->data,
+ p->data + p->psize);
+ }
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_SET_PARAM end");
+ } break;
+
+ case EFFECT_CMD_ENABLE:
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE start");
+ if (pReplyData == NULL || *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : Effect_command cmdCode Case: EFFECT_CMD_ENABLE: ERROR");
+ return -EINVAL;
+ }
+ switch (pContext->EffectType){
+ case LVM_BASS_BOOST:
+ if(pContext->pBundledContext->bBassEnabled == LVM_TRUE){
+ LOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: "
+ "EFFECT_CMD_ENABLE: ERROR-Effect is already enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bBassEnabled = LVM_TRUE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE LVM_BASS_BOOST enabled");
+ break;
+ case LVM_EQUALIZER:
+ if(pContext->pBundledContext->bEqualizerEnabled == LVM_TRUE){
+ LOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: "
+ "EFFECT_CMD_ENABLE: ERROR-Effect is already enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bEqualizerEnabled = LVM_TRUE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE LVM_EQUALIZER enabled");
+ break;
+ case LVM_VIRTUALIZER:
+ if(pContext->pBundledContext->bVirtualizerEnabled == LVM_TRUE){
+ LOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: "
+ "EFFECT_CMD_ENABLE: ERROR-Effect is already enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bVirtualizerEnabled = LVM_TRUE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE LVM_VIRTUALIZER enabled");
+ break;
+ case LVM_VOLUME:
+ if(pContext->pBundledContext->bVolumeEnabled == LVM_TRUE){
+ LOGV("\tLVM_ERROR : Volume_command cmdCode Case: "
+ "EFFECT_CMD_ENABLE: ERROR-Effect is already enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bVolumeEnabled = LVM_TRUE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE LVM_VOLUME enabled");
+ break;
+ default:
+ LOGV("\tLVM_ERROR : Effect_command cmdCode Case: "
+ "EFFECT_CMD_ENABLE: ERROR, invalid Effect Type");
+ return -EINVAL;
+ }
+ *(int *)pReplyData = 0;
+ pContext->pBundledContext->NumberEffectsEnabled++;
+ android::LvmEffect_enable(pContext);
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE NumberEffectsEnabled = %d", pContext->pBundledContext->NumberEffectsEnabled);
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_ENABLE end");
+ break;
+
+ case EFFECT_CMD_DISABLE:
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE start");
+ if (pReplyData == NULL || *replySize != sizeof(int)){
+ LOGV("\tLVM_ERROR : Effect_command cmdCode Case: EFFECT_CMD_DISABLE: ERROR");
+ return -EINVAL;
+ }
+ switch (pContext->EffectType){
+ case LVM_BASS_BOOST:
+ if(pContext->pBundledContext->bBassEnabled == LVM_FALSE){
+ LOGV("\tLVM_ERROR : BassBoost_command cmdCode Case: "
+ "EFFECT_CMD_DISABLE: ERROR-Effect is not yet enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bBassEnabled = LVM_FALSE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE LVM_BASS_BOOST disabled");
+ break;
+ case LVM_EQUALIZER:
+ if(pContext->pBundledContext->bEqualizerEnabled == LVM_FALSE){
+ LOGV("\tLVM_ERROR : Equalizer_command cmdCode Case: "
+ "EFFECT_CMD_DISABLE: ERROR-Effect is not yet enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bEqualizerEnabled = LVM_FALSE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE LVM_EQUALIZER disabled");
+ break;
+ case LVM_VIRTUALIZER:
+ if(pContext->pBundledContext->bVirtualizerEnabled == LVM_FALSE){
+ LOGV("\tLVM_ERROR : Virtualizer_command cmdCode Case: "
+ "EFFECT_CMD_DISABLE: ERROR-Effect is not yet enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bVirtualizerEnabled = LVM_FALSE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE LVM_VIRTUALIZER disabled");
+ break;
+ case LVM_VOLUME:
+ if(pContext->pBundledContext->bVolumeEnabled == LVM_FALSE){
+ LOGV("\tLVM_ERROR : Volume_command cmdCode Case: "
+ "EFFECT_CMD_DISABLE: ERROR-Effect is not yet enabled");
+ return -EINVAL;
+ }
+ pContext->pBundledContext->bVolumeEnabled = LVM_FALSE;
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE LVM_VOLUME disabled");
+ break;
+ break;
+ default:
+ LOGV("\tLVM_ERROR : Effect_command cmdCode Case: "
+ "EFFECT_CMD_DISABLE: ERROR, invalid Effect Type");
+ return -EINVAL;
+ }
+ *(int *)pReplyData = 0;
+ pContext->pBundledContext->NumberEffectsEnabled--;
+ android::LvmEffect_disable(pContext);
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE NumberEffectsEnabled = %d", pContext->pBundledContext->NumberEffectsEnabled);
+ LOGV("\tEffect_command cmdCode Case: EFFECT_CMD_DISABLE end");
+ break;
+
+ case EFFECT_CMD_SET_DEVICE:
+ case EFFECT_CMD_SET_VOLUME:
+// case EFFECT_CMD_SET_AUDIO_MODE:// AGO add this
+ LOGV("\tEffect_command cmdCode Case: "
+ "EFFECT_CMD_SET_DEVICE/EFFECT_CMD_SET_VOLUME/EFFECT_CMD_SET_AUDIO_MODE start");
+ break;
+
+ default:
+ LOGV("\tLVM_ERROR : Effect_command cmdCode Case: DEFAULT start %d ERROR",cmdCode);
+ return -EINVAL;
+ }
+
+ LOGV("\tEffect_command end...\n\n");
+ return 0;
+} /* end Effect_command */
+
+// effect_interface_t interface implementation for effect
+const struct effect_interface_s gLvmEffectInterface = {
+ Effect_process,
+ Effect_command
+}; /* end gLvmEffectInterface */
+
+
diff --git a/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h
new file mode 100644
index 0000000..6818dd6
--- /dev/null
+++ b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_EFFECTBUNDLE_H_
+#define ANDROID_EFFECTBUNDLE_H_
+
+#include <media/EffectApi.h>
+#include <LVM.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+#define FIVEBAND_NUMBANDS 5
+#define MAX_NUM_BANDS 5
+#define MAX_CALL_SIZE 256
+
+//TODO: this should be included from each effect API include
+static const effect_uuid_t SL_IID_BASSBOOST_ = { 0x0634f220, 0xddd4, 0x11db, 0xa0fc, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+const effect_uuid_t * const SL_IID_BASSBOOST = &SL_IID_BASSBOOST_;
+
+static const effect_uuid_t SL_IID_EQUALIZER_ = { 0x0bed4300, 0xddd6, 0x11db, 0x8f34, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+const effect_uuid_t * const SL_IID_EQUALIZER = &SL_IID_EQUALIZER_;
+
+static const effect_uuid_t SL_IID_VIRTUALIZER_ = { 0x37cc2c00, 0xdddd, 0x11db, 0x8577, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } }; // updated mon 28th june 2010
+const effect_uuid_t * const SL_IID_VIRTUALIZER = &SL_IID_VIRTUALIZER_;
+
+static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } }; // updated mon 28th june 2010
+const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
+
+typedef enum
+{
+ LVM_BASS_BOOST,
+ LVM_VIRTUALIZER,
+ LVM_EQUALIZER,
+ LVM_VOLUME
+} lvm_effect_en;
+
+// Preset configuration.
+struct PresetConfig {
+ // Human-readable name.
+ const char * name;
+ // An array of size nBands where each element is a configuration for the
+ // corresponding band.
+ //const BandConfig * bandConfigs;
+};
+
+/* BundledEffectContext : One per session */
+struct BundledEffectContext{
+ LVM_Handle_t hInstance; /* Instance handle */
+ int SessionNo; /* Current session number */
+ bool bVolumeEnabled; /* Flag for Volume */
+ bool bEqualizerEnabled; /* Flag for EQ */
+ bool bBassEnabled; /* Flag for Bass */
+ bool bVirtualizerEnabled; /* Flag for Virtualizer */
+ int NumberEffectsEnabled; /* Effects in this session */
+ int NumberEffectsCalled; /* Effects called so far */
+ // Saved parameters for each effect */
+ // Bass Boost
+ int BassStrengthSaved; /* Conversion between Get/Set */
+ // Equalizer
+ int CurPreset; /* Current preset being used */
+ // Virtualzer
+ int VirtStrengthSaved; /* Conversion between Get/Set */
+ // Volume
+ int levelSaved; /* for when mute is set, level must be saved */
+ bool bMuteEnabled; /* Must store as mute = -96dB level */
+};
+
+/* SessionContext : One session */
+struct SessionContext{
+ bool bBundledEffectsEnabled;
+ bool bVolumeInstantiated;
+ bool bEqualizerInstantiated;
+ bool bBassInstantiated;
+ bool bVirtualizerInstantiated;
+ BundledEffectContext *pBundledContext;
+};
+
+struct EffectContext{
+ const struct effect_interface_s *itfe;
+ effect_config_t config;
+ lvm_effect_en EffectType;
+ BundledEffectContext *pBundledContext;
+};
+
+//TODO: this should be included from each effect API include
+/* enumerated parameter settings for BassBoost effect */
+typedef enum
+{
+ BASSBOOST_PARAM_STRENGTH_SUP, // type SLboolean = typedef SLuint32
+ BASSBOOST_PARAM_STRENGTH // type SLpermille = typedef SLuint16
+} t_bassboost_params;
+
+/* enumerated parameter settings for Virtualizer effect */
+typedef enum
+{
+ VIRTUALIZER_PARAM_STRENGTH_SUP, // type SLboolean = typedef SLuint32
+ VIRTUALIZER_PARAM_STRENGTH // type SLpermille = typedef SLuint16
+} t_virtualizer_params;
+
+/* enumerated parameter settings for Equalizer effect */
+typedef enum
+{
+ EQ_PARAM_NUM_BANDS, // Gets the number of frequency bands that the equalizer supports.
+ EQ_PARAM_LEVEL_RANGE, // Returns the minimum and maximum band levels supported.
+ EQ_PARAM_BAND_LEVEL, // Gets/Sets the gain set for the given equalizer band.
+ EQ_PARAM_CENTER_FREQ, // Gets the center frequency of the given band.
+ EQ_PARAM_BAND_FREQ_RANGE, // Gets the frequency range of the given frequency band.
+ EQ_PARAM_GET_BAND, // Gets the band that has the most effect on the given frequency.
+ EQ_PARAM_CUR_PRESET, // Gets/Sets the current preset.
+ EQ_PARAM_GET_NUM_OF_PRESETS, // Gets the total number of presets the equalizer supports.
+ EQ_PARAM_GET_PRESET_NAME // Gets the preset name based on the index.
+} t_equalizer_params;
+
+/* enumerated parameter settings for Volume effect */
+typedef enum
+{
+ VOLUME_PARAM_LEVEL, // type SLmillibel = typedef SLuint16 (set & get)
+ VOLUME_PARAM_MAXLEVEL, // type SLmillibel = typedef SLuint16 (get)
+ VOLUME_PARAM_MUTE, // type SLboolean = typedef SLuint32 (set & get)
+ VOLUME_PARAM_ENABLESTEREOPOSITION, // type SLboolean = typedef SLuint32 (set & get)
+ VOLUME_PARAM_STEREOPOSITION, // type SLpermille = typedef SLuint16 (set & get)
+} t_volume_params;
+
+static const int PRESET_CUSTOM = -1;
+
+static const uint32_t bandFreqRange[FIVEBAND_NUMBANDS][2] = {
+ {30000, 120000},
+ {12000, 460000},
+ {46000, 1800000},
+ {180000, 7000000},
+ {700000, 1}
+ };
+
+static const LVM_UINT16 EQNB_5BandPresetsFrequencies[] = {
+ 60, /* Frequencies in Hz */
+ 230,
+ 910,
+ 3600,
+ 14000};
+
+static const LVM_UINT16 EQNB_5BandPresetsQFactors[] = {
+ 96, /* Q factor multiplied by 100 */
+ 96,
+ 96,
+ 96,
+ 96};
+
+static const LVM_INT16 EQNB_5BandNormalPresets[] = {
+ 3, 0, 0, 0, 3, /* Normal Preset */
+ 8, 5, -3, 5, 6, /* Classical Preset */
+ 15, -6, 7, 13, 10, /* Dance Preset */
+ 0, 0, 0, 0, 0, /* Flat Preset */
+ 6, -2, -2, 6, -3, /* Folk Preset */
+ 8, -8, 13, -1, -4, /* Heavy Metal Preset */
+ 10, 6, -4, 5, 8, /* Hip Hop Preset */
+ 8, 5, -4, 5, 9, /* Jazz Preset */
+ -6, 4, 9, 4, -5, /* Pop Preset */
+ 10, 6, -1, 8, 10}; /* Rock Preset */
+
+static const PresetConfig gEqualizerPresets[] = {
+ {"Normal"},
+ {"Classical"},
+ {"Dance"},
+ {"Flat"},
+ {"Folk"},
+ {"Heavy Metal"},
+ {"Hip Hop"},
+ {"Jazz"},
+ {"Pop"},
+ {"Rock"}
+ };
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECTBUNDLE_H_*/