Merge "libeffects: Removed the unused/redundant code in lvm/lib" am:... (632863e2) · Commits · e / os / android_frameworks_av

media/libeffects/lvm/lib/Android.bp

+0 −4

Original line number	Diff line number	Diff line
		@@ -137,8 +137,6 @@ cc_library_static {
		],
		cppflags: [
		"-fvisibility=hidden",
		"-DBUILD_FLOAT",
		"-DHIGHER_FS",
		"-DSUPPORT_MC",

		"-Wall",
		@@ -208,8 +206,6 @@ cc_library_static {

		cppflags: [
		"-fvisibility=hidden",
		"-DBUILD_FLOAT",
		"-DHIGHER_FS",

		"-Wall",
		"-Werror",

media/libeffects/lvm/lib/Bass/lib/LVDBE.h

+0 −33

Original line number	Diff line number	Diff line
		@@ -55,8 +55,6 @@
		#ifndef __LVDBE_H__
		#define __LVDBE_H__



		/****************************************************************************************/
		/* */
		/* Includes */
		@@ -65,7 +63,6 @@

		#include "LVM_Types.h"


		/****************************************************************************************/
		/* */
		/* Definitions */
		@@ -82,7 +79,6 @@
		#define LVDBE_EFFECT_12DB 12
		#define LVDBE_EFFECT_15DB 15


		/****************************************************************************************/
		/* */
		/* Types */
		@@ -92,7 +88,6 @@
		/* Instance handle */
		typedef void *LVDBE_Handle_t;


		/* Operating modes */
		typedef enum
		{
		@@ -101,7 +96,6 @@ typedef enum
		LVDBE_MODE_MAX = LVM_MAXINT_32
		} LVDBE_Mode_en;


		/* High pass filter */
		typedef enum
		{
		@@ -110,7 +104,6 @@ typedef enum
		LVDBE_HPF_MAX = LVM_MAXINT_32
		} LVDBE_FilterSelect_en;


		/* Volume control */
		typedef enum
		{
		@@ -119,7 +112,6 @@ typedef enum
		LVDBE_VOLUME_MAX = LVM_MAXINT_32
		} LVDBE_Volume_en;


		/* Memory Types */
		typedef enum
		{
		@@ -131,7 +123,6 @@ typedef enum

		} LVDBE_MemoryTypes_en;


		/* Function return status */
		typedef enum
		{
		@@ -143,7 +134,6 @@ typedef enum
		LVDBE_STATUS_MAX = LVM_MAXINT_32
		} LVDBE_ReturnStatus_en;


		/****************************************************************************************/
		/* */
		/* Linked enumerated type and capability definitions */
		@@ -182,7 +172,6 @@ typedef enum
		LVDBE_CENTRE_MAX = LVM_MAXINT_32
		} LVDBE_CentreFreq_en;


		/*
		* Supported sample rates in samples per second
		*/
		@@ -195,12 +184,10 @@ typedef enum
		#define LVDBE_CAP_FS_32000 64
		#define LVDBE_CAP_FS_44100 128
		#define LVDBE_CAP_FS_48000 256
		#if defined(BUILD_FLOAT) && defined(HIGHER_FS)
		#define LVDBE_CAP_FS_88200 512
		#define LVDBE_CAP_FS_96000 1024
		#define LVDBE_CAP_FS_176400 2048
		#define LVDBE_CAP_FS_192000 4096
		#endif

		typedef enum
		{
		@@ -213,16 +200,13 @@ typedef enum
		LVDBE_FS_32000 = 6,
		LVDBE_FS_44100 = 7,
		LVDBE_FS_48000 = 8,
		#if defined(BUILD_FLOAT) && defined(HIGHER_FS)
		LVDBE_FS_88200 = 9,
		LVDBE_FS_96000 = 10,
		LVDBE_FS_176400 = 11,
		LVDBE_FS_192000 = 12,
		#endif
		LVDBE_FS_MAX = LVM_MAXINT_32
		} LVDBE_Fs_en;


		/****************************************************************************************/
		/* */
		/* Structures */
		@@ -238,14 +222,12 @@ typedef struct
		void pBaseAddress; / Pointer to the region base address */
		} LVDBE_MemoryRegion_t;


		/* Memory table containing the region definitions */
		typedef struct
		{
		LVDBE_MemoryRegion_t Region[LVDBE_NR_MEMORY_REGIONS]; /* One definition for each region */
		} LVDBE_MemTab_t;


		/* Parameter structure */
		typedef struct
		{
		@@ -263,7 +245,6 @@ typedef struct

		} LVDBE_Params_t;


		/* Capability structure */
		typedef struct
		{
		@@ -272,7 +253,6 @@ typedef struct
		LVM_UINT16 MaxBlockSize; /* Maximum block size in sample pairs */
		} LVDBE_Capabilities_t;


		/****************************************************************************************/
		/* */
		/* Function Prototypes */
		@@ -314,7 +294,6 @@ LVDBE_ReturnStatus_en LVDBE_Memory(LVDBE_Handle_t hInstance,
		LVDBE_MemTab_t *pMemoryTable,
		LVDBE_Capabilities_t *pCapabilities);


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_Init */
		@@ -352,7 +331,6 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		LVDBE_MemTab_t *pMemoryTable,
		LVDBE_Capabilities_t *pCapabilities);


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_GetParameters */
		@@ -376,7 +354,6 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
		LVDBE_Params_t *pParams);


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_GetCapabilities */
		@@ -400,7 +377,6 @@ LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
		LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
		LVDBE_Capabilities_t *pCapabilities);


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_Control */
		@@ -441,7 +417,6 @@ LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
		LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		LVDBE_Params_t *pParams);


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_Process */
		@@ -462,17 +437,9 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		/* NOTES: */
		/* */
		/****************************************************************************************/
		#ifdef BUILD_FLOAT
		LVDBE_ReturnStatus_en LVDBE_Process(LVDBE_Handle_t hInstance,
		const LVM_FLOAT *pInData,
		LVM_FLOAT *pOutData,
		LVM_UINT16 NumSamples);
		#else
		LVDBE_ReturnStatus_en LVDBE_Process(LVDBE_Handle_t hInstance,
		const LVM_INT16 *pInData,
		LVM_INT16 *pOutData,
		LVM_UINT16 NumSamples);
		#endif


		#endif /* __LVDBE_H__ */

