Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5ca88423 authored by Andy Hung's avatar Andy Hung Committed by Automerger Merge Worker
Browse files

Merge "lvm: Format the code using clang-format" am: 7ec362b7 am: fb11a864 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/1443655

Change-Id: I533fe8129825475e8be9d5d942abc377ee4f6f65
parents 7057ee25 fb11a864

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;