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

media/libeffects/lvm/lib/Android.bp

+0 −4

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

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

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

	"-Wall",		"-Wall",
	"-Werror",		"-Werror",

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

+0 −33

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



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

	#include "LVM_Types.h"		#include "LVM_Types.h"


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


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


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


	/* High pass filter */		/* High pass filter */
	typedef enum		typedef enum
	{		{
	@@ -110,7 +104,6 @@ typedef enum
	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
	{		{
	@@ -119,7 +112,6 @@ typedef enum
	LVDBE_VOLUME_MAX = LVM_MAXINT_32		LVDBE_VOLUME_MAX = LVM_MAXINT_32
	} LVDBE_Volume_en;		} LVDBE_Volume_en;


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

	} LVDBE_MemoryTypes_en;		} LVDBE_MemoryTypes_en;


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


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


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

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


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


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


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

	} LVDBE_Params_t;		} LVDBE_Params_t;


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


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


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


	/****************************************************************************************/		/****************************************************************************************/
	/* */		/* */
	/* FUNCTION: LVDBE_GetParameters */		/* 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_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
	LVDBE_Params_t *pParams);		LVDBE_Params_t *pParams);


	/****************************************************************************************/		/****************************************************************************************/
	/* */		/* */
	/* FUNCTION: LVDBE_GetCapabilities */		/* 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_ReturnStatus_en LVDBE_GetCapabilities(LVDBE_Handle_t hInstance,
	LVDBE_Capabilities_t *pCapabilities);		LVDBE_Capabilities_t *pCapabilities);


	/****************************************************************************************/		/****************************************************************************************/
	/* */		/* */
	/* FUNCTION: LVDBE_Control */		/* 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_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	LVDBE_Params_t *pParams);		LVDBE_Params_t *pParams);


	/****************************************************************************************/		/****************************************************************************************/
	/* */		/* */
	/* FUNCTION: LVDBE_Process */		/* FUNCTION: LVDBE_Process */
	@@ -462,17 +437,9 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	/* NOTES: */		/* NOTES: */
	/* */		/* */
	/****************************************************************************************/		/****************************************************************************************/
	#ifdef BUILD_FLOAT
	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_FLOAT *pOutData,
	LVM_UINT16 NumSamples);		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__ */		#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	Original line	Diff line number	Diff line
	@@ -58,7 +58,6 @@ LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
	return(LVDBE_SUCCESS);		return(LVDBE_SUCCESS);
	}		}


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


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

	#if defined(BUILD_FLOAT) && defined(HIGHER_FS)
	/*		/*
	* 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)));
	#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		* 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 */		LoadConst_Float(0, /* Clear the history, value 0 */
	(LVM_FLOAT )&pInstance->pData->HPFTaps, / Destination Cast to void: \		(LVM_FLOAT )&pInstance->pData->HPFTaps, / Destination Cast to void: \
	no dereferencing in function*/		no dereferencing in function*/
	sizeof(pInstance->pData->HPFTaps) / sizeof(LVM_FLOAT)); /* Number of words */		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 */		BQ_2I_D32F32Cll_TRC_WRA_01_Init(&pInstance->pCoef->HPFInstance, /* Initialise the filter */
	&pInstance->pData->HPFTaps,		&pInstance->pData->HPFTaps,
	(BQ_FLOAT_Coefs_t *)&LVDBE_HPF_Table[Offset]);		(BQ_FLOAT_Coefs_t *)&LVDBE_HPF_Table[Offset]);
	#endif


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



	/************************************************************************************/		/************************************************************************************/
	/* */		/* */
	/* FUNCTION: LVDBE_SetAGC */		/* 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_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 */		pInstance->pData->AGCInstance.AGC_Decay = LVDBE_AGC_DECAY_Table[(LVM_UINT16)pParams->SampleRate]; /* Decay multipler */


	/*		/*
	* Get the boost gain		* 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 */		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;		pInstance->pData->AGCInstance.AGC_Target = AGC_TARGETLEVEL;

	}		}


	/************************************************************************************/		/************************************************************************************/
	/* */		/* */
	/* FUNCTION: LVDBE_SetVolume */		/* FUNCTION: LVDBE_SetVolume */
	@@ -247,9 +203,7 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
	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 */

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


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

	#ifdef BUILD_FLOAT
	dBShifts_fac = (LVM_FLOAT)(1 << dBShifts);		dBShifts_fac = (LVM_FLOAT)(1 << dBShifts);
	#endif
	/*		/*
	* When DBE is enabled use AGC volume		* 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 = (LVDBE_VolumeTable[dBOffset]);
	pInstance->pData->AGCInstance.Target = pInstance->pData->AGCInstance.Target / dBShifts_fac;		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 */		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		* When DBE is disabled use the bypass volume control
	*/		*/
	if(dBShifts > 0)		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],		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],
	LVDBE_VolumeTable[dBOffset] / dBShifts_fac);		LVDBE_VolumeTable[dBOffset] / dBShifts_fac);
	#endif
	}		}
	else		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],		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],
	LVDBE_VolumeTable[dBOffset]);		LVDBE_VolumeTable[dBOffset]);
	#endif
	}		}

	pInstance->pData->BypassVolume.MixerStream[0].CallbackSet = 1;		pInstance->pData->BypassVolume.MixerStream[0].CallbackSet = 1;
	#ifndef BUILD_FLOAT
	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,		(LVM_Fs_en)pInstance->Params.SampleRate,
	2);		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 */		/* FUNCTION: LVDBE_Control */
	@@ -372,12 +299,7 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
	{		{

	LVDBE_Instance_t pInstance =(LVDBE_Instance_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;		LVMixer3_2St_FLOAT_st *pBypassMixer_Instance = &pInstance->pData->BypassMixer;
	#endif


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


	/*		/*
	* Update the AGC is the effect level has changed		* 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 */		LVDBE_SetAGC(pInstance, /* Instance pointer */
	pParams); /* New parameters */		pParams); /* New parameters */
	#ifndef BUILD_FLOAT
	LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0],		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[0],
	LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);

	LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1],
	LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pParams->SampleRate, 2);		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		* 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)		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[0], 0);
	LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1], 1.0f);		LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1], 1.0f);
	#endif
	}		}
	if (pInstance->Params.OperatingMode==LVDBE_OFF && pParams->OperatingMode==LVDBE_ON)		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[0], 1.0f);
	LVC_Mixer_SetTarget(&pInstance->pData->BypassMixer.MixerStream[1], 0);		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;		pInstance->Params = *pParams;


	return(LVDBE_SUCCESS);		return(LVDBE_SUCCESS);
	}		}

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

