lvm: Format the code using clang-format (0bbbe07c) · Commits · e / os / android_frameworks_av

media/libeffects/lvm/.clang-format

0 → 100644

+15 −0

Original line number	Original line	Diff line number	Diff line
			BasedOnStyle: Google
			Standard: Cpp11
			AccessModifierOffset: -2
			AllowShortFunctionsOnASingleLine: Inline
			ColumnLimit: 100
			CommentPragmas: NOLINT:.*
			DerivePointerAlignment: false
			IncludeBlocks: Preserve
			IndentWidth: 4
			ContinuationIndentWidth: 8
			PointerAlignment: Left
			TabWidth: 4
			UseTab: Never
			# Following are specific to libeffects/lvm
			SortIncludes: false

media/libeffects/lvm/lib/Android.bp

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -132,7 +132,7 @@ cc_library_static {
	"liblog",		"liblog",
	],		],
	header_libs: [		header_libs: [
	"libhardware_headers"		"libhardware_headers",
	],		],
	cppflags: [		cppflags: [
	"-fvisibility=hidden",		"-fvisibility=hidden",

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

+62 −79

Original line number	Original line	Diff line number	Diff line
	@@ -86,32 +86,24 @@
	typedef void* LVDBE_Handle_t;		typedef void* LVDBE_Handle_t;

	/* Operating modes */		/* Operating modes */
	typedef enum		typedef enum { LVDBE_OFF = 0, LVDBE_ON = 1, LVDBE_MODE_MAX = LVM_MAXINT_32 } LVDBE_Mode_en;
	{
	LVDBE_OFF = 0,
	LVDBE_ON = 1,
	LVDBE_MODE_MAX = LVM_MAXINT_32
	} LVDBE_Mode_en;

	/* High pass filter */		/* High pass filter */
	typedef enum		typedef enum {
	{
	LVDBE_HPF_OFF = 0,		LVDBE_HPF_OFF = 0,
	LVDBE_HPF_ON = 1,		LVDBE_HPF_ON = 1,
	LVDBE_HPF_MAX = LVM_MAXINT_32		LVDBE_HPF_MAX = LVM_MAXINT_32
	} LVDBE_FilterSelect_en;		} LVDBE_FilterSelect_en;

	/* Volume control */		/* Volume control */
	typedef enum		typedef enum {
	{
	LVDBE_VOLUME_OFF = 0,		LVDBE_VOLUME_OFF = 0,
	LVDBE_VOLUME_ON = 1,		LVDBE_VOLUME_ON = 1,
	LVDBE_VOLUME_MAX = LVM_MAXINT_32		LVDBE_VOLUME_MAX = LVM_MAXINT_32
	} LVDBE_Volume_en;		} LVDBE_Volume_en;

	/* Function return status */		/* Function return status */
	typedef enum		typedef enum {
	{
	LVDBE_SUCCESS = 0, /* Successful return from a routine */		LVDBE_SUCCESS = 0, /* Successful return from a routine */
	LVDBE_NULLADDRESS = 1, /* NULL allocation address */		LVDBE_NULLADDRESS = 1, /* NULL allocation address */
	LVDBE_TOOMANYSAMPLES = 2, /* Maximum block size exceeded */		LVDBE_TOOMANYSAMPLES = 2, /* Maximum block size exceeded */
	@@ -147,8 +139,7 @@ typedef enum
	#define LVDBE_CAP_CENTRE_78Hz 4		#define LVDBE_CAP_CENTRE_78Hz 4
	#define LVDBE_CAP_CENTRE_90Hz 8		#define LVDBE_CAP_CENTRE_90Hz 8

	typedef enum		typedef enum {
	{
	LVDBE_CENTRE_55HZ = 0,		LVDBE_CENTRE_55HZ = 0,
	LVDBE_CENTRE_66HZ = 1,		LVDBE_CENTRE_66HZ = 1,
	LVDBE_CENTRE_78HZ = 2,		LVDBE_CENTRE_78HZ = 2,
	@@ -173,8 +164,7 @@ typedef enum
	#define LVDBE_CAP_FS_176400 2048		#define LVDBE_CAP_FS_176400 2048
	#define LVDBE_CAP_FS_192000 4096		#define LVDBE_CAP_FS_192000 4096

	typedef enum		typedef enum {
	{
	LVDBE_FS_8000 = 0,		LVDBE_FS_8000 = 0,
	LVDBE_FS_11025 = 1,		LVDBE_FS_11025 = 1,
	LVDBE_FS_12000 = 2,		LVDBE_FS_12000 = 2,
	@@ -198,8 +188,7 @@ typedef enum
	/****************************************************************************************/		/****************************************************************************************/

	/* Parameter structure */		/* Parameter structure */
	typedef struct		typedef struct {
	{
	LVDBE_Mode_en OperatingMode;		LVDBE_Mode_en OperatingMode;
	LVDBE_Fs_en SampleRate;		LVDBE_Fs_en SampleRate;
	LVM_INT16 EffectLevel;		LVM_INT16 EffectLevel;
	@@ -213,8 +202,7 @@ typedef struct
	} LVDBE_Params_t;		} LVDBE_Params_t;

	/* Capability structure */		/* Capability structure */
	typedef struct		typedef struct {
	{
	LVM_UINT16 SampleRate; /* Sampling rate capabilities */		LVM_UINT16 SampleRate; /* Sampling rate capabilities */
	LVM_UINT16 CentreFrequency; /* Centre frequency capabilities */		LVM_UINT16 CentreFrequency; /* Centre frequency capabilities */
	LVM_UINT16 MaxBlockSize; /* Maximum block size in sample pairs */		LVM_UINT16 MaxBlockSize; /* Maximum block size in sample pairs */
	@@ -246,8 +234,7 @@ typedef struct
	/* 1. This function must not be interrupted by the LVDBE_Process function */		/* 1. This function must not be interrupted by the LVDBE_Process function */
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/
	LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,		LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t* phInstance, LVDBE_Capabilities_t* pCapabilities,
	LVDBE_Capabilities_t *pCapabilities,
	void* pScratch);		void* pScratch);

	/****************************************************************************************/		/****************************************************************************************/
	@@ -283,8 +270,7 @@ void LVDBE_DeInit(LVDBE_Handle_t *phInstance);
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/

	LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams);
	LVDBE_Params_t *pParams);

	/****************************************************************************************/		/****************************************************************************************/
	/* */		/* */
	@@ -346,8 +332,7 @@ LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/

	LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,		LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams);
	LVDBE_Params_t *pParams);

	/****************************************************************************************/		/****************************************************************************************/
	/* */		/* */
	@@ -369,9 +354,7 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	/* NOTES: */		/* NOTES: */
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/
	LVDBE_ReturnStatus_en LVDBE_Process(LVDBE_Handle_t hInstance,		LVDBE_ReturnStatus_en LVDBE_Process(LVDBE_Handle_t hInstance, const LVM_FLOAT* pInData,
	const LVM_FLOAT *pInData,		LVM_FLOAT* pOutData, LVM_UINT16 NumSamples);
	LVM_FLOAT *pOutData,
	LVM_UINT16 NumSamples);

	#endif /* __LVDBE_H__ */		#endif /* __LVDBE_H__ */

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

+66 −96

Original line number	Original line	Diff line number	Diff line
	@@ -47,10 +47,7 @@
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/

	LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams) {
	LVDBE_Params_t *pParams)
	{

	LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;

	*pParams = pInstance->Params;		*pParams = pInstance->Params;
	@@ -78,9 +75,7 @@ LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
	/************************************************************************************/		/************************************************************************************/

	LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,		LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
	LVDBE_Capabilities_t *pCapabilities)		LVDBE_Capabilities_t* pCapabilities) {
	{

	LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;

	*pCapabilities = pInstance->Capabilities;		*pCapabilities = pInstance->Capabilities;
	@@ -101,14 +96,12 @@ LVDBE_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
	/* */		/* */
	/************************************************************************************/		/************************************************************************************/

	void LVDBE_SetFilters(LVDBE_Instance_t *pInstance,		void LVDBE_SetFilters(LVDBE_Instance_t* pInstance, LVDBE_Params_t* pParams) {
	LVDBE_Params_t *pParams)
	{

	/*		/*
	* Calculate the table offsets		* Calculate the table offsets
	*/		*/
	LVM_UINT16 Offset = (LVM_UINT16)((LVM_UINT16)pParams->SampleRate + \		LVM_UINT16 Offset =
			(LVM_UINT16)((LVM_UINT16)pParams->SampleRate +
	(LVM_UINT16)(pParams->CentreFrequency * (1 + LVDBE_FS_192000)));		(LVM_UINT16)(pParams->CentreFrequency * (1 + LVDBE_FS_192000)));

	/*		/*
	@@ -145,29 +138,26 @@ void LVDBE_SetFilters(LVDBE_Instance_t *pInstance,
	/* */		/* */
	/************************************************************************************/		/************************************************************************************/

	void LVDBE_SetAGC(LVDBE_Instance_t *pInstance,		void LVDBE_SetAGC(LVDBE_Instance_t* pInstance, LVDBE_Params_t* pParams) {
	LVDBE_Params_t *pParams)
	{

	/*		/*
	* Get the attack and decay time constants		* Get the attack and decay time constants
	*/		*/
	pInstance->pData->AGCInstance.AGC_Attack = LVDBE_AGC_ATTACK_Table[(LVM_UINT16)pParams->SampleRate]; /* Attack multiplier */		pInstance->pData->AGCInstance.AGC_Attack =
	pInstance->pData->AGCInstance.AGC_Decay = LVDBE_AGC_DECAY_Table[(LVM_UINT16)pParams->SampleRate]; /* Decay multipler */		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		* Get the boost gain
	*/		*/
	if (pParams->HPFSelect == LVDBE_HPF_ON)		if (pParams->HPFSelect == LVDBE_HPF_ON) {
	{		pInstance->pData->AGCInstance.AGC_MaxGain =
	pInstance->pData->AGCInstance.AGC_MaxGain = LVDBE_AGC_HPFGAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter on */		LVDBE_AGC_HPFGAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter on */
	}		} else {
	else		pInstance->pData->AGCInstance.AGC_MaxGain =
	{		LVDBE_AGC_GAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter off */
	pInstance->pData->AGCInstance.AGC_MaxGain = LVDBE_AGC_GAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter off */
	}		}
	pInstance->pData->AGCInstance.AGC_Target = AGC_TARGETLEVEL;		pInstance->pData->AGCInstance.AGC_Target = AGC_TARGETLEVEL;

	}		}

	/************************************************************************************/		/************************************************************************************/
	@@ -193,10 +183,7 @@ void LVDBE_SetAGC(LVDBE_Instance_t *pInstance,
	/* */		/* */
	/************************************************************************************/		/************************************************************************************/

	void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,		void LVDBE_SetVolume(LVDBE_Instance_t* pInstance, LVDBE_Params_t* pParams) {
	LVDBE_Params_t *pParams)
	{

	LVM_UINT16 dBShifts; /* 6dB shifts */		LVM_UINT16 dBShifts; /* 6dB shifts */
	LVM_UINT16 dBOffset; /* Table offset */		LVM_UINT16 dBOffset; /* Table offset */
	LVM_INT16 Volume = 0; /* Required volume in dBs */		LVM_INT16 Volume = 0; /* Required volume in dBs */
	@@ -205,17 +192,13 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
	/*		/*
	* Apply the volume if enabled		* Apply the volume if enabled
	*/		*/
	if (pParams->VolumeControl == LVDBE_VOLUME_ON)		if (pParams->VolumeControl == LVDBE_VOLUME_ON) {
	{
	/*		/*
	* Limit the gain to the maximum allowed		* Limit the gain to the maximum allowed
	*/		*/
	if (pParams->VolumedB > VOLUME_MAX)		if (pParams->VolumedB > VOLUME_MAX) {
	{
	Volume = VOLUME_MAX;		Volume = VOLUME_MAX;
	}		} else {
	else
	{
	Volume = pParams->VolumedB;		Volume = pParams->VolumedB;
	}		}
	}		}
	@@ -232,27 +215,23 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
	*/		*/
	pInstance->pData->AGCInstance.Target = (LVDBE_VolumeTable[dBOffset]);		pInstance->pData->AGCInstance.Target = (LVDBE_VolumeTable[dBOffset]);
	pInstance->pData->AGCInstance.Target = pInstance->pData->AGCInstance.Target / dBShifts_fac;		pInstance->pData->AGCInstance.Target = pInstance->pData->AGCInstance.Target / dBShifts_fac;
	pInstance->pData->AGCInstance.VolumeTC = LVDBE_VolumeTCTable[(LVM_UINT16)pParams->SampleRate]; /* Volume update time constant */		pInstance->pData->AGCInstance.VolumeTC =
			LVDBE_VolumeTCTable[(LVM_UINT16)pParams->SampleRate]; /* Volume update time constant */

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

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

	/****************************************************************************************/		/****************************************************************************************/
	@@ -292,10 +271,7 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/

	LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,		LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams) {
	LVDBE_Params_t *pParams)
	{

	LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;
	LVMixer3_2St_FLOAT_st* pBypassMixer_Instance = &pInstance->pData->BypassMixer;		LVMixer3_2St_FLOAT_st* pBypassMixer_Instance = &pInstance->pData->BypassMixer;

	@@ -303,8 +279,7 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	* Update the filters		* Update the filters
	*/		*/
	if ((pInstance->Params.SampleRate != pParams->SampleRate) \|\|		if ((pInstance->Params.SampleRate != pParams->SampleRate) \|\|
	(pInstance->Params.CentreFrequency != pParams->CentreFrequency))		(pInstance->Params.CentreFrequency != pParams->CentreFrequency)) {
	{
	LVDBE_SetFilters(pInstance, /* Instance pointer */		LVDBE_SetFilters(pInstance, /* Instance pointer */
	pParams); /* New parameters */		pParams); /* New parameters */
	}		}
	@@ -314,16 +289,14 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	*/		*/
	if ((pInstance->Params.SampleRate != pParams->SampleRate) \|\|		if ((pInstance->Params.SampleRate != pParams->SampleRate) \|\|
	(pInstance->Params.EffectLevel != pParams->EffectLevel) \|\|		(pInstance->Params.EffectLevel != pParams->EffectLevel) \|\|
	(pInstance->Params.HPFSelect != pParams->HPFSelect))		(pInstance->Params.HPFSelect != pParams->HPFSelect)) {
	{
	LVDBE_SetAGC(pInstance, /* Instance pointer */		LVDBE_SetAGC(pInstance, /* Instance pointer */
	pParams); /* New parameters */		pParams); /* New parameters */
	LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0],		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0], LVDBE_BYPASS_MIXER_TC,
	LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);		(LVM_Fs_en)pParams->SampleRate, 2);

	LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],
	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);
	}		}

	/*		/*
	@@ -332,19 +305,16 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	if ((pInstance->Params.VolumedB != pParams->VolumedB) \|\|		if ((pInstance->Params.VolumedB != pParams->VolumedB) \|\|
	(pInstance->Params.SampleRate != pParams->SampleRate) \|\|		(pInstance->Params.SampleRate != pParams->SampleRate) \|\|
	(pInstance->Params.HeadroomdB != pParams->HeadroomdB) \|\|		(pInstance->Params.HeadroomdB != pParams->HeadroomdB) \|\|
	(pInstance->Params.VolumeControl != pParams->VolumeControl))		(pInstance->Params.VolumeControl != pParams->VolumeControl)) {
	{
	LVDBE_SetVolume(pInstance, /* Instance pointer */		LVDBE_SetVolume(pInstance, /* Instance pointer */
	pParams); /* New parameters */		pParams); /* New parameters */
	}		}

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

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

+36 −44

Original line number	Original line	Diff line number	Diff line
	@@ -45,11 +45,8 @@
	/* 1. This function must not be interrupted by the LVDBE_Process function */		/* 1. This function must not be interrupted by the LVDBE_Process function */
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/
	LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,		LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t* phInstance, LVDBE_Capabilities_t* pCapabilities,
	LVDBE_Capabilities_t *pCapabilities,		void* pScratch) {
	void *pScratch)
	{

	LVDBE_Instance_t* pInstance;		LVDBE_Instance_t* pInstance;
	LVMixer3_1St_FLOAT_st* pMixer_Instance;		LVMixer3_1St_FLOAT_st* pMixer_Instance;
	LVMixer3_2St_FLOAT_st* pBypassMixer_Instance;		LVMixer3_2St_FLOAT_st* pBypassMixer_Instance;
	@@ -58,12 +55,10 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
	/*		/*
	* Create the instance handle if not already initialised		* Create the instance handle if not already initialised
	*/		*/
	if (*phInstance == LVM_NULL)		if (*phInstance == LVM_NULL) {
	{
	phInstance = calloc(1, sizeof(pInstance));		phInstance = calloc(1, sizeof(pInstance));
	}		}
	if (*phInstance == LVM_NULL)		if (*phInstance == LVM_NULL) {
	{
	return LVDBE_NULLADDRESS;		return LVDBE_NULLADDRESS;
	}		}
	pInstance = (LVDBE_Instance_t)phInstance;		pInstance = (LVDBE_Instance_t)phInstance;
	@@ -91,13 +86,11 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
	* Create pointer to data and coef memory		* Create pointer to data and coef memory
	*/		*/
	pInstance->pData = (LVDBE_Data_FLOAT_t)calloc(1, sizeof((pInstance->pData)));		pInstance->pData = (LVDBE_Data_FLOAT_t)calloc(1, sizeof((pInstance->pData)));
	if (pInstance->pData == NULL)		if (pInstance->pData == NULL) {
	{
	return LVDBE_NULLADDRESS;		return LVDBE_NULLADDRESS;
	}		}
	pInstance->pCoef = (LVDBE_Coef_FLOAT_t)calloc(1, sizeof((pInstance->pCoef)));		pInstance->pCoef = (LVDBE_Coef_FLOAT_t)calloc(1, sizeof((pInstance->pCoef)));
	if (pInstance->pCoef == NULL)		if (pInstance->pCoef == NULL) {
	{
	return LVDBE_NULLADDRESS;		return LVDBE_NULLADDRESS;
	}		}

	@@ -152,8 +145,8 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
	pBypassMixer_Instance->MixerStream[0].CallbackSet = 0;		pBypassMixer_Instance->MixerStream[0].CallbackSet = 0;

	LVC_Mixer_Init(&pBypassMixer_Instance->MixerStream[0], 0, 0);		LVC_Mixer_Init(&pBypassMixer_Instance->MixerStream[0], 0, 0);
	LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0],		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0], LVDBE_BYPASS_MIXER_TC,
	LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pInstance->Params.SampleRate,2);		(LVM_Fs_en)pInstance->Params.SampleRate, 2);

	/*		/*
	* Setup the mixer gain for the unprocessed path		* Setup the mixer gain for the unprocessed path
	@@ -163,8 +156,8 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
	pBypassMixer_Instance->MixerStream[1].pCallBack = LVM_NULL;		pBypassMixer_Instance->MixerStream[1].pCallBack = LVM_NULL;
	pBypassMixer_Instance->MixerStream[1].CallbackSet = 0;		pBypassMixer_Instance->MixerStream[1].CallbackSet = 0;
	LVC_Mixer_Init(&pBypassMixer_Instance->MixerStream[1], 1.0, 1.0);		LVC_Mixer_Init(&pBypassMixer_Instance->MixerStream[1], 1.0, 1.0);
	LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1], LVDBE_BYPASS_MIXER_TC,
	LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pInstance->Params.SampleRate, 2);		(LVM_Fs_en)pInstance->Params.SampleRate, 2);

	return (LVDBE_SUCCESS);		return (LVDBE_SUCCESS);
	}		}
	@@ -180,8 +173,7 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
	/* phInstance Pointer to instance handle */		/* phInstance Pointer to instance handle */
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/
	void LVDBE_DeInit(LVDBE_Handle_t *phInstance)		void LVDBE_DeInit(LVDBE_Handle_t* phInstance) {
	{
	LVDBE_Instance_t* pInstance = (LVDBE_Instance_t)phInstance;		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t)phInstance;
	if (pInstance == LVM_NULL) {		if (pInstance == LVM_NULL) {
	return;		return;