Merge "lvm: Format the code using clang-format" am: 7ec362b7ec am: fb11a86421... (6c5a0eeb) · Commits · e / os / android_frameworks_av

media/libeffects/lvm/.clang-format

0 → 100644

+15 −0

Original line number	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	Diff line number	Diff line
		@@ -132,7 +132,7 @@ cc_library_static {
		"liblog",
		],
		header_libs: [
		"libhardware_headers"
		"libhardware_headers",
		],
		cppflags: [
		"-fvisibility=hidden",

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

+62 −79

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

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

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

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

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

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

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

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

		/* Capability structure */
		typedef struct
		{
		typedef struct {
		LVM_UINT16 SampleRate; /* Sampling rate capabilities */
		LVM_UINT16 CentreFrequency; /* Centre frequency capabilities */
		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 */
		/* */
		/****************************************************************************************/
		LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		LVDBE_Capabilities_t *pCapabilities,
		LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t* phInstance, LVDBE_Capabilities_t* pCapabilities,
		void* pScratch);

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

		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
		LVDBE_Params_t *pParams);
		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance, 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_Params_t *pParams);
		LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams);

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

		#endif /* __LVDBE_H__ */

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

+66 −96

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

		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance,
		LVDBE_Params_t *pParams)
		{

		LVDBE_ReturnStatus_en LVDBE_GetParameters(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams) {
		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;

		*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_Capabilities_t *pCapabilities)
		{

		LVDBE_Capabilities_t* pCapabilities) {
		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;

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

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

		void LVDBE_SetFilters(LVDBE_Instance_t* pInstance, LVDBE_Params_t* pParams) {
		/*
		* 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)));

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

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

		void LVDBE_SetAGC(LVDBE_Instance_t* pInstance, LVDBE_Params_t* pParams) {
		/*
		* 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_Decay = LVDBE_AGC_DECAY_Table[(LVM_UINT16)pParams->SampleRate]; /* Decay multipler */
		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
		*/
		if (pParams->HPFSelect == LVDBE_HPF_ON)
		{
		pInstance->pData->AGCInstance.AGC_MaxGain = LVDBE_AGC_HPFGAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter on */
		}
		else
		{
		pInstance->pData->AGCInstance.AGC_MaxGain = LVDBE_AGC_GAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter off */
		if (pParams->HPFSelect == LVDBE_HPF_ON) {
		pInstance->pData->AGCInstance.AGC_MaxGain =
		LVDBE_AGC_HPFGAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter on */
		} else {
		pInstance->pData->AGCInstance.AGC_MaxGain =
		LVDBE_AGC_GAIN_Table[(LVM_UINT16)pParams->EffectLevel]; /* High pass filter off */
		}
		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,
		LVDBE_Params_t *pParams)
		{

		void LVDBE_SetVolume(LVDBE_Instance_t* pInstance, LVDBE_Params_t* pParams) {
		LVM_UINT16 dBShifts; /* 6dB shifts */
		LVM_UINT16 dBOffset; /* Table offset */
		LVM_INT16 Volume = 0; /* Required volume in dBs */
		@@ -205,17 +192,13 @@ void LVDBE_SetVolume(LVDBE_Instance_t *pInstance,
		/*
		* Apply the volume if enabled
		*/
		if (pParams->VolumeControl == LVDBE_VOLUME_ON)
		{
		if (pParams->VolumeControl == LVDBE_VOLUME_ON) {
		/*
		* Limit the gain to the maximum allowed
		*/
		if (pParams->VolumedB > VOLUME_MAX)
		{
		if (pParams->VolumedB > VOLUME_MAX) {
		Volume = VOLUME_MAX;
		}
		else
		{
		} else {
		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 = 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
		*/
		if(dBShifts > 0)
		{
		if (dBShifts > 0) {
		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_VolumeTable[dBOffset] / dBShifts_fac);
		}
		else
		{
		} else {
		LVC_Mixer_SetTarget(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_VolumeTable[dBOffset]);
		}

		pInstance->pData->BypassVolume.MixerStream[0].CallbackSet = 1;
		LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->pData->BypassVolume.MixerStream[0],
		LVDBE_MIXER_TC,
		(LVM_Fs_en)pInstance->Params.SampleRate,
		2);
		LVDBE_MIXER_TC, (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_Params_t *pParams)
		{

		LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance, LVDBE_Params_t* pParams) {
		LVDBE_Instance_t* pInstance = (LVDBE_Instance_t*)hInstance;
		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
		*/
		if ((pInstance->Params.SampleRate != pParams->SampleRate) \|\|
		(pInstance->Params.CentreFrequency != pParams->CentreFrequency))
		{
		(pInstance->Params.CentreFrequency != pParams->CentreFrequency)) {
		LVDBE_SetFilters(pInstance, /* Instance pointer */
		pParams); /* New parameters */
		}
		@@ -314,16 +289,14 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		*/
		if ((pInstance->Params.SampleRate != pParams->SampleRate) \|\|
		(pInstance->Params.EffectLevel != pParams->EffectLevel) \|\|
		(pInstance->Params.HPFSelect != pParams->HPFSelect))
		{
		(pInstance->Params.HPFSelect != pParams->HPFSelect)) {
		LVDBE_SetAGC(pInstance, /* Instance pointer */
		pParams); /* New parameters */
		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);
		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);
		}

		/*
		@@ -332,19 +305,16 @@ LVDBE_ReturnStatus_en LVDBE_Control(LVDBE_Handle_t hInstance,
		if ((pInstance->Params.VolumedB != pParams->VolumedB) \|\|
		(pInstance->Params.SampleRate != pParams->SampleRate) \|\|
		(pInstance->Params.HeadroomdB != pParams->HeadroomdB) \|\|
		(pInstance->Params.VolumeControl != pParams->VolumeControl))
		{
		(pInstance->Params.VolumeControl != pParams->VolumeControl)) {
		LVDBE_SetVolume(pInstance, /* Instance pointer */
		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[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[1], 0);
		}

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

+36 −44

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

		LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t* phInstance, LVDBE_Capabilities_t* pCapabilities,
		void* pScratch) {
		LVDBE_Instance_t* pInstance;
		LVMixer3_1St_FLOAT_st* pMixer_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
		*/
		if (*phInstance == LVM_NULL)
		{
		if (*phInstance == LVM_NULL) {
		phInstance = calloc(1, sizeof(pInstance));
		}
		if (*phInstance == LVM_NULL)
		{
		if (*phInstance == LVM_NULL) {
		return LVDBE_NULLADDRESS;
		}
		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
		*/
		pInstance->pData = (LVDBE_Data_FLOAT_t)calloc(1, sizeof((pInstance->pData)));
		if (pInstance->pData == NULL)
		{
		if (pInstance->pData == NULL) {
		return LVDBE_NULLADDRESS;
		}
		pInstance->pCoef = (LVDBE_Coef_FLOAT_t)calloc(1, sizeof((pInstance->pCoef)));
		if (pInstance->pCoef == NULL)
		{
		if (pInstance->pCoef == NULL) {
		return LVDBE_NULLADDRESS;
		}

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

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

		/*
		* 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].CallbackSet = 0;
		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);
		LVC_Mixer_SetTimeConstant(&pBypassMixer_Instance->MixerStream[1], LVDBE_BYPASS_MIXER_TC,
		(LVM_Fs_en)pInstance->Params.SampleRate, 2);

		return (LVDBE_SUCCESS);
		}
		@@ -180,8 +173,7 @@ LVDBE_ReturnStatus_en LVDBE_Init(LVDBE_Handle_t *phInstance,
		/* 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;
		if (pInstance == LVM_NULL) {
		return;