media/libeffects/lvm/lib/Bass/src/LVDBE_Coeffs.h

+0 −526

File changed.

Preview size limit exceeded, changes collapsed.

media/libeffects/lvm/lib/Bass/src/LVDBE_Control.cpp

+0 −100

Original line number	Diff line number	Diff line
		@@ -58,7 +58,6 @@ LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
		return(LVDBE_SUCCESS);
		}


		/************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_GetCapabilities */
		@@ -89,7 +88,6 @@ LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
		return(LVDBE_SUCCESS);
		}


		/************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_SetFilters */
		@@ -107,72 +105,35 @@ void LVDBE_SetFilters(LVDBE_Instance_t *pInstance,
		LVDBE_Params_t *pParams)
		{

		#if defined(BUILD_FLOAT) && defined(HIGHER_FS)
		/*
		* Calculate the table offsets
		*/
		LVM_UINT16 Offset = (LVM_UINT16)((LVM_UINT16)pParams->SampleRate + \
		(LVM_UINT16)(pParams->CentreFrequency * (1+LVDBE_FS_192000)));
		#else
		/*
		* Calculate the table offsets
		*/
		LVM_UINT16 Offset = (LVM_UINT16)((LVM_UINT16)pParams->SampleRate + \
		(LVM_UINT16)(pParams->CentreFrequency * (1+LVDBE_FS_48000)));
		#endif

		/*
		* Setup the high pass filter
		*/
		#ifndef BUILD_FLOAT
		LoadConst_16(0, /* Clear the history, value 0 */
		(void )&pInstance->pData->HPFTaps, / Destination Cast to void: \
		no dereferencing in function*/
		sizeof(pInstance->pData->HPFTaps)/sizeof(LVM_INT16)); /* Number of words */
		#else
		LoadConst_Float(0, /* Clear the history, value 0 */
		(LVM_FLOAT )&pInstance->pData->HPFTaps, / Destination Cast to void: \
		no dereferencing in function*/
		sizeof(pInstance->pData->HPFTaps) / sizeof(LVM_FLOAT)); /* Number of words */
		#endif
		#ifndef BUILD_FLOAT
		BQ_2I_D32F32Cll_TRC_WRA_01_Init(&pInstance->pCoef->HPFInstance, /* Initialise the filter */
		&pInstance->pData->HPFTaps,
		(BQ_C32_Coefs_t *)&LVDBE_HPF_Table[Offset]);
		#else
		BQ_2I_D32F32Cll_TRC_WRA_01_Init(&pInstance->pCoef->HPFInstance, /* Initialise the filter */
		&pInstance->pData->HPFTaps,
		(BQ_FLOAT_Coefs_t *)&LVDBE_HPF_Table[Offset]);
		#endif


		/*
		* Setup the band pass filter
		*/
		#ifndef BUILD_FLOAT
		LoadConst_16(0, /* Clear the history, value 0 */
		(void )&pInstance->pData->BPFTaps, / Destination Cast to void: \
		no dereferencing in function*/
		sizeof(pInstance->pData->BPFTaps)/sizeof(LVM_INT16)); /* Number of words */
		#else
		LoadConst_Float(0, /* Clear the history, value 0 */
		(LVM_FLOAT )&pInstance->pData->BPFTaps, / Destination Cast to void: \
		no dereferencing in function*/
		sizeof(pInstance->pData->BPFTaps) / sizeof(LVM_FLOAT)); /* Number of words */
		#endif
		#ifndef BUILD_FLOAT
		BP_1I_D32F32Cll_TRC_WRA_02_Init(&pInstance->pCoef->BPFInstance, /* Initialise the filter */
		&pInstance->pData->BPFTaps,
		(BP_C32_Coefs_t *)&LVDBE_BPF_Table[Offset]);
		#else
		BP_1I_D32F32Cll_TRC_WRA_02_Init(&pInstance->pCoef->BPFInstance, /* Initialise the filter */
		&pInstance->pData->BPFTaps,
		(BP_FLOAT_Coefs_t *)&LVDBE_BPF_Table[Offset]);
		#endif
		}



		/************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_SetAGC */
		@@ -196,7 +157,6 @@ void LVDBE_SetAGC(LVDBE_Instance_t *pInstance,
		pInstance->pData->AGCInstance.AGC_Attack = LVDBE_AGC_ATTACK_Table[(LVM_UINT16)pParams->SampleRate]; /* Attack multiplier */
		pInstance->pData->AGCInstance.AGC_Decay = LVDBE_AGC_DECAY_Table[(LVM_UINT16)pParams->SampleRate]; /* Decay multipler */


		/*
		* Get the boost gain
		*/
		@@ -208,14 +168,10 @@ void LVDBE_SetAGC(LVDBE_Instance_t *pInstance,
		{
		pInstance->pData->AGCInstance.AGC_MaxGain = LVDBE_AGC_GAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter off */
		}
		#ifndef BUILD_FLOAT
		pInstance->pData->AGCInstance.AGC_GainShift = AGC_GAIN_SHIFT;
		#endif
		pInstance->pData->AGCInstance.AGC_Target = AGC_TARGETLEVEL;

		}


		/************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_SetVolume */
		@@ -247,9 +203,7 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
		LVM_UINT16 dBOffset; /* Table offset */
		LVM_INT16 Volume = 0; /* Required volume in dBs */

		#ifdef BUILD_FLOAT
		LVM_FLOAT dBShifts_fac;
		#endif
		/*
		* Apply the volume if enabled
		*/
		@@ -268,68 +222,41 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
		}
		}


		/*
		* Calculate the required gain and shifts
		*/
		dBOffset = (LVM_UINT16)(6 + Volume % 6); /* Get the dBs 0-5 */
		dBShifts = (LVM_UINT16)(Volume / -6); /* Get the 6dB shifts */

		#ifdef BUILD_FLOAT
		dBShifts_fac = (LVM_FLOAT)(1 << dBShifts);
		#endif
		/*
		* When DBE is enabled use AGC volume
		*/
		#ifndef BUILD_FLOAT
		pInstance->pData->AGCInstance.Target = ((LVM_INT32)LVDBE_VolumeTable[dBOffset] << 16);
		pInstance->pData->AGCInstance.Target = pInstance->pData->AGCInstance.Target >> dBShifts;
		#else
		pInstance->pData->AGCInstance.Target = (LVDBE_VolumeTable[dBOffset]);
		pInstance->pData->AGCInstance.Target = pInstance->pData->AGCInstance.Target / dBShifts_fac;
		#endif
		pInstance->pData->AGCInstance.VolumeTC = LVDBE_VolumeTCTable[(LVM_UINT16)pParams->SampleRate]; /* Volume update time constant */
		#ifndef BUILD_FLOAT
		pInstance->pData->AGCInstance.VolumeShift = VOLUME_SHIFT+1;
		#endif

		/*
		* When DBE is disabled use the bypass volume control
		*/
		if(dBShifts > 0)
		{
		#ifndef BUILD_FLOAT
		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],(((LVM_INT32)LVDBE_VolumeTable[dBOffset]) >> dBShifts));
		#else
		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_VolumeTable[dBOffset] / dBShifts_fac);
		#endif
		}
		else
		{
		#ifndef BUILD_FLOAT
		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],(LVM_INT32)LVDBE_VolumeTable[dBOffset]);
		#else
		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_VolumeTable[dBOffset]);
		#endif
		}

		pInstance->pData->BypassVolume.MixerStream[0].CallbackSet = 1;
		#ifndef BUILD_FLOAT
		LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_MIXER_TC,
		(LVM_Fs_en)pInstance->Params.SampleRate,
		2);
		#else
		LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_MIXER_TC,
		(LVM_Fs_en)pInstance->Params.SampleRate,
		2);
		#endif
		}


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_Control */
		@@ -372,12 +299,7 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		{

		LVDBE_Instance_t pInstance =(LVDBE_Instance_t )hInstance;
		#ifndef BUILD_FLOAT
		LVMixer3_2St_st *pBypassMixer_Instance = &pInstance->pData->BypassMixer;
		#else
		LVMixer3_2St_FLOAT_st *pBypassMixer_Instance = &pInstance->pData->BypassMixer;
		#endif


		/*
		* Update the filters
		@@ -389,7 +311,6 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		pParams); /* New parameters */
		}


		/*
		* Update the AGC is the effect level has changed
		*/
		@@ -399,24 +320,14 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		{
		LVDBE_SetAGC(pInstance, /* Instance pointer */
		pParams); /* New parameters */
		#ifndef BUILD_FLOAT
		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0],
		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);

		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],
		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);
		#else
		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0],
		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);

		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],
		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);
		#endif


		}


		/*
		* Update the Volume if the volume demand has changed
		*/
		@@ -431,23 +342,13 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,

		if (pInstance->Params.OperatingMode==LVDBE_ON && pParams->OperatingMode==LVDBE_OFF)
		{
		#ifndef BUILD_FLOAT
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[0],0);
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1],0x00007FFF);
		#else
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[0], 0);
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1], 1.0f);
		#endif
		}
		if (pInstance->Params.OperatingMode==LVDBE_OFF && pParams->OperatingMode==LVDBE_ON)
		{
		#ifndef BUILD_FLOAT
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[0],0x00007FFF);
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1],0);
		#else
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[0], 1.0f);
		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1], 0);
		#endif
		}

		/*
		@@ -455,6 +356,5 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		*/
		pInstance->Params = *pParams;


		return(LVDBE_SUCCESS);
		}

media/libeffects/lvm/lib/Bass/src/LVDBE_Init.cpp

+0 −43

Original line number	Diff line number	Diff line
		@@ -63,7 +63,6 @@ LVDBE_ReturnStatus_en LVDBE_Memory(LVDBE_Handle_t hInstance,
		LVM_UINT32 ScratchSize;
		LVDBE_Instance_t pInstance = (LVDBE_Instance_t )hInstance;


		/*
		* Fill in the memory table
		*/
		@@ -80,11 +79,7 @@ LVDBE_ReturnStatus_en LVDBE_Memory(LVDBE_Handle_t hInstance,
		/*
		* Data memory
		*/
		#ifdef BUILD_FLOAT
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size = sizeof(LVDBE_Data_FLOAT_t);
		#else
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_DATA].Size = sizeof(LVDBE_Data_t);
		#endif
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_DATA].Alignment = LVDBE_PERSISTENT_DATA_ALIGN;
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_DATA].Type = LVDBE_PERSISTENT_DATA;
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_DATA].pBaseAddress = LVM_NULL;
		@@ -92,11 +87,7 @@ LVDBE_ReturnStatus_en LVDBE_Memory(LVDBE_Handle_t hInstance,
		/*
		* Coef memory
		*/
		#ifdef BUILD_FLOAT
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size = sizeof(LVDBE_Coef_FLOAT_t);
		#else
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_COEF].Size = sizeof(LVDBE_Coef_t);
		#endif
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_COEF].Alignment = LVDBE_PERSISTENT_COEF_ALIGN;
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_COEF].Type = LVDBE_PERSISTENT_COEF;
		pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress = LVM_NULL;
		@@ -104,12 +95,8 @@ LVDBE_ReturnStatus_en LVDBE_Memory(LVDBE_Handle_t hInstance,
		/*
		* Scratch memory
		*/
		#ifdef BUILD_FLOAT
		ScratchSize = (LVM_UINT32)(LVDBE_SCRATCHBUFFERS_INPLACEsizeof(LVM_FLOAT) \
		pCapabilities->MaxBlockSize);
		#else /BUILD_FLOAT/
		ScratchSize = (LVM_UINT32)(LVDBE_SCRATCHBUFFERS_INPLACEsizeof(LVM_INT16)pCapabilities->MaxBlockSize);
		#endif
		pMemoryTable->Region[LVDBE_MEMREGION_SCRATCH].Size = ScratchSize;
		pMemoryTable->Region[LVDBE_MEMREGION_SCRATCH].Alignment = LVDBE_SCRATCH_ALIGN;
		pMemoryTable->Region[LVDBE_MEMREGION_SCRATCH].Type = LVDBE_SCRATCH;
		@@ -124,7 +111,6 @@ LVDBE_ReturnStatus_en LVDBE_Memory(LVDBE_Handle_t hInstance,
		return(LVDBE_SUCCESS);
		}


		/****************************************************************************************/
		/* */
		/* FUNCTION: LVDBE_Init */
		@@ -164,18 +150,11 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		{

		LVDBE_Instance_t *pInstance;
		#ifdef BUILD_FLOAT
		LVMixer3_1St_FLOAT_st *pMixer_Instance;
		LVMixer3_2St_FLOAT_st *pBypassMixer_Instance;
		LVM_FLOAT MixGain;
		#else
		LVMixer3_1St_st *pMixer_Instance;
		LVMixer3_2St_st *pBypassMixer_Instance;
		LVM_INT32 MixGain;
		#endif
		LVM_INT16 i;


		/*
		* Set the instance handle if not already initialised
		*/
		@@ -185,7 +164,6 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		}
		pInstance =(LVDBE_Instance_t )phInstance;


		/*
		* Check the memory table for NULL pointers and incorrectly aligned data
		*/
		@@ -203,19 +181,16 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		}
		}


		/*
		* Save the memory table in the instance structure
		*/
		pInstance->Capabilities = *pCapabilities;


		/*
		* Save the memory table in the instance structure
		*/
		pInstance->MemoryTable = *pMemoryTable;


		/*
		* Set the default instance parameters
		*/
		@@ -228,7 +203,6 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		pInstance->Params.VolumeControl = LVDBE_VOLUME_OFF;
		pInstance->Params.VolumedB = 0;


		/*
		* Set pointer to data and coef memory
		*/
		@@ -237,14 +211,12 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		pInstance->pCoef =
		(LVDBE_Coef_FLOAT_t *)pMemoryTable->Region[LVDBE_MEMREGION_PERSISTENT_COEF].pBaseAddress;


		/*
		* Initialise the filters
		*/
		LVDBE_SetFilters(pInstance, /* Set the filter taps and coefficients */
		&pInstance->Params);


		/*
		* Initialise the AGC
		*/
		@@ -256,11 +228,7 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		// initialize the mixer with some fixes values since otherwise LVDBE_SetVolume ends up
		// reading uninitialized data
		pMixer_Instance = &pInstance->pData->BypassVolume;
		#ifndef BUILD_FLOAT
		LVC_Mixer_Init(&pMixer_Instance->MixerStream[0],0x00007FFF,0x00007FFF);
		#else
		LVC_Mixer_Init(&pMixer_Instance->MixerStream[0], 1.0, 1.0);
		#endif

		/*
		* Initialise the volume
		@@ -270,13 +238,8 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,

		pInstance->pData->AGCInstance.Volume = pInstance->pData->AGCInstance.Target;
		/* Initialise as the target */
		#ifndef BUILD_FLOAT
		MixGain = LVC_Mixer_GetTarget(&pMixer_Instance->MixerStream[0]);
		LVC_Mixer_Init(&pMixer_Instance->MixerStream[0], MixGain, MixGain);
		#else
		MixGain = LVC_Mixer_GetTarget(&pMixer_Instance->MixerStream[0]);
		LVC_Mixer_Init(&pMixer_Instance->MixerStream[0], MixGain, MixGain);
		#endif

		/* Configure the mixer process path */
		pMixer_Instance->MixerStream[0].CallbackParam = 0;
		@@ -309,15 +272,9 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		pBypassMixer_Instance->MixerStream[1].pCallbackHandle = LVM_NULL;
		pBypassMixer_Instance->MixerStream[1].pCallBack = LVM_NULL;
		pBypassMixer_Instance->MixerStream[1].CallbackSet=0;
		#ifndef BUILD_FLOAT
		LVC_Mixer_Init(&pBypassMixer_Instance->MixerStream[1],0x00007FFF,0x00007FFF);
		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],
		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pInstance->Params.SampleRate,2);
		#else
		LVC_Mixer_Init(&pBypassMixer_Instance->MixerStream[1], 1.0, 1.0);
		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],
		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pInstance->Params.SampleRate, 2);
		#endif

		return(LVDBE_SUCCESS);
		}