/*
 * Copyright (C) 2004-2010 NXP Software
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/****************************************************************************************/
/*                                                                                      */
/* Includes                                                                             */
/*                                                                                      */
/****************************************************************************************/

#include "VectorArithmetic.h"
#include "ScalarArithmetic.h"
#include "LVM_Coeffs.h"
#include "LVM_Tables.h"
#include "LVM_Private.h"

#include <log/log.h>

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:           LVM_SetControlParameters                                         */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  Sets or changes the LifeVibes module parameters.                                    */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance          Instance handle                                                  */
/*  pParams            Pointer to a parameter structure                                 */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVM_SUCCESS        Succeeded                                                        */
/*  LVM_NULLADDRESS    When hInstance, pParams or any control pointers are NULL         */
/*  LVM_OUTOFRANGE     When any of the control parameters are out of range              */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1. This function may be interrupted by the LVM_Process function                     */
/*                                                                                      */
/****************************************************************************************/

LVM_ReturnStatus_en LVM_SetControlParameters(LVM_Handle_t hInstance, LVM_ControlParams_t* pParams) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)hInstance;

    if ((pParams == LVM_NULL) || (hInstance == LVM_NULL)) {
        return (LVM_NULLADDRESS);
    }

    pInstance->NewParams = *pParams;

    if (
            /* General parameters */
            ((pParams->OperatingMode != LVM_MODE_OFF) && (pParams->OperatingMode != LVM_MODE_ON)) ||
            ((pParams->SampleRate != LVM_FS_8000) && (pParams->SampleRate != LVM_FS_11025) &&
             (pParams->SampleRate != LVM_FS_12000) && (pParams->SampleRate != LVM_FS_16000) &&
             (pParams->SampleRate != LVM_FS_22050) && (pParams->SampleRate != LVM_FS_24000) &&
             (pParams->SampleRate != LVM_FS_32000) && (pParams->SampleRate != LVM_FS_44100) &&
             (pParams->SampleRate != LVM_FS_48000) && (pParams->SampleRate != LVM_FS_88200) &&
             (pParams->SampleRate != LVM_FS_96000) && (pParams->SampleRate != LVM_FS_176400) &&
             (pParams->SampleRate != LVM_FS_192000)) ||
            ((pParams->SourceFormat != LVM_STEREO) && (pParams->SourceFormat != LVM_MONOINSTEREO) &&
             (pParams->SourceFormat != LVM_MONO) && (pParams->SourceFormat != LVM_MULTICHANNEL)) ||
            (pParams->SpeakerType > LVM_EX_HEADPHONES)) {
        return (LVM_OUTOFRANGE);
    }

    pInstance->Params.NrChannels = pParams->NrChannels;
    pInstance->Params.ChMask = pParams->ChMask;
    /*
     * Cinema Sound parameters
     */
    if ((pParams->VirtualizerOperatingMode != LVM_MODE_OFF) &&
        (pParams->VirtualizerOperatingMode != LVM_MODE_ON)) {
        return (LVM_OUTOFRANGE);
    }

    if (pParams->VirtualizerType != LVM_CONCERTSOUND) {
        return (LVM_OUTOFRANGE);
    }

    if (pParams->VirtualizerReverbLevel > LVM_VIRTUALIZER_MAX_REVERB_LEVEL) {
        return (LVM_OUTOFRANGE);
    }

    if (pParams->CS_EffectLevel < LVM_CS_MIN_EFFECT_LEVEL) {
        return (LVM_OUTOFRANGE);
    }

    /*
     * N-Band Equalizer
     */
    if (pParams->EQNB_NBands > pInstance->InstParams.EQNB_NumBands) {
        return (LVM_OUTOFRANGE);
    }

    /* Definition pointer */
    if ((pParams->pEQNB_BandDefinition == LVM_NULL) && (pParams->EQNB_NBands != 0)) {
        return (LVM_NULLADDRESS);
    }

    /*
     * Copy the filter definitions for the Equaliser
     */
    {
        LVM_INT16 i;

        if (pParams->EQNB_NBands != 0) {
            for (i = 0; i < pParams->EQNB_NBands; i++) {
                pInstance->pEQNB_BandDefs[i] = pParams->pEQNB_BandDefinition[i];
            }
            pInstance->NewParams.pEQNB_BandDefinition = pInstance->pEQNB_BandDefs;
        }
    }
    if (/* N-Band Equaliser parameters */
        ((pParams->EQNB_OperatingMode != LVM_EQNB_OFF) &&
         (pParams->EQNB_OperatingMode != LVM_EQNB_ON)) ||
        (pParams->EQNB_NBands > pInstance->InstParams.EQNB_NumBands)) {
        return (LVM_OUTOFRANGE);
    }
    /* Band parameters*/
    {
        LVM_INT16 i;
        for (i = 0; i < pParams->EQNB_NBands; i++) {
            if (((pParams->pEQNB_BandDefinition[i].Frequency < LVM_EQNB_MIN_BAND_FREQ) ||
                 (pParams->pEQNB_BandDefinition[i].Frequency > LVM_EQNB_MAX_BAND_FREQ)) ||
                ((pParams->pEQNB_BandDefinition[i].Gain < LVM_EQNB_MIN_BAND_GAIN) ||
                 (pParams->pEQNB_BandDefinition[i].Gain > LVM_EQNB_MAX_BAND_GAIN)) ||
                ((pParams->pEQNB_BandDefinition[i].QFactor < LVM_EQNB_MIN_QFACTOR) ||
                 (pParams->pEQNB_BandDefinition[i].QFactor > LVM_EQNB_MAX_QFACTOR))) {
                return (LVM_OUTOFRANGE);
            }
        }
    }

    /*
     * Bass Enhancement parameters
     */
    if (((pParams->BE_OperatingMode != LVM_BE_OFF) && (pParams->BE_OperatingMode != LVM_BE_ON)) ||
        ((pParams->BE_EffectLevel < LVM_BE_MIN_EFFECTLEVEL) ||
         (pParams->BE_EffectLevel > LVM_BE_MAX_EFFECTLEVEL)) ||
        ((pParams->BE_CentreFreq != LVM_BE_CENTRE_55Hz) &&
         (pParams->BE_CentreFreq != LVM_BE_CENTRE_66Hz) &&
         (pParams->BE_CentreFreq != LVM_BE_CENTRE_78Hz) &&
         (pParams->BE_CentreFreq != LVM_BE_CENTRE_90Hz)) ||
        ((pParams->BE_HPF != LVM_BE_HPF_OFF) && (pParams->BE_HPF != LVM_BE_HPF_ON))) {
        return (LVM_OUTOFRANGE);
    }

    /*
     * Volume Control parameters
     */
    if ((pParams->VC_EffectLevel < LVM_VC_MIN_EFFECTLEVEL) ||
        (pParams->VC_EffectLevel > LVM_VC_MAX_EFFECTLEVEL)) {
        return (LVM_OUTOFRANGE);
    }
    if ((pParams->VC_Balance < LVM_VC_BALANCE_MIN) || (pParams->VC_Balance > LVM_VC_BALANCE_MAX)) {
        return (LVM_OUTOFRANGE);
    }

    /*
     * PSA parameters
     */
    if (((LVPSA_LevelDetectSpeed_en)pParams->PSA_PeakDecayRate > LVPSA_SPEED_HIGH) ||
        (pParams->PSA_Enable > LVM_PSA_ON)) {
        return (LVM_OUTOFRANGE);
    }

    /*
     * Set the flag to indicate there are new parameters to use
     *
     * Protect the copy of the new parameters from interrupts to avoid possible problems
     * with loss control parameters. This problem can occur if this control function is called more
     * than once before a call to the process function. If the process function interrupts
     * the copy to NewParams then one frame may have mixed parameters, some old and some new.
     */
    pInstance->ControlPending = LVM_TRUE;

    return (LVM_SUCCESS);
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:             LVM_GetControlParameters                                       */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  Request the LifeVibes module parameters. The current parameter set is returned      */
/*  via the parameter pointer.                                                          */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance            Instance handle                                                */
/*  pParams              Pointer to an empty parameter structure                        */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVM_SUCCESS          Succeeded                                                      */
/*  LVM_NULLADDRESS      when any of hInstance or pParams is NULL                       */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1. This function may be interrupted by the LVM_Process function                     */
/*                                                                                      */
/****************************************************************************************/

LVM_ReturnStatus_en LVM_GetControlParameters(LVM_Handle_t hInstance, LVM_ControlParams_t* pParams) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)hInstance;

    /*
     * Check pointer
     */
    if ((pParams == LVM_NULL) || (hInstance == LVM_NULL)) {
        return (LVM_NULLADDRESS);
    }
    *pParams = pInstance->NewParams;

    /*
     * Copy the filter definitions for the Equaliser
     */
    {
        LVM_INT16 i;

        if (pInstance->NewParams.EQNB_NBands != 0)
            for (i = 0; i < pInstance->NewParams.EQNB_NBands; i++) {
                pInstance->pEQNB_UserDefs[i] = pInstance->pEQNB_BandDefs[i];
            }
        pParams->pEQNB_BandDefinition = pInstance->pEQNB_UserDefs;
    }

    return (LVM_SUCCESS);
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVM_SetTrebleBoost                                          */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  Enable the treble boost when the settings are appropriate, i.e. non-zero gain       */
/*  and the sample rate is high enough for the effect to be heard.                      */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  pInstance               Pointer to the instance structure                           */
/*  pParams                 Pointer to the parameters to use                            */
/*                                                                                      */
/****************************************************************************************/
void LVM_SetTrebleBoost(LVM_Instance_t* pInstance, LVM_ControlParams_t* pParams) {
    extern FO_FLOAT_LShx_Coefs_t LVM_TrebleBoostCoefs[];

    LVM_INT16 Offset;
    LVM_INT16 EffectLevel = 0;

    /*
     * Load the coefficients
     */
    if ((pParams->TE_OperatingMode == LVM_TE_ON) && (pParams->SampleRate >= TrebleBoostMinRate) &&
        (pParams->OperatingMode == LVM_MODE_ON) && (pParams->TE_EffectLevel > 0)) {
        if ((pParams->TE_EffectLevel == LVM_TE_LOW_MIPS) &&
            ((pParams->SpeakerType == LVM_HEADPHONES) ||
             (pParams->SpeakerType == LVM_EX_HEADPHONES))) {
            pInstance->TE_Active = LVM_FALSE;
        } else {
            EffectLevel = pParams->TE_EffectLevel;
            pInstance->TE_Active = LVM_TRUE;
        }

        if (pInstance->TE_Active == LVM_TRUE) {
            /*
             * Load the coefficients and enabled the treble boost
             */
            Offset = (LVM_INT16)(EffectLevel - 1 +
                                 TrebleBoostSteps * (pParams->SampleRate - TrebleBoostMinRate));
            /*
             * Create biquad instance
             */
            std::array<LVM_FLOAT, android::audio_utils::kBiquadNumCoefs> coefs = {
                    LVM_TrebleBoostCoefs[Offset].A0, LVM_TrebleBoostCoefs[Offset].A1, 0.0,
                    -(LVM_TrebleBoostCoefs[Offset].B1), 0.0};
            pInstance->pTEBiquad.reset(
                    new android::audio_utils::BiquadFilter<LVM_FLOAT>(pParams->NrChannels, coefs));
        }
    } else {
        /*
         * Disable the treble boost
         */
        pInstance->TE_Active = LVM_FALSE;
    }

    return;
}

/************************************************************************************/
/*                                                                                  */
/* FUNCTION:            LVM_SetVolume                                               */
/*                                                                                  */
/* DESCRIPTION:                                                                     */
/*  Converts the input volume demand from dBs to linear.                            */
/*                                                                                  */
/* PARAMETERS:                                                                      */
/*  pInstance           Pointer to the instance                                     */
/*  pParams             Initialisation parameters                                   */
/*                                                                                  */
/************************************************************************************/
void LVM_SetVolume(LVM_Instance_t* pInstance, LVM_ControlParams_t* pParams) {
    LVM_UINT16 dBShifts;  /* 6dB shifts */
    LVM_UINT16 dBOffset;  /* Table offset */
    LVM_INT16 Volume = 0; /* Required volume in dBs */
    LVM_FLOAT Temp;

    /*
     * Limit the gain to the maximum allowed
     */
    if (pParams->VC_EffectLevel > 0) {
        Volume = 0;
    } else {
        Volume = pParams->VC_EffectLevel;
    }

    /* Compensate this volume in PSA plot */
    if (Volume > -60)                                     /* Limit volume loss to PSA Limits*/
        pInstance->PSA_GainOffset = (LVM_INT16)(-Volume); /* Loss is compensated by Gain*/
    else
        pInstance->PSA_GainOffset = (LVM_INT16)60; /* Loss is compensated by Gain*/

    pInstance->VC_AVLFixedVolume = 0;

    /*
     * Set volume control and AVL volumes according to headroom and volume user setting
     */
    if (pParams->OperatingMode == LVM_MODE_ON) {
        /* Default Situation with no AVL and no RS */
        if (pParams->EQNB_OperatingMode == LVM_EQNB_ON) {
            if (Volume > -pInstance->Headroom) Volume = (LVM_INT16)-pInstance->Headroom;
        }
    }

    /*
     * Activate volume control if necessary
     */
    pInstance->VC_Active = LVM_TRUE;
    if (Volume != 0) {
        pInstance->VC_VolumedB = Volume;
    } else {
        pInstance->VC_VolumedB = 0;
    }

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

    /*
     * Set the parameters
     */
    if (dBShifts == 0) {
        LVC_Mixer_SetTarget(&pInstance->VC_Volume.MixerStream[0],
                            (LVM_FLOAT)LVM_VolumeTable[dBOffset]);
    } else {
        Temp = LVM_VolumeTable[dBOffset];
        while (dBShifts) {
            Temp = Temp / 2.0f;
            dBShifts--;
        }
        LVC_Mixer_SetTarget(&pInstance->VC_Volume.MixerStream[0], Temp);
    }
    pInstance->VC_Volume.MixerStream[0].CallbackSet = 1;
    if (pInstance->NoSmoothVolume == LVM_TRUE) {
        LVC_Mixer_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0], 0,
                                  pInstance->Params.SampleRate, 2);
    } else {
        LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_Volume.MixerStream[0], LVM_VC_MIXER_TIME,
                                           pInstance->Params.SampleRate, 2);
    }
}

/************************************************************************************/
/*                                                                                  */
/* FUNCTION:            LVM_SetHeadroom                                             */
/*                                                                                  */
/* DESCRIPTION:                                                                     */
/*  Find suitable headroom based on EQ settings.                                    */
/*                                                                                  */
/* PARAMETERS:                                                                      */
/*  pInstance           Pointer to the instance                                     */
/*  pParams             Initialisation parameters                                   */
/*                                                                                  */
/* RETURNS:                                                                         */
/*  void                Nothing                                                     */
/*                                                                                  */
/* NOTES:                                                                           */
/*                                                                                  */
/************************************************************************************/
void LVM_SetHeadroom(LVM_Instance_t* pInstance, LVM_ControlParams_t* pParams) {
    LVM_INT16 ii, jj;
    LVM_INT16 Headroom = 0;
    LVM_INT16 MaxGain = 0;

    if (((LVEQNB_Mode_en)pParams->EQNB_OperatingMode == LVEQNB_ON) &&
        (pInstance->HeadroomParams.Headroom_OperatingMode == LVM_HEADROOM_ON)) {
        /* Find typical headroom value */
        for (jj = 0; jj < pInstance->HeadroomParams.NHeadroomBands; jj++) {
            MaxGain = 0;
            for (ii = 0; ii < pParams->EQNB_NBands; ii++) {
                if ((pParams->pEQNB_BandDefinition[ii].Frequency >=
                     pInstance->HeadroomParams.pHeadroomDefinition[jj].Limit_Low) &&
                    (pParams->pEQNB_BandDefinition[ii].Frequency <=
                     pInstance->HeadroomParams.pHeadroomDefinition[jj].Limit_High)) {
                    if (pParams->pEQNB_BandDefinition[ii].Gain > MaxGain) {
                        MaxGain = pParams->pEQNB_BandDefinition[ii].Gain;
                    }
                }
            }

            if ((MaxGain - pInstance->HeadroomParams.pHeadroomDefinition[jj].Headroom_Offset) >
                Headroom) {
                Headroom = (LVM_INT16)(
                        MaxGain -
                        pInstance->HeadroomParams.pHeadroomDefinition[jj].Headroom_Offset);
            }
        }

        /* Saturate */
        if (Headroom < 0) Headroom = 0;
    }
    pInstance->Headroom = (LVM_UINT16)Headroom;
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVM_ApplyNewSettings                                        */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  Applies changes to parametres. This function makes no assumptions about what        */
/*  each module needs for initialisation and hence passes all parameters to all the     */
/*  the modules in turn.                                                                */
/*                                                                                      */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance               Instance handle                                             */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVM_Success             Succeeded                                                   */
/*                                                                                      */
/****************************************************************************************/

LVM_ReturnStatus_en LVM_ApplyNewSettings(LVM_Handle_t hInstance) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)hInstance;
    LVM_ControlParams_t LocalParams;
    LVM_INT16 Count = 5;

    /*
     * Copy the new parameters but make sure they didn't change while copying
     */
    do {
        pInstance->ControlPending = LVM_FALSE;
        LocalParams = pInstance->NewParams;
        pInstance->HeadroomParams = pInstance->NewHeadroomParams;
        Count--;
    } while ((pInstance->ControlPending != LVM_FALSE) && (Count > 0));

    pInstance->NrChannels = LocalParams.NrChannels;
    pInstance->ChMask = LocalParams.ChMask;

    /* Clear all internal data if format change*/
    if (LocalParams.SourceFormat != pInstance->Params.SourceFormat) {
        LVM_ClearAudioBuffers(pInstance);
        pInstance->ControlPending = LVM_FALSE;
    }

    /*
     * Update the treble boost if required
     */
    if ((pInstance->Params.SampleRate != LocalParams.SampleRate) ||
        (pInstance->Params.TE_EffectLevel != LocalParams.TE_EffectLevel) ||
        (pInstance->Params.TE_OperatingMode != LocalParams.TE_OperatingMode) ||
        (pInstance->Params.OperatingMode != LocalParams.OperatingMode) ||
        (pInstance->Params.SpeakerType != LocalParams.SpeakerType)) {
        LVM_SetTrebleBoost(pInstance, &LocalParams);
    }

    /*
     * Update the headroom if required
     */
    LVM_SetHeadroom(pInstance,     /* Instance pointer */
                    &LocalParams); /* New parameters */

    /*
     * Update the volume if required
     */
    {
        LVM_SetVolume(pInstance,     /* Instance pointer */
                      &LocalParams); /* New parameters */
    }
    /* Apply balance changes*/
    if (pInstance->Params.VC_Balance != LocalParams.VC_Balance) {
        /* Configure Mixer module for gradual changes to volume*/
        if (LocalParams.VC_Balance < 0) {
            LVM_FLOAT Target_Float;
            /* Drop in right channel volume*/
            Target_Float = LVM_MAXFLOAT;
            LVC_Mixer_SetTarget(&pInstance->VC_BalanceMix.MixerStream[0], Target_Float);
            LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],
                                               LVM_VC_MIXER_TIME, LocalParams.SampleRate, 1);

            Target_Float = dB_to_LinFloat((LVM_INT16)(LocalParams.VC_Balance << 4));
            LVC_Mixer_SetTarget(&pInstance->VC_BalanceMix.MixerStream[1], Target_Float);
            LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],
                                               LVM_VC_MIXER_TIME, LocalParams.SampleRate, 1);
        } else if (LocalParams.VC_Balance > 0) {
            LVM_FLOAT Target_Float;
            /* Drop in left channel volume*/
            Target_Float = dB_to_LinFloat((LVM_INT16)((-LocalParams.VC_Balance) << 4));
            LVC_Mixer_SetTarget(&pInstance->VC_BalanceMix.MixerStream[0], Target_Float);
            LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],
                                               LVM_VC_MIXER_TIME, LocalParams.SampleRate, 1);

            Target_Float = LVM_MAXFLOAT;
            LVC_Mixer_SetTarget(&pInstance->VC_BalanceMix.MixerStream[1], Target_Float);
            LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],
                                               LVM_VC_MIXER_TIME, LocalParams.SampleRate, 1);
        } else {
            LVM_FLOAT Target_Float;
            /* No drop*/
            Target_Float = LVM_MAXFLOAT;
            LVC_Mixer_SetTarget(&pInstance->VC_BalanceMix.MixerStream[0], Target_Float);
            LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[0],
                                               LVM_VC_MIXER_TIME, LocalParams.SampleRate, 1);

            LVC_Mixer_SetTarget(&pInstance->VC_BalanceMix.MixerStream[1], Target_Float);
            LVC_Mixer_VarSlope_SetTimeConstant(&pInstance->VC_BalanceMix.MixerStream[1],
                                               LVM_VC_MIXER_TIME, LocalParams.SampleRate, 1);
        }
    }
    /*
     * Update the bass enhancement
     */
    {
        LVDBE_ReturnStatus_en DBE_Status;
        LVDBE_Params_t DBE_Params;
        LVDBE_Handle_t* hDBEInstance = (LVDBE_Handle_t*)pInstance->hDBEInstance;

        /*
         * Set the new parameters
         */
        if (LocalParams.OperatingMode == LVM_MODE_OFF) {
            DBE_Params.OperatingMode = LVDBE_OFF;
        } else {
            DBE_Params.OperatingMode = (LVDBE_Mode_en)LocalParams.BE_OperatingMode;
        }
        DBE_Params.SampleRate = (LVDBE_Fs_en)LocalParams.SampleRate;
        DBE_Params.EffectLevel = LocalParams.BE_EffectLevel;
        DBE_Params.CentreFrequency = (LVDBE_CentreFreq_en)LocalParams.BE_CentreFreq;
        DBE_Params.HPFSelect = (LVDBE_FilterSelect_en)LocalParams.BE_HPF;
        DBE_Params.HeadroomdB = 0;
        DBE_Params.VolumeControl = LVDBE_VOLUME_OFF;
        DBE_Params.VolumedB = 0;
        DBE_Params.NrChannels = LocalParams.NrChannels;

        /*
         * Make the changes
         */
        DBE_Status = LVDBE_Control(hDBEInstance, &DBE_Params);

        /*
         * Quit if the changes were not accepted
         */
        if (DBE_Status != LVDBE_SUCCESS) {
            return ((LVM_ReturnStatus_en)DBE_Status);
        }

        /*
         * Set the control flag
         */
        pInstance->DBE_Active = LVM_TRUE;
    }

    /*
     * Update the N-Band Equaliser
     */
    {
        LVEQNB_ReturnStatus_en EQNB_Status;
        LVEQNB_Params_t EQNB_Params;
        LVEQNB_Handle_t* hEQNBInstance = (LVEQNB_Handle_t*)pInstance->hEQNBInstance;

        /*
         * Set the new parameters
         */

        if (LocalParams.OperatingMode == LVM_MODE_OFF) {
            EQNB_Params.OperatingMode = LVEQNB_BYPASS;
        } else {
            EQNB_Params.OperatingMode = (LVEQNB_Mode_en)LocalParams.EQNB_OperatingMode;
        }

        EQNB_Params.SampleRate = (LVEQNB_Fs_en)LocalParams.SampleRate;
        EQNB_Params.NBands = LocalParams.EQNB_NBands;
        EQNB_Params.pBandDefinition = (LVEQNB_BandDef_t*)LocalParams.pEQNB_BandDefinition;
        if (LocalParams.SourceFormat == LVM_STEREO) /* Mono format not supported */
        {
            EQNB_Params.SourceFormat = LVEQNB_STEREO;
        }
        /* Note: Currently SourceFormat field of EQNB is not been
         *       used by the module.
         */
        else if (LocalParams.SourceFormat == LVM_MULTICHANNEL) {
            EQNB_Params.SourceFormat = LVEQNB_MULTICHANNEL;
        } else {
            EQNB_Params.SourceFormat = LVEQNB_MONOINSTEREO; /* Force to Mono-in-Stereo mode */
        }
        EQNB_Params.NrChannels = LocalParams.NrChannels;

        /*
         * Set the control flag
         */
        if ((LocalParams.OperatingMode == LVM_MODE_ON) &&
            (LocalParams.EQNB_OperatingMode == LVM_EQNB_ON)) {
            pInstance->EQNB_Active = LVM_TRUE;
        } else {
            EQNB_Params.OperatingMode = LVEQNB_BYPASS;
        }

        /*
         * Make the changes
         */
        EQNB_Status = LVEQNB_Control(hEQNBInstance, &EQNB_Params);

        /*
         * Quit if the changes were not accepted
         */
        if (EQNB_Status != LVEQNB_SUCCESS) {
            return ((LVM_ReturnStatus_en)EQNB_Status);
        }
    }

    /*
     * Update concert sound
     */
    {
        LVCS_ReturnStatus_en CS_Status;
        LVCS_Params_t CS_Params;
        LVCS_Handle_t* hCSInstance = (LVCS_Handle_t*)pInstance->hCSInstance;
        LVM_Mode_en CompressorMode = LVM_MODE_ON;

        /*
         * Set the new parameters
         */
        if (LocalParams.VirtualizerOperatingMode == LVM_MODE_ON) {
            CS_Params.OperatingMode = LVCS_ON;
        } else {
            CS_Params.OperatingMode = LVCS_OFF;
        }

        if ((LocalParams.TE_OperatingMode == LVM_TE_ON) &&
            (LocalParams.TE_EffectLevel == LVM_TE_LOW_MIPS)) {
            CS_Params.SpeakerType = LVCS_EX_HEADPHONES;
        } else {
            CS_Params.SpeakerType = LVCS_HEADPHONES;
        }

        /* Concert sound module processes only the left and right channels
         * data. So the Source Format is set to LVCS_STEREO for multichannel
         * input also.
         */
        if (LocalParams.SourceFormat == LVM_STEREO ||
            LocalParams.SourceFormat == LVM_MULTICHANNEL) {
            CS_Params.SourceFormat = LVCS_STEREO;
        } else {
            CS_Params.SourceFormat = LVCS_MONOINSTEREO; /* Force to Mono-in-Stereo mode */
        }
        CS_Params.SampleRate = LocalParams.SampleRate;
        CS_Params.ReverbLevel = LocalParams.VirtualizerReverbLevel;
        CS_Params.EffectLevel = LocalParams.CS_EffectLevel;
        CS_Params.NrChannels = LocalParams.NrChannels;

        /*
         * Set the control flag
         */
        if (((LVM_Mode_en)LocalParams.OperatingMode == LVM_MODE_ON) &&
            ((LVCS_Modes_en)LocalParams.VirtualizerOperatingMode != LVCS_OFF)) {
            pInstance->CS_Active = LVM_TRUE;
        } else {
            CS_Params.OperatingMode = LVCS_OFF;
        }

        CS_Params.CompressorMode = CompressorMode;

        /*
         * Make the changes
         */
        CS_Status = LVCS_Control(hCSInstance, &CS_Params);

        /*
         * Quit if the changes were not accepted
         */
        if (CS_Status != LVCS_SUCCESS) {
            return ((LVM_ReturnStatus_en)CS_Status);
        }
    }

    /*
     * Update the Power Spectrum Analyser
     */
    {
        LVPSA_RETURN PSA_Status;
        LVPSA_ControlParams_t PSA_Params;
        pLVPSA_Handle_t* hPSAInstance = (pLVPSA_Handle_t*)pInstance->hPSAInstance;

        /*
         * Set the new parameters
         */
        PSA_Params.Fs = LocalParams.SampleRate;
        PSA_Params.LevelDetectionSpeed = (LVPSA_LevelDetectSpeed_en)LocalParams.PSA_PeakDecayRate;

        /*
         * Make the changes
         */
        if (pInstance->InstParams.PSA_Included == LVM_PSA_ON) {
            PSA_Status = LVPSA_Control(hPSAInstance, &PSA_Params);

            if (PSA_Status != LVPSA_OK) {
                return ((LVM_ReturnStatus_en)PSA_Status);
            }

            /*
             * Apply new settings
             */
            PSA_Status = LVPSA_ApplyNewSettings((LVPSA_InstancePr_t*)hPSAInstance);
            if (PSA_Status != LVPSA_OK) {
                return ((LVM_ReturnStatus_en)PSA_Status);
            }
        }
    }

    /*
     * Update the parameters and clear the flag
     */
    pInstance->NoSmoothVolume = LVM_FALSE;
    pInstance->Params = LocalParams;

    return (LVM_SUCCESS);
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVM_SetHeadroomParams                                       */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  This function is used to set the automatiuc headroom management parameters.         */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance               Instance Handle                                             */
/*  pHeadroomParams         Pointer to headroom parameter structure                     */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVM_Success             Succeeded                                                   */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1.  This function may be interrupted by the LVM_Process function                    */
/*                                                                                      */
/****************************************************************************************/

LVM_ReturnStatus_en LVM_SetHeadroomParams(LVM_Handle_t hInstance,
                                          LVM_HeadroomParams_t* pHeadroomParams) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)hInstance;
    LVM_UINT16 ii, NBands;

    /* Check for NULL pointers */
    if ((hInstance == LVM_NULL) || (pHeadroomParams == LVM_NULL)) {
        return (LVM_NULLADDRESS);
    }
    if ((pHeadroomParams->NHeadroomBands != 0) &&
        (pHeadroomParams->pHeadroomDefinition == LVM_NULL)) {
        return (LVM_NULLADDRESS);
    }

    /* Consider only the LVM_HEADROOM_MAX_NBANDS first bands*/
    if (pHeadroomParams->NHeadroomBands > LVM_HEADROOM_MAX_NBANDS) {
        NBands = LVM_HEADROOM_MAX_NBANDS;
    } else {
        NBands = pHeadroomParams->NHeadroomBands;
    }
    pInstance->NewHeadroomParams.NHeadroomBands = NBands;

    /* Copy settings in memory */
    for (ii = 0; ii < NBands; ii++) {
        pInstance->pHeadroom_BandDefs[ii] = pHeadroomParams->pHeadroomDefinition[ii];
    }

    pInstance->NewHeadroomParams.pHeadroomDefinition = pInstance->pHeadroom_BandDefs;
    pInstance->NewHeadroomParams.Headroom_OperatingMode = pHeadroomParams->Headroom_OperatingMode;
    pInstance->ControlPending = LVM_TRUE;

    return (LVM_SUCCESS);
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVM_GetHeadroomParams                                       */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  This function is used to get the automatic headroom management parameters.          */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  hInstance               Instance Handle                                             */
/*  pHeadroomParams         Pointer to headroom parameter structure (output)            */
/*                                                                                      */
/* RETURNS:                                                                             */
/*  LVM_SUCCESS             Succeeded                                                   */
/*  LVM_NULLADDRESS         When hInstance or pHeadroomParams are NULL                  */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1.  This function may be interrupted by the LVM_Process function                    */
/*                                                                                      */
/****************************************************************************************/

LVM_ReturnStatus_en LVM_GetHeadroomParams(LVM_Handle_t hInstance,
                                          LVM_HeadroomParams_t* pHeadroomParams) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)hInstance;
    LVM_UINT16 ii;

    /* Check for NULL pointers */
    if ((hInstance == LVM_NULL) || (pHeadroomParams == LVM_NULL)) {
        return (LVM_NULLADDRESS);
    }

    pHeadroomParams->NHeadroomBands = pInstance->NewHeadroomParams.NHeadroomBands;

    /* Copy settings in memory */
    for (ii = 0; ii < pInstance->NewHeadroomParams.NHeadroomBands; ii++) {
        pInstance->pHeadroom_UserDefs[ii] = pInstance->pHeadroom_BandDefs[ii];
    }

    pHeadroomParams->pHeadroomDefinition = pInstance->pHeadroom_UserDefs;
    pHeadroomParams->Headroom_OperatingMode = pInstance->NewHeadroomParams.Headroom_OperatingMode;
    return (LVM_SUCCESS);
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVM_AlgoCallBack                                            */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  This is the callback function of the algorithm.                                     */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  pBundleHandle           Pointer to the Instance Handle                              */
/*  pData                   Pointer to the data                                         */
/*  callbackId              ID of the callback                                          */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1.  This function may be interrupted by the LVM_Process function                    */
/*                                                                                      */
/****************************************************************************************/
LVM_INT32 LVM_AlgoCallBack(void* pBundleHandle, void* pData, LVM_INT16 callbackId) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)pBundleHandle;

    (void)pData;

    switch (callbackId & 0xFF00) {
        case ALGORITHM_CS_ID:
            switch (callbackId & 0x00FF) {
                case LVCS_EVENT_ALGOFF:
                    pInstance->CS_Active = LVM_FALSE;
                    break;
                default:
                    break;
            }
            break;
        case ALGORITHM_EQNB_ID:
            switch (callbackId & 0x00FF) {
                case LVEQNB_EVENT_ALGOFF:
                    pInstance->EQNB_Active = LVM_FALSE;
                    break;
                default:
                    break;
            }
            break;
        default:
            break;
    }

    return 0;
}

/****************************************************************************************/
/*                                                                                      */
/* FUNCTION:                LVM_VCCallBack                                              */
/*                                                                                      */
/* DESCRIPTION:                                                                         */
/*  This is the callback function of the Volume control.                                */
/*                                                                                      */
/* PARAMETERS:                                                                          */
/*  pBundleHandle           Pointer to the Instance Handle                              */
/*  pGeneralPurpose         Pointer to the data                                         */
/*  CallBackParam           ID of the callback                                          */
/*                                                                                      */
/* NOTES:                                                                               */
/*  1.  This function may be interrupted by the LVM_Process function                    */
/*                                                                                      */
/****************************************************************************************/
LVM_INT32 LVM_VCCallBack(void* pBundleHandle, void* pGeneralPurpose, short CallBackParam) {
    LVM_Instance_t* pInstance = (LVM_Instance_t*)pBundleHandle;
    LVM_FLOAT Target;

    (void)pGeneralPurpose;
    (void)CallBackParam;

    /* When volume mixer has reached 0 dB target then stop it to avoid
       unnecessary processing. */
    Target = LVC_Mixer_GetTarget(&pInstance->VC_Volume.MixerStream[0]);
    if (Target == 1.0f) {
        pInstance->VC_Active = LVM_FALSE;
    }
    return 1;
}