+0 −43

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


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


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

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


	/*		/*
	* Set the instance handle if not already initialised		* 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;		pInstance =(LVDBE_Instance_t )phInstance;


	/*		/*
	* Check the memory table for NULL pointers and incorrectly aligned data		* 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		* Save the memory table in the instance structure
	*/		*/
	pInstance->Capabilities = *pCapabilities;		pInstance->Capabilities = *pCapabilities;


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


	/*		/*
	* Set the default instance parameters		* 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.VolumeControl = LVDBE_VOLUME_OFF;
	pInstance->Params.VolumedB = 0;		pInstance->Params.VolumedB = 0;


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


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


	/*		/*
	* Initialise the AGC		* 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		// initialize the mixer with some fixes values since otherwise LVDBE_SetVolume ends up
	// reading uninitialized data		// reading uninitialized data
	pMixer_Instance = &pInstance->pData->BypassVolume;		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);		LVC_Mixer_Init(&pMixer_Instance->MixerStream[0], 1.0, 1.0);
	#endif

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

	pInstance->pData->AGCInstance.Volume = pInstance->pData->AGCInstance.Target;		pInstance->pData->AGCInstance.Volume = pInstance->pData->AGCInstance.Target;
	/* Initialise as the target */		/* Initialise as the target */
	#ifndef BUILD_FLOAT
	MixGain = LVC_Mixer_GetTarget(&pMixer_Instance->MixerStream[0]);		MixGain = LVC_Mixer_GetTarget(&pMixer_Instance->MixerStream[0]);
	LVC_Mixer_Init(&pMixer_Instance->MixerStream[0], MixGain, MixGain);		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 */		/* Configure the mixer process path */
	pMixer_Instance->MixerStream[0].CallbackParam = 0;		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].pCallbackHandle = LVM_NULL;
	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;
	#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_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,(LVM_Fs_en)pInstance->Params.SampleRate, 2);		LVDBE_BYPASS_MIXER_TC,(LVM_Fs_en)pInstance->Params.SampleRate, 2);
	#endif

	return(LVDBE_SUCCESS);		return(LVDBE_SUCCESS);
	}		}