/* * 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 /****************************************************************************************/ /* */ /* 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 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(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; }