661 lines
26 KiB
C
661 lines
26 KiB
C
/*
|
|
* Copyright 2021-2022 NXP
|
|
* All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
* The BSD-3-Clause license for this file can be found in the LICENSE.txt file included with this distribution
|
|
* or at https://spdx.org/licenses/BSD-3-Clause.html#licenseText
|
|
*/
|
|
#include "eap_att.h"
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#if (defined EAP_PROC || defined EAP32_PROC)
|
|
// @formatter:off
|
|
LVM_EQNB_BandDef_t EQNB_BandDefs_UserEq1_internal[LVM_EQNB_MAX_BANDS_NBR] = {
|
|
{-15, 50, 50}, // gain(dB), freq(Hz) , Qfactor *100
|
|
{5, 400, 100}, {-3, 3999, 80}, {0, 1400, 96}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
|
|
|
|
LVM_EQNB_BandDef_t EQNB_BandDefs_ProductEq1_internal[LVM_EQNB_MAX_BANDS_NBR] = {
|
|
{3, 700, 1000}, // gain(dB), freq(Hz) , Qfactor *100
|
|
{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
|
|
|
|
LVM_InstParams_t InstParams_internal = {
|
|
.BufferMode = LVM_MANAGED_BUFFERS, /* Buffer management mode */
|
|
.MaxBlockSize = 480, /* Maximum processing block size max = 480 */
|
|
.EQNB_NumBands = LVM_EQNB_MAX_BANDS_NBR, /* Maximum number of band for the equalizer */
|
|
.PR_EQNB_NumBands = LVM_EQNB_MAX_BANDS_NBR, /* Maximum number of band for the equalizer */
|
|
#ifdef ALGORITHM_PSA
|
|
.PSA_HistorySize = 1000, /* PSA History size in ms: 200 to 5000 */
|
|
.PSA_MaxBands = 64, /* Maximum number of bands: 6 to 64 */
|
|
.PSA_SpectrumUpdateRate = 25, /* Spectrum update rate : 10 to 25*/
|
|
.PSA_Included = LVM_PSA_ON, /* Controls the instance memory allocation for PSA: ON/OFF */
|
|
#endif
|
|
};
|
|
|
|
#ifdef ALGORITHM_EQNB
|
|
LVM_HeadroomBandDef_t HeadroomBandDef_internal[LVM_HEADROOM_MAX_NBANDS] = {
|
|
{20, 4999, 3}, /* Limit_Low, Limit_High, Headroom_Offset */
|
|
{5000, 24000, 5},
|
|
{0, 0, 0},
|
|
{0, 0, 0},
|
|
{0, 0, 0}};
|
|
|
|
LVM_HeadroomParams_t HeadroomParams_internal = {
|
|
.Headroom_OperatingMode = LVM_HEADROOM_OFF, /* Headroom Control On/Off */
|
|
.pHeadroomDefinition = &HeadroomBandDef_internal[0], /* Headroom band definition */
|
|
.NHeadroomBands = 0, /* Number of headroom bands */
|
|
};
|
|
#endif
|
|
|
|
LVM_ControlParams_t ControlParamSet_internal = {
|
|
/* General parameters */
|
|
.OperatingMode = LVM_MODE_ON, // LVM_MODE_ON or LVM_MODE_OFF / Bundle operating mode On/Bypass
|
|
.SampleRate = LVM_FS_48000, // LVM_FS_8000, LVM_FS_11025, LVM_FS_12000, LVM_FS_16000, LVM_FS_22050, LVM_FS_24000,
|
|
// LVM_FS_32000, LVM_FS_44100, LVM_FS_48000
|
|
.SourceFormat = LVM_STEREO, // LVM_MONO or LVM_MONOINSTEREO or LVM_STEREO
|
|
.SpeakerType = LVM_HEADPHONES, // LVM_HEADPHONES or LVM_MOBILE_SPEAKERS_SMALL or LVM_MOBILE_SPEAKERS_MEDIUM or
|
|
// LVM_MOBILE_SPEAKERS_LARGE
|
|
.SpeakerTypeInternal = LVM_SPEAKER_STEREO, // Device speaker type, LVM_SPEAKER_MONO or LVM_SPEAKER_STEREO
|
|
#ifdef ALGORITHM_3DWIDENING
|
|
/* Concert Sound Virtualizer parameters */
|
|
.VirtualizerOperatingMode = LVM_MODE_OFF, // LVM_MODE_ON or LVM_MODE_OFF;
|
|
.VirtualizerType = LVM_CONCERTSOUND, // LVM_CONCERTSOUND or LVM_CINEMASOUND_MUSIC or LVM_CINEMASOUND_MOVIE or
|
|
// LVM_CINEMASOUND_STEREO;
|
|
.VirtualizerReverbLevel = (LVM_UINT16)100, // Virtualizer reverb level min = 0% to max = 100%
|
|
.CS_EffectLevel = (LVM_INT16)32767, // Concert Sound effect level min = 0 to max = 32767
|
|
|
|
// Concert sound advanced parameter
|
|
#ifdef ALGORITHM_CS
|
|
.CS_AP_Mode = LVM_AP_DEFAULT, // concert sound advanced parameter mode: LVM_AP_DEFAULT or LVM_AP_MANUAL
|
|
.CS_AP_MidGain = 0, // MidChannelGain: -10 to 10 dB
|
|
.CS_AP_MidCornerFreq = 500, // Shelving Filter Corner Frequency: 20 to 24000 Hz
|
|
.CS_AP_SideHighPassCutoff = 600, // SideBoost HighPassFilter Corner Frequency: 20 to 24000 Hz
|
|
.CS_AP_SideLowPassCutoff = 1544, // SideBoost LowPassFilter Corner Frequency: 20 to 24000 Hz
|
|
.CS_AP_SideGain = 10, // Side Channel Gain: 0 to 15 dB
|
|
#endif /* ALGORITHM_CS */
|
|
#endif /* ALGORITHM_3DWIDENING */
|
|
|
|
#ifdef ALGORITHM_BASS
|
|
/* Bass Enhancement parameters */
|
|
.BE_OperatingMode = LVM_BE_OFF, // LVM_BE_ON or LVM_BE_OFF;
|
|
.BE_EffectLevel =
|
|
(LVM_INT16)LVM_BE_9DB, // LVM_BE_0DB or LVM_BE_3DB or LVM_BE_6DB or LVM_BE_9DB or LVM_BE_12DB or LVM_BE_15DB;
|
|
.BE_CentreFreq =
|
|
LVM_BE_CENTRE_90Hz, // LVM_BE_CENTRE_55Hz or LVM_BE_CENTRE_66Hz or LVM_BE_CENTRE_78Hz or LVM_BE_CENTRE_90Hz;
|
|
.BE_HPF = LVM_BE_HPF_OFF, // LVM_BE_HPF_ON or LVM_BE_HPF_OFF;
|
|
#endif /* ALGORITHM_BASS */
|
|
|
|
/* Volume Control parameters */
|
|
.VC_EffectLevel = (LVM_INT16)0, // Volume Control setting in dBs -96 to 0 dB
|
|
.VC_Balance = (LVM_INT16)0, // Left Right Balance control in dB (-96 to 96 dB)
|
|
|
|
#ifdef ALGORITHM_TE
|
|
/* Treble Enhancement parameters */
|
|
.TE_OperatingMode = LVM_TE_OFF, // LVM_TE_ON or LVM_TE_OFF
|
|
.TE_EffectLevel = (LVM_INT16)4, // Treble Enhancement gain 0dB to 15dB or LVM_TE_LOW_MIPS for saving MIPS
|
|
#endif /* ALGORITHM_TE */
|
|
|
|
#ifdef ALGORITHM_LM
|
|
/* Loudness Maximizer parameters */
|
|
.LM_OperatingMode = LVM_LM_OFF, // LVM_LM_ON or LVM_LM_OFF
|
|
.LM_EffectLevel = LVM_LM_GENTLE, // LVM_LM_GENTLE or LVM_LM_MEDIUM or LVM_LM_EXTREME
|
|
.LM_Attenuation = (LVM_UINT16)0, // 0 to 6 ; Loudness Maximizer output attenuation
|
|
.LM_CompressorGain = (LVM_UINT16)2, // 0 to 6 ; Loudness Maximizer output compressor gain
|
|
.LM_SpeakerCutOff = (LVM_UINT16)0, // 150 to 1100; Loudness Maximizer speaker cut off frequency
|
|
#endif /* ALGORITHM_LM */
|
|
|
|
#ifdef ALGORITHM_AVL
|
|
/* AVL parameters */
|
|
.AVL_OperatingMode = LVM_AVL_OFF, // LVM_AVL_ON or LVM_AVL_OFF
|
|
#endif /* ALGORITHM_AVL */
|
|
|
|
#ifdef ALGORITHM_TG
|
|
/* Tone Generator parameters */
|
|
.TG_OperatingMode = LVM_TG_OFF, // LVM_TG_OFF or LVM_TG_CONTINUOUS or LVM_TG_ONESHOT
|
|
.TG_SweepMode = LVM_TG_SWEEPLOG, // LVM_TG_SWEEPLIN or LVM_TG_SWEEPLOG
|
|
.TG_StartFrequency = (LVM_UINT16)20, // Tone Generator Sweep Start Frequency 20 to 24000 Hz
|
|
.TG_StartAmplitude = (LVM_INT16)0, // Tone Generator Sweep Start Amplitude -96 to 0 dB
|
|
.TG_StopFrequency = (LVM_UINT16)2200, // Tone Generator Sweep Stop Frequency 20 to 24000 Hz
|
|
.TG_StopAmplitude = (LVM_INT16)0, // Tone Generator Sweep Stop Amplitude -96 to 0 dB
|
|
.TG_SweepDuration =
|
|
(LVM_UINT16)60, // Tone Generator Sweep Duration; Sweep duration in seconds, 0 for infinite duration tone
|
|
.pTG_CallBack = LVM_NULL, // WARNING Callback not supported; End of sweep callback
|
|
.TG_CallBackID = 0x100, // Callback ID
|
|
.pTGAppMemSpace = (void *)LVM_NULL, // Application instance handle or memory area
|
|
#endif /* ALGORITHM_TG */
|
|
|
|
#ifdef ALGORITHM_PSA
|
|
/* General Control */
|
|
.PSA_Enable = LVM_PSA_OFF, // LVM_PSA_ON or LVM_PSA_OFF;
|
|
/* Spectrum Analyzer parameters */
|
|
.PSA_PeakDecayRate =
|
|
LVM_PSA_SPEED_MEDIUM, // LVM_PSA_SPEED_SLOW or LVM_PSA_SPEED_MEDIUM or LVM_PSA_SPEED_FAST; Peak value decay rate
|
|
.PSA_NumBands = (LVM_UINT16)32, // 6 to 64; Number of Bands
|
|
#endif /* ALGORITHM_PSA */
|
|
|
|
#ifdef ALGORITHM_LIMP
|
|
.LIMP_OperatingMode = LVM_LIMP_OFF, // LIMP operating mode: LVM_LIMP_ON or LVM_LIMP_OFF
|
|
.LIMP_Threshold = -3, // LIMP threshold in dB: -24dB to 0dB
|
|
#endif /* ALGORITHM_LIMP */
|
|
|
|
#ifdef ALGORITHM_LIMR
|
|
.LIMR_OperatingMode = LVM_LIMR_OFF, // LVM_LIMR_ON or LVM_LIMR_OFF
|
|
.LIMR_Reference = LVM_LIMR_REF_0DBFS, // LIMR reference input: LVM_LIMR_REF_INPUT or LVM_LIMR_REF_0DBFS
|
|
.LIMR_Threshold = -24, // LIMR threshold in dB: -24dB to 0dB
|
|
#endif /* ALGORITHM_LIMR */
|
|
|
|
#ifdef ALGORITHM_EQNB
|
|
/* N-Band Equalizer parameters */
|
|
.EQNB_OperatingMode = LVM_EQNB_OFF, // LVM_EQNB_ON or LVM_EQNB_OFF;
|
|
.EQNB_LPF_Mode = LVM_EQNB_FILTER_OFF, // LVM_EQNB_FILTER_ON or LVM_EQNB_FILTER_OFF;
|
|
.EQNB_LPF_CornerFreq = (LVM_INT16)2000, // EQNB LowPass Corner Frequency;
|
|
.EQNB_HPF_Mode = LVM_EQNB_FILTER_OFF, // LVM_EQNB_FILTER_ON or LVM_EQNB_FILTER_OFF;
|
|
.EQNB_HPF_CornerFreq = (LVM_INT16)20, // EQNB HighPass Corner Frequency;
|
|
.EQNB_NBands = (LVM_UINT16)0, // Number of bands 0 to LVM_EQNB_MAX_BANDS_NBR
|
|
.pEQNB_BandDefinition = &EQNB_BandDefs_UserEq1_internal[0], // EQ band configuration
|
|
#endif /* ALGORITHM_EQNB */
|
|
|
|
#ifdef ALGORITHM_PR_EQNB
|
|
/* N-Band Equalizer parameters */
|
|
.PR_EQNB_OperatingMode = LVM_EQNB_OFF, // LVM_EQNB_ON or LVM_EQNB_OFF;
|
|
.PR_EQNB_LPF_Mode = LVM_EQNB_FILTER_OFF, // LVM_EQNB_FILTER_ON or LVM_EQNB_FILTER_OFF;
|
|
.PR_EQNB_LPF_CornerFreq = (LVM_INT16)2000, // EQNB LowPass Corner Frequency;
|
|
.PR_EQNB_HPF_Mode = LVM_EQNB_FILTER_OFF, // LVM_EQNB_FILTER_ON or LVM_EQNB_FILTER_OFF;
|
|
.PR_EQNB_HPF_CornerFreq = (LVM_INT16)20, // EQNB HighPass Corner Frequency;
|
|
.PR_EQNB_NBands = (LVM_UINT16)0, // Number of bands 0 to MAX_EQNB_BANDS
|
|
.pPR_EQNB_BandDefinition = &EQNB_BandDefs_ProductEq1_internal[0], // EQ band configuration
|
|
#endif /* ALGORITHM_PR_EQNB */
|
|
|
|
#ifdef ALGORITHM_XO
|
|
.XO_OperatingMode = LVM_MODE_OFF, // LVM_MODE_ON or LVM_MODE_OFF
|
|
.XO_cutoffFrequency = 100, // Cutoff frequency in Hz (range = [60 Hz - 6 000 Hz])
|
|
#endif
|
|
};
|
|
// @formatter:on
|
|
|
|
static eap_att_code_t normalize_params(void);
|
|
static eap_att_code_t set_control_params(void);
|
|
static eap_att_code_t get_control_params(LVM_HeadroomParams_t *headroom, LVM_ControlParams_t *control);
|
|
static eap_att_code_t update_wrapper(void);
|
|
|
|
#endif /* EAP_PROC */
|
|
|
|
static eap_att_code_t play_wrapper(void);
|
|
static eap_att_code_t pause_wrapper(void);
|
|
static eap_att_code_t resume_wrapper(void);
|
|
static eap_att_code_t reset_wrapper(void);
|
|
static eap_att_code_t stop_wrapper(void);
|
|
static eap_att_code_t set_volume_wrapper(int value);
|
|
static eap_att_code_t seek_wrapper(int32_t seek_time);
|
|
|
|
static eap_att_code_t update(void);
|
|
static eap_att_code_t set_volume(int value);
|
|
static eap_att_code_t seek(int32_t seek_time);
|
|
|
|
static void progress(int current, int total);
|
|
|
|
int attProcessIterator = 0;
|
|
|
|
eap_att_control_t att_control = {.attVersion = 4,
|
|
.eapVersion = "0.0.0",
|
|
.command = kAttCmdNone,
|
|
.status = kAttIdle,
|
|
.lastError = 0,
|
|
.eapPreset = 0,
|
|
.generatePSA = 0,
|
|
.input = "",
|
|
.trackTotal = 0,
|
|
.trackCurrent = 0,
|
|
.availableInputs = {{0}},
|
|
.progress = &progress,
|
|
.update = &update,
|
|
.set_volume = &set_volume,
|
|
.seek = &seek,
|
|
.logme = printf,
|
|
.volume = 75,
|
|
.seek_time = 0,
|
|
|
|
#if (defined EAP_PROC || defined EAP32_PROC)
|
|
.controlParam = &ControlParamSet_internal,
|
|
.instParams = &InstParams_internal,
|
|
.headroomParams = &HeadroomParams_internal,
|
|
.normalize_params = &normalize_params
|
|
#endif
|
|
};
|
|
|
|
eap_att_control_t *get_eap_att_control(void)
|
|
{
|
|
return &att_control;
|
|
}
|
|
|
|
void eap_att_process(void)
|
|
{
|
|
#if (defined EAP_PROC || defined EAP32_PROC)
|
|
if (attProcessIterator++ == 0)
|
|
{
|
|
LVM_VersionInfo_st eapVersionInfo;
|
|
if (LVM_GetVersionInfo(&eapVersionInfo) == LVM_SUCCESS)
|
|
{
|
|
strcpy(att_control.eapVersion, eapVersionInfo.pVersionNumber);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
switch (att_control.command)
|
|
{
|
|
case kAttCmdNone:
|
|
{
|
|
// some waiting info could be printed here
|
|
break;
|
|
}
|
|
case kAttCmdStart:
|
|
{
|
|
if (att_control.status == kAttPaused)
|
|
{
|
|
att_control.lastError = resume_wrapper();
|
|
}
|
|
else
|
|
{
|
|
if (att_control.status == kAttRunning)
|
|
{
|
|
att_control.lastError = stop_wrapper();
|
|
att_control.trackCurrent = 0;
|
|
att_control.trackTotal = 0;
|
|
}
|
|
if (att_control.lastError == kEapAttCodeOk)
|
|
{
|
|
att_control.lastError = play_wrapper();
|
|
}
|
|
}
|
|
|
|
att_control.status = kAttRunning;
|
|
|
|
att_control.logme("[EAP_ATT] Playback started for %s\r\n", att_control.input);
|
|
|
|
break;
|
|
}
|
|
case kAttCmdStop:
|
|
{
|
|
if (att_control.status == kAttRunning || att_control.status == kAttPaused)
|
|
{
|
|
att_control.lastError = stop_wrapper();
|
|
att_control.trackCurrent = 0;
|
|
att_control.trackTotal = 0;
|
|
att_control.status = kAttIdle;
|
|
|
|
att_control.logme("[EAP_ATT] Playback stopped\r\n");
|
|
}
|
|
break;
|
|
}
|
|
case kAttCmdPause:
|
|
{
|
|
if (att_control.status == kAttPaused)
|
|
{
|
|
att_control.lastError = resume_wrapper();
|
|
att_control.status = kAttRunning;
|
|
att_control.logme("[EAP_ATT] Playback continued\r\n");
|
|
}
|
|
else if (att_control.status == kAttRunning)
|
|
{
|
|
att_control.lastError = pause_wrapper();
|
|
att_control.status = kAttPaused;
|
|
att_control.logme("[EAP_ATT] Playback paused\r\n");
|
|
}
|
|
break;
|
|
}
|
|
case kAttCmdSeek:
|
|
if (att_control.status != kAttPaused)
|
|
{
|
|
att_control.logme("[EAP_ATT] First pause the track\r\n");
|
|
}
|
|
else
|
|
{
|
|
att_control.lastError = seek_wrapper(att_control.seek_time);
|
|
}
|
|
break;
|
|
#if (defined EAP_PROC || defined EAP32_PROC)
|
|
case kAttCmdSetConfig:
|
|
{
|
|
att_control.logme("[EAP_ATT] Set config\r\n");
|
|
att_control.lastError = set_control_params();
|
|
break;
|
|
}
|
|
case kAttCmdGetConfig:
|
|
{
|
|
att_control.logme("[EAP_ATT] Get config\r\n");
|
|
att_control.lastError = get_control_params(0, 0);
|
|
break;
|
|
}
|
|
#endif
|
|
case kAttCmdReset:
|
|
{
|
|
/* currently used only in tests */
|
|
att_control.command = kAttCmdNone;
|
|
att_control.lastError = reset_wrapper();
|
|
while (1)
|
|
; // block until restarted
|
|
break;
|
|
}
|
|
case kAttCmdVolume:
|
|
{
|
|
if (att_control.status == kAttRunning || att_control.status == kAttPaused)
|
|
{
|
|
att_control.lastError = set_volume_wrapper(att_control.volume);
|
|
}
|
|
else
|
|
{
|
|
att_control.logme("[EAP_ATT] First, play an audio file.\r\n");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
att_control.logme("[EAP_ATT] Error: Undefined command has been detected: %d\r\n", att_control.command);
|
|
att_control.lastError = kEapAttCodeUndefinedCommand;
|
|
}
|
|
}
|
|
|
|
if (att_control.lastError != kEapAttCodeOk && att_control.status != kAttError)
|
|
{
|
|
att_control.logme("[EAP_ATT] Error occurred %d for command %d\r\n", att_control.lastError, att_control.command);
|
|
if (att_control.status == kAttRunning)
|
|
{
|
|
att_control.logme("[EAP_ATT] Error occurred, trying to stop...\r\n");
|
|
stop_wrapper();
|
|
}
|
|
att_control.status = kAttError;
|
|
}
|
|
|
|
att_control.command = kAttCmdNone;
|
|
}
|
|
|
|
static void progress(int current, int total)
|
|
{
|
|
att_control.trackCurrent = current;
|
|
att_control.trackTotal = total;
|
|
}
|
|
|
|
/* wrap functions by safe invoker */
|
|
static eap_att_code_t play_wrapper(void)
|
|
{
|
|
if (att_control.play != NULL)
|
|
{
|
|
return (*att_control.play)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
static eap_att_code_t pause_wrapper(void)
|
|
{
|
|
if (att_control.pause != NULL)
|
|
{
|
|
return (*att_control.pause)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
static eap_att_code_t resume_wrapper(void)
|
|
{
|
|
if (att_control.resume != NULL)
|
|
{
|
|
return (*att_control.resume)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
static eap_att_code_t reset_wrapper(void)
|
|
{
|
|
if (att_control.reset != NULL)
|
|
{
|
|
return (*att_control.reset)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
static eap_att_code_t stop_wrapper(void)
|
|
{
|
|
if (att_control.stop != NULL)
|
|
{
|
|
return (*att_control.stop)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
static eap_att_code_t seek_wrapper(int32_t seek_time)
|
|
{
|
|
if (att_control.seek != NULL)
|
|
{
|
|
return (*att_control.seek)(seek_time);
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
eap_att_code_t seek(int32_t seek_time)
|
|
{
|
|
return kEapAttCodeOk; // let implementation on user if needed
|
|
}
|
|
|
|
static eap_att_code_t update(void)
|
|
{
|
|
return kEapAttCodeOk; // let implementation on user if needed
|
|
}
|
|
|
|
static eap_att_code_t set_volume_wrapper(int volume)
|
|
{
|
|
if (att_control.set_volume != NULL)
|
|
{
|
|
return (*att_control.set_volume)(volume);
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
eap_att_code_t set_volume(int value)
|
|
{
|
|
return kEapAttCodeOk; // let implementation on user if needed
|
|
}
|
|
|
|
#if (defined EAP_PROC || defined EAP32_PROC)
|
|
|
|
static eap_att_code_t update_wrapper(void)
|
|
{
|
|
if (att_control.update != NULL)
|
|
{
|
|
return (*att_control.update)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
void eap_att_register_handle(LVM_Handle_t *handle)
|
|
{
|
|
LVM_VersionInfo_st eapVersionInfo;
|
|
if (LVM_GetVersionInfo(&eapVersionInfo) == LVM_SUCCESS)
|
|
{
|
|
strcpy(att_control.eapVersion, eapVersionInfo.pVersionNumber);
|
|
}
|
|
|
|
att_control.logme("[EAP_ATT] Handle registered into ATT control (v%d, eap: %s)\r\n", att_control.attVersion,
|
|
att_control.eapVersion);
|
|
att_control.handle = handle;
|
|
}
|
|
|
|
static eap_att_code_t normalize_params(void)
|
|
{
|
|
LVM_ControlParams_t *cp = att_control.controlParam;
|
|
#ifdef ALGORITHM_EQNB
|
|
for (cp->EQNB_NBands = 0; cp->EQNB_NBands < LVM_EQNB_MAX_BANDS_NBR; cp->EQNB_NBands++)
|
|
{
|
|
if (cp->pEQNB_BandDefinition[cp->EQNB_NBands].Frequency == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
LVM_HeadroomParams_t *hp = att_control.headroomParams;
|
|
for (hp->NHeadroomBands = 0; hp->NHeadroomBands < LVM_EQNB_MAX_BANDS_NBR; hp->NHeadroomBands++)
|
|
{
|
|
if (hp->pHeadroomDefinition[hp->NHeadroomBands].Limit_Low == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef ALGORITHM_PR_EQNB
|
|
for (cp->PR_EQNB_NBands = 0; cp->PR_EQNB_NBands < LVM_EQNB_MAX_BANDS_NBR; cp->PR_EQNB_NBands++)
|
|
{
|
|
if (cp->pPR_EQNB_BandDefinition[cp->PR_EQNB_NBands].Frequency == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
return kEapAttCodeOk;
|
|
}
|
|
|
|
static eap_att_code_t normalize_params_wrapper(void)
|
|
{
|
|
if (att_control.normalize_params != NULL)
|
|
{
|
|
return (*att_control.normalize_params)();
|
|
}
|
|
return kEapAttCodeMissingHandler;
|
|
}
|
|
|
|
/* internal */
|
|
static eap_att_code_t set_control_params(void)
|
|
{
|
|
int status = LVM_SUCCESS;
|
|
|
|
if (att_control.handle != 0)
|
|
{
|
|
// pointer has to be initialized because memcpy during get will fail (looks like caused by get LVM param);
|
|
// use {} initializer will be good solution but only for gcc|clang but fail during compilation by msvc,
|
|
// thus using this old-school init
|
|
LVM_HeadroomParams_t headroom;
|
|
LVM_ControlParams_t control;
|
|
LVM_HeadroomBandDef_t HeadroomBandDef_placeholder[LVM_HEADROOM_MAX_NBANDS] = {0};
|
|
LVM_EQNB_BandDef_t EQNB_BandDef_placeholder[LVM_EQNB_MAX_BANDS_NBR] = {0};
|
|
LVM_EQNB_BandDef_t PR_EQNB_BandDef_placeholder[LVM_EQNB_MAX_BANDS_NBR] = {0};
|
|
headroom.pHeadroomDefinition = HeadroomBandDef_placeholder;
|
|
control.pEQNB_BandDefinition = EQNB_BandDef_placeholder;
|
|
control.pPR_EQNB_BandDefinition = PR_EQNB_BandDef_placeholder;
|
|
|
|
eap_att_code_t code = get_control_params(&headroom, &control);
|
|
if (code != kEapAttCodeOk)
|
|
{
|
|
att_control.logme("[EAP_ATT] Parameters write failed in getting current params phase: %d\r\n", code);
|
|
return code;
|
|
}
|
|
|
|
code = normalize_params_wrapper();
|
|
if (code != kEapAttCodeOk)
|
|
{
|
|
att_control.logme("[EAP_ATT] Parameters normalization failed: %d\r\n", code);
|
|
return code;
|
|
}
|
|
|
|
#ifdef ALGORITHM_EQNB
|
|
// headroomParams restricted parameters filter could be here
|
|
status = LVM_SetHeadroomParams(att_control.handle, att_control.headroomParams);
|
|
if (status != LVM_SUCCESS)
|
|
{
|
|
att_control.logme("[EAP_ATT] Headroom parameters write failed: %d\r\n", status);
|
|
return kEapAttCodeHeadroomSetFailed;
|
|
}
|
|
#endif
|
|
// controlParams restricted parameters filter
|
|
if (control.SampleRate != att_control.controlParam->SampleRate ||
|
|
control.SourceFormat != att_control.controlParam->SourceFormat)
|
|
{
|
|
att_control.controlParam->SampleRate = control.SampleRate;
|
|
att_control.controlParam->SourceFormat = control.SourceFormat;
|
|
att_control.logme(
|
|
"[EAP_ATT] SampleRate or SourceFormat not matching, replacing by active one from EAP config.\r\n");
|
|
}
|
|
status = LVM_SetControlParameters(att_control.handle, att_control.controlParam);
|
|
|
|
if (status != LVM_SUCCESS)
|
|
{
|
|
att_control.logme("[EAP_ATT] Control parameters write failed: %d\r\n", status);
|
|
return kEapAttCodeControlParamSetFailed;
|
|
}
|
|
|
|
att_control.logme("[EAP_ATT] Parameters written.\r\n");
|
|
}
|
|
else
|
|
{
|
|
att_control.logme("[EAP_ATT] Parameters write skipped. EAP instance not registered or is null.\r\n");
|
|
}
|
|
return update_wrapper();
|
|
}
|
|
|
|
static eap_att_code_t get_control_params(LVM_HeadroomParams_t *headroom, LVM_ControlParams_t *control)
|
|
{
|
|
int status = LVM_SUCCESS;
|
|
if (att_control.handle != 0)
|
|
{
|
|
LVM_ControlParams_t *controlDest = control;
|
|
if (control == 0)
|
|
{
|
|
controlDest = att_control.controlParam;
|
|
}
|
|
|
|
#ifdef ALGORITHM_EQNB
|
|
LVM_HeadroomParams_t *headroomDest = headroom;
|
|
if (headroom == 0)
|
|
{
|
|
headroomDest = att_control.headroomParams;
|
|
}
|
|
LVM_HeadroomBandDef_t *headroomPtrBackup = headroomDest->pHeadroomDefinition;
|
|
|
|
status = LVM_GetHeadroomParams(att_control.handle, headroomDest);
|
|
if (status != LVM_SUCCESS)
|
|
{
|
|
att_control.logme("[EAP_ATT] Headroom parameters read failed: %d\r\n", status);
|
|
return kEapAttCodeHeadroomGetFailed;
|
|
}
|
|
if (headroomPtrBackup != headroomDest->pHeadroomDefinition)
|
|
{
|
|
// copy current headroom band definition if array is on different pointer than internal definition
|
|
memcpy(headroomPtrBackup, headroomDest->pHeadroomDefinition,
|
|
sizeof(*headroomDest->pHeadroomDefinition) * headroomDest->NHeadroomBands);
|
|
headroomDest->pHeadroomDefinition = headroomPtrBackup;
|
|
}
|
|
LVM_EQNB_BandDef_t *eqnbPtrBackup = controlDest->pEQNB_BandDefinition;
|
|
#endif
|
|
#ifdef ALGORITHM_PR_EQNB
|
|
LVM_EQNB_BandDef_t *prodPtrBackup = controlDest->pPR_EQNB_BandDefinition;
|
|
#endif
|
|
status = LVM_GetControlParameters(att_control.handle, controlDest);
|
|
|
|
if (status != LVM_SUCCESS)
|
|
{
|
|
att_control.logme("[EAP_ATT] Control parameters read failed: %d\r\n", status);
|
|
return kEapAttCodeControlParamGetFailed;
|
|
}
|
|
#ifdef ALGORITHM_EQNB
|
|
if (eqnbPtrBackup != controlDest->pEQNB_BandDefinition)
|
|
{
|
|
memcpy(eqnbPtrBackup, controlDest->pEQNB_BandDefinition,
|
|
sizeof(*controlDest->pEQNB_BandDefinition) * controlDest->EQNB_NBands);
|
|
controlDest->pEQNB_BandDefinition = eqnbPtrBackup;
|
|
}
|
|
#endif
|
|
#ifdef ALGORITHM_PR_EQNB
|
|
if (prodPtrBackup != controlDest->pPR_EQNB_BandDefinition)
|
|
{
|
|
memcpy(prodPtrBackup, controlDest->pPR_EQNB_BandDefinition,
|
|
sizeof(*controlDest->pPR_EQNB_BandDefinition) * controlDest->PR_EQNB_NBands);
|
|
controlDest->pPR_EQNB_BandDefinition = prodPtrBackup;
|
|
}
|
|
#endif
|
|
att_control.logme("[EAP_ATT] Parameters synchronized.\r\n");
|
|
}
|
|
else
|
|
{
|
|
att_control.logme("[EAP_ATT] Parameters read skipped. EAP instance not registered or is null.\r\n");
|
|
}
|
|
return kEapAttCodeOk;
|
|
}
|
|
#endif /* EAP_PROC */
|