FreeCalypso > hg > freecalypso-sw
changeset 606:c5286d24539e
gsm-fw/L1/audio_cfile: initial import from LoCosto source
| author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
|---|---|
| date | Fri, 29 Aug 2014 03:25:51 +0000 (2014-08-29) |
| parents | 527956ce73c7 |
| children | 262fcce10859 |
| files | gsm-fw/L1/audio_cfile/l1audio_abb.c gsm-fw/L1/audio_cfile/l1audio_afunc.c gsm-fw/L1/audio_cfile/l1audio_async.c gsm-fw/L1/audio_cfile/l1audio_back.c gsm-fw/L1/audio_cfile/l1audio_drive.c gsm-fw/L1/audio_cfile/l1audio_func.c gsm-fw/L1/audio_cfile/l1audio_init.c gsm-fw/L1/audio_cfile/l1audio_stereo.c gsm-fw/L1/audio_cfile/l1audio_sync.c |
| diffstat | 9 files changed, 24403 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_abb.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,1005 @@ +/* + * l1audio_abb.c + * + * Control audio + * + * Filename l1audio_abb.c + * Copyright 2003 (C) Texas Instruments + * + * Reference : S820, GACS001 (OMEGA) spec + * + */ + +#include "l1_macro.h" +#include "l1_confg.h" + + +#if (CODE_VERSION == NOT_SIMULATION) + +#if (defined _WINDOWS && (OP_RIV_AUDIO == 1)) + #include "rv_general.h" +#endif + +#if (CODE_VERSION == SIMULATION) + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "l1_varex.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include <stdio.h> + #include "sim_cfg.h" + #include "sim_cons.h" + #include "sim_def.h" + #include "sim_var.h" + +#else + #include <string.h> + #if (defined _WINDOWS && (OP_RIV_AUDIO == 1)) + #define BOOL_FLAG + #endif +// Triton Audio ON/OFF Changes + + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #include "l1_time.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #if (RF_FAM == 61) + #include "l1_rf61.h" + #endif + + #include "l1_defty.h" + #include "l1_varex.h" + #include "l1_msgty.h" + #if (OP_RIV_AUDIO == 0) + #include "cust_os.h" + #include "tpudrv.h" + #endif +#endif + +#include "abb.h" + +#include "l1audio_abb.h" + +#if (ANLG_FAM == 11) + #include "types.h" + #include "bspTwl3029_I2c.h" + #include "bspTwl3029_Aud_Map.h" + #include "bspTwl3029_Audio.h" +#endif + +#if (CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(CHIPSET == 15) + void l1_audio_on_off_callback_fn(Uint8 callback_val); +#endif +#include "l1audio_abb.h" + +#if ((CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(OP_L1_STANDALONE == 1)&&(CHIPSET == 12)) + #include "nucleus.h" +#endif + +#if (ANLG_FAM == 3) +extern T_L1S_DSP_COM l1s_dsp_com; +extern void l1_audio_lim_partial_update(); + + +#define MAX_PGA_UL 24 +#define MAX_PGA_DL 12 +#define MAX_VOL_DL 249 + +static UWORD8 ABB_CurrentVolume = 0; + +// Uplink PGA gain is coded on 5 bits, corresponding to -12 dB to +12 dB in 1dB steps +const UWORD8 ABB_uplink_PGA_gain[] = +{ + 0x10, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16 +}; + +// Downlink volume: mute, -24dB to 0dB in 6dB steps +const UWORD8 ABB_volume_control_gain[] = +{ + 0x05, 0x03, 0x04, 0x00, 0x06, 0x02 +}; + +// Downlink volume gain read in unsigned Q15 (in VBDCTRL) +const WORD16 ABB_DL_volume_read_gain[] = +{ + 0x2000 , // 0: -12 dB + 0 , // 1: Mute + 0x8000 , // 2: 0 dB + 0x0800 , // 3: -24 dB + 0x1000 , // 4: -18 dB + 0 , // 5: Mute + 0x4000 , // 6: -6 dB + 0 , // 7: Mute +}; + +// Downlink PGA gain read in unsigned Q15 (in VBDCTRL) +const WORD16 ABB_DL_PGA_read_gain[] = +{ + 0x4026 , // 0: - 6 dB + 0x47FA , // 1: - 5 dB + 0x50C3 , // 2: - 4 dB + 0x5A9D , // 3: - 3 dB + 0x65AC , // 4: - 2 dB + 0x7214 , // 5: - 1 dB + 0x8000 , // 6: 0 dB + 0x8F9E , // 7: 1 dB + 0xA124 , // 8: 2 dB + 0xB4CE , // 9: 3 dB + 0xCADD , // 10: 4 dB + 0xE39E , // 11: 5 dB + 0xFF64 , // 12: 6 dB + 0x4026 , // 13: - 6 dB + 0x4026 , // 14: - 6 dB + 0x4026 , // 15: - 6 dB +}; + + +// Downlink PGA gain is coded on 4 bits, corresponding to -6dB to 6dB in 1dB steps +const UWORD8 ABB_downlink_PGA_gain[] = +{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C +}; + +// Side tone level: mute, -23dB to +4dB in 3dB steps +const UWORD8 ABB_sidetone_gain[] = +{ + 0x08, 0x0D, 0x0C, 0x06, 0x02, 0x07, + 0x03, 0x00, 0x04, 0x01, 0x05 +}; + +/* + * ABB_Audio_Config + * + * Configuration of VBCTRL1 register + * + */ +void ABB_Audio_Config (UWORD16 data) +{ +#if (ANLG_FAM == 1) + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl = ABB_L1_WRITE (VBCTRL, data); +#elif ((ANLG_FAM == 2) || (ANLG_FAM == 3) ) + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl1 = ABB_L1_WRITE (VBCTRL1, data); +#endif +} + + +/* + * ABB_Audio_Config_2 + * + * Configuration of VBCTRL2 register + * + */ +void ABB_Audio_Config_2 (UWORD16 data) +{ +#if ((ANLG_FAM == 2) || (ANLG_FAM == 3)) + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl2 = ABB_L1_WRITE (VBCTRL2, data); +#endif +} + + +/* + * ABB_Audio_Control + * + * Configuration of VAUDCTRL register + * + */ +void ABB_Audio_Control (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vaud_cfg = ABB_L1_WRITE (VAUDCTRL, data); +#endif +} + + +/* + * ABB_Audio_On_Off + * + * Configuration of VAUOCTRL register + * + */ +void ABB_Audio_On_Off (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vauo_onoff = ABB_L1_WRITE (VAUOCTRL, data); +#endif +} + + +/* + * ABB_Audio_Volume + * + * Configuration of VAUSCTRL register + * + */ +void ABB_Audio_Volume (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vaus_vol = ABB_L1_WRITE (VAUSCTRL, data); +#endif +} + + +/* + * ABB_Audio_PLL + * + * Configuration of VAUDPLL register + * + */ +void ABB_Audio_PLL (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll = ABB_L1_WRITE (VAUDPLL, data); +#endif +} + + +/* + * ABB_Audio_VBPop + * + * Configuration of VBPOP register + * + */ +void ABB_Audio_VBPop (UWORD16 data) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vbpop = ABB_L1_WRITE (VBPOP, data); +#endif +} + + +/* + * ABB_Audio_Delay_Init + * + * Configuration of the delay initialization for POP noise reduction + * + */ +void ABB_Audio_Delay_Init (UWORD8 delay) +{ +#if (ANLG_FAM == 3) + l1s_dsp_com.dsp_ndb_ptr->d_vau_delay_init = delay; +#endif +} + + +/* + * ABB_CAL_UlVolume + * + * Uplink audio volume calibration + * + * Parameter : pga index - range 0..24 + * + * When this function is called the Mute bit of VBUCTRL is set to zero + */ +void ABB_CAL_UlVolume (UWORD8 pga_index) +{ + UWORD16 index; + API reg_state; + + index = pga_index; + if (index > MAX_PGA_UL) + index = MAX_PGA_UL; //clip + + //mask side tone gain and the mute settings + reg_state = l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl &= 0xF800; + + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl = reg_state | + ABB_L1_WRITE ( VBUCTRL, + ABB_uplink_PGA_gain[index]); +} + +/* + * ABB_CAL_DlVolume + * + * Downlink audio volume calibration + * + * Parameter : volume - range 0 to 255, pga - range 0-12 + * + */ + +void ABB_CAL_DlVolume (UWORD8 volume_index, UWORD8 pga_index) +{ + UWORD16 volume, pga; + // Remember current volume for subsequent mute commands + ABB_CurrentVolume = volume_index; + + // Normalize volume (0 to 5) + if (volume_index > MAX_VOL_DL) volume_index=MAX_VOL_DL; //clip + + if (volume_index) + volume = (volume_index / 50) + 1; + else + volume = volume_index; + + if (pga_index > MAX_PGA_DL) pga_index=MAX_PGA_DL; //clip + pga = pga_index; + + + l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl = + ABB_L1_WRITE ( VBDCTRL, + (ABB_volume_control_gain[volume] << 4) | + (ABB_downlink_PGA_gain[pga]) ); + + #if (L1_LIMITER == 1) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_ENABLE) + l1_audio_lim_partial_update(); + #endif +} + +/* + * ABB_DlVolume + * + * Control Downlink audio volume + * + * Parameter : volume - range 0 to 255 + * + */ + +void ABB_DlVolume (UWORD8 volume_index) +{ + UWORD16 volume; + API reg_state; + + // Remember current volume for subsequent mute commands + ABB_CurrentVolume = volume_index; + + // Normalize volume (0 to 5) + if (volume_index > MAX_VOL_DL) volume_index=MAX_VOL_DL; //clip + + if (volume_index) + volume = (volume_index / 50) + 1; + else + volume = volume_index; + + //mask PGA setting determined during calibration phase + reg_state = l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl &= 0x03c0; + + l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl = reg_state | + ABB_L1_WRITE ( VBDCTRL, + (ABB_volume_control_gain[volume] << 4)); + + #if (L1_LIMITER == 1) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_ENABLE) + l1_audio_lim_partial_update(); + #endif +} + +/* + * ABB_DlMute + * + * Mute downlink audio + * + * Parameter : Mute - On or Off + * + */ + +void ABB_DlMute (BOOL mute) +{ + UWORD8 current_volume; + + if (mute) + { + /* + * The current downlink volume must be memorized to avoid + * having 0 as the new current volume. + */ + + current_volume = ABB_CurrentVolume; + ABB_DlVolume (0); + ABB_CurrentVolume = current_volume; + } + else + { + ABB_DlVolume (ABB_CurrentVolume); + } +} + +/* + * ABB_UlMute + * + * Mute uplink audio + * + * Parameter : Mute - On or Off + * + */ + +void ABB_UlMute (BOOL mute) +{ + if (mute) + { + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl |= + ABB_L1_WRITE ( VBUCTRL, + DXEN); + } + else + { + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl &= 0x7fff; + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl |= 0x01; + } + + } + +/* + * ABB_SideTone + * + * Control audio sidetone + * + * Parameter : volume - range 0 to 255 + * nominal is 175 (-5dB) + * + */ + +void ABB_SideTone (UWORD8 volume_index) +{ + UWORD16 side_tone; + API reg_state; + + // Normalize sidetone (0 to 10) + side_tone = volume_index / 25; + + // mask uplink PGA gain and mute settings + reg_state = l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl &= 0x87c0; + + l1s_dsp_com.dsp_ndb_ptr->d_vbuctrl = reg_state | + ABB_L1_WRITE (VBUCTRL, + (ABB_sidetone_gain[side_tone] << 5)); +} + +/* + * ABB_Read_DLVolume + * + * Returns the last controlled ABB DL gain in unsigned Q15 format + * This value includes volume and PGA gain. + * + */ +UWORD16 ABB_Read_DLGain() +{ + + UWORD16 volume_index; + UWORD16 pga_index; + + // Read last programmed volume + //Sundi: change for Triton + #if (ANLG_FAM == 1) || (ANLG_FAM == 2) || (ANLG_FAM == 3) + volume_index = (API)((l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl >> 10) & 0x7); + pga_index = (API)((l1s_dsp_com.dsp_ndb_ptr->d_vbdctrl >> 6) & 0xF); + #endif + + // Convert volume into gain (dB) + return((ABB_DL_volume_read_gain[volume_index] * ABB_DL_PGA_read_gain[pga_index]) >> 15); + } +#endif // ANLG_FAM == 3 + +#if (ANLG_FAM == 11) + // Downlink volume gain read in unsigned Q15 (in VBDCTRL) + const WORD16 L1_audio_abb_DL_volume_read_gain[] = + { + (WORD16)0x2000 , // 0: -12 dB //omaps00090550 + (WORD16)0x0000 , // 1: Mute //omaps00090550 + (WORD16)0x8000 , // 2: 0 dB//omaps00090550 + (WORD16)0x0800 , // 3: -24 dB//omaps00090550 + (WORD16)0x1000 , // 4: -18 dB//omaps00090550 + (WORD16)0x0000 , // 5: Mute//omaps00090550 + (WORD16)0x4000 , // 6: -6 dB//omaps00090550 + (WORD16)0x0000 , // 7: Mute//omaps00090550 + }; + + // Downlink PGA gain read in unsigned Q15 (in VBDCTRL) + const WORD16 L1_audio_abb_DL_PGA_read_gain[] = + { + (WORD16)0x4026 , // 0: - 6 dB//omaps00090550 + (WORD16) 0x47FA , // 1: - 5 dB//omaps00090550 + (WORD16)0x50C3 , // 2: - 4 dB//omaps00090550 + (WORD16)0x5A9D , // 3: - 3 dB//omaps00090550 + (WORD16)0x65AC , // 4: - 2 dB//omaps00090550 + (WORD16)0x7214 , // 5: - 1 dB//omaps00090550 + (WORD16)0x8000 , // 6: 0 dB//omaps00090550 + (WORD16)0x8F9E , // 7: 1 dB//omaps00090550 + (WORD16)0xA124 , // 8: 2 dB//omaps00090550 + (WORD16)0xB4CE , // 9: 3 dB//omaps00090550 + (WORD16)0xCADD , // 10: 4 dB//omaps00090550 + (WORD16)0xE39E , // 11: 5 dB//omaps00090550 + (WORD16)0xFF64 , // 12: 6 dB//omaps00090550 + (WORD16)0x4026 , // 13: - 6 dB//omaps00090550 + (WORD16)0x4026 , // 14: - 6 dB//omaps00090550 + (WORD16)0x4026 , // 15: - 6 dB//omaps00090550 + }; + + UWORD16 l1_audio_abb_Read_DLGain() + { + + UWORD8 volume_index; + UWORD8 pga_index; + UWORD8 vdlgain; + + BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_VDLGAIN_OFFSET, + &vdlgain); + + volume_index = ((vdlgain & 0x70) >> 4); // bits 4-6 + pga_index = (vdlgain & 0x0f) ; //bits 0-3 + + // Convert volume into gain (dB) + return((L1_audio_abb_DL_volume_read_gain[volume_index] * L1_audio_abb_DL_PGA_read_gain[pga_index]) >> 15); + } + + void ABB_Audio_On_Off (UWORD16 data) + { + + } +#endif // ANLG_FAM == 11 + +#endif // CODE_VERSION != SIMULATION + +// Triton Audio ON/OFF Changes +#if (CODE_VERSION == SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1) + +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ) +{ + callback_fn(); +} + +#endif // SIMULATION && L1_AUDIO_MCU_ONOFF + +// Triton Audio ON/OFF Changes +#if ((CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(OP_L1_STANDALONE == 1)&&(CHIPSET == 12)) + +void(*cb_array[3])(void); +SYS_UWORD16 vauoctrl_status; +extern NU_TIMER l1_audio_abb_ul_timer; +extern NU_TIMER l1_audio_abb_dl_timer; +extern NU_TIMER l1_audio_abb_ul_dl_timer; + +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ) +{ + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg|0x0200); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0002); + cb_array[0]=callback_fn; + NU_Control_Timer(&l1_audio_abb_ul_timer, NU_ENABLE_TIMER); +} +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ) +{ + vauoctrl_status = ABB_Read_Register_on_page(PAGE1, VAUOCTRL); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, 0x0000); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0008); + cb_array[1]=callback_fn; + NU_Control_Timer(&l1_audio_abb_dl_timer, NU_ENABLE_TIMER); +} + +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ) +{ + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0001); + callback_fn(); +} + +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ) +{ + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0004); + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ) +{ + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0001|0x0004); + callback_fn(); +} + +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ) +{ + vauoctrl_status = ABB_Read_Register_on_page(PAGE1, VAUOCTRL); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, 0x0000); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0008|0x0001); + cb_array[1]=callback_fn; + NU_Control_Timer(&l1_audio_abb_dl_timer, NU_ENABLE_TIMER); +} + +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ) +{ + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg|0x0200); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0002|0x0004); + cb_array[0]=callback_fn; + NU_Control_Timer(&l1_audio_abb_ul_timer, NU_ENABLE_TIMER); +} + +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ) +{ + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + vauoctrl_status = ABB_Read_Register_on_page(PAGE1, VAUOCTRL); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, 0x0000); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg|0x0200); + ABB_Write_Register_on_page(PAGE0, TOGBR1, 0x0002|0x0008); + cb_array[2]=callback_fn; + NU_Control_Timer(&l1_audio_abb_ul_dl_timer, NU_ENABLE_TIMER); +} + + +void l1_audio_abb_onoff_timer_expiry(UNSIGNED index) +{ + L1_trace_string("ON OFF Timer Expiry\r\n"); + switch(index) + { + case 0: + { + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg&0x01FF); + cb_array[0](); + } + break; + case 1: + { + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, vauoctrl_status); + cb_array[1](); + } + break; + case 2: + { + SYS_UWORD16 reg; + reg = ABB_Read_Register_on_page(PAGE1, VBUCTRL); + ABB_Write_Register_on_page(PAGE1, VBUCTRL, reg&0x01FF); + ABB_Write_Register_on_page(PAGE1, VAUOCTRL, vauoctrl_status); + cb_array[2](); + } + break; + default: + { + while(1); + } + break; + } +} +#endif // SIMULATION && L1_AUDIO_MCU_ONOFF + +// Triton Audio ON/OFF Changes +#if (CODE_VERSION == NOT_SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1)&&(CHIPSET == 15) + +void(*cb_array[3])(void); +UWORD8 cb_index = 0; + +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_NONE, + ret, OUTEN_NONE); + +} +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_NONE, + AUDIO_DOWNLINK_ON, + ret, OUTEN_NONE); + +} + +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_NONE, + ret, OUTEN_NONE); + +} + +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + // Configure the outen reg to 0 only when STEREOPATH_DRV_STATE is in IDLE STATE + if(l1s.audio_state[L1S_STEREOPATH_DRV_STATE] == 0) + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_NONE, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_DISABLE); + } + else + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_NONE, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_ENABLE); + } + +} + +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + // Configure the outen reg to 0 only when STEREOPATH_DRV_STATE is in IDLE STATE + if(l1s.audio_state[L1S_STEREOPATH_DRV_STATE] == 0) + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_DISABLE); + } + else + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_ENABLE); + } + +} + +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_OFF, + AUDIO_DOWNLINK_ON, + ret, OUTEN_NONE); +} + +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + // Configure the outen reg to 0 only when STEREOPATH_DRV_STATE is in IDLE STATE + if(l1s.audio_state[L1S_STEREOPATH_DRV_STATE] == 0) + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_DISABLE); + } + else + { + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_OFF, + ret, OUTEN_ENABLE); + } + +} + +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ) +{ + T_AUDIO_ON_OFF_CONTROL_RETURN ret; + + cb_array[cb_index] = callback_fn; + + ret.audio_on_off_callback = l1_audio_on_off_callback_fn; + ret.callback_val = cb_index; + + cb_index++; + if(cb_index == 3)cb_index = 0; + + + bspTwl3029_audio_on_off_control (AUDIO_UPLINK_ON, + AUDIO_DOWNLINK_ON, + ret, OUTEN_NONE); +} + + +void l1_audio_on_off_callback_fn(Uint8 callback_val) +{ + cb_array[callback_val](); +} + +#endif // SIMULATION && L1_AUDIO_MCU_ONOFF + +#if (AUDIO_DEBUG == 1) +/*-------------------------------------------------------*/ +/* l1_audio_regs_debug_read */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* */ +/*-------------------------------------------------------*/ +UWORD8 audio_reg_read_status; +BspI2c_TransactionRequest audo_read_i2cIntTransArray[20]; +BspTwl3029_I2C_RegData audio_regs[20]; +UWORD8 audio_regs_cpy[20]; +void l1_audio_reg_debug_read_callback(); +void l1_audio_regs_debug_read() +{ + BspTwl3029_I2C_RegisterInfo i2cRegArray[20]; + BspTwl3029_I2C_RegisterInfo* i2cRegArrayPtr = i2cRegArray; + + BspTwl3029_I2C_Callback callback; + BspTwl3029_I2C_CallbackPtr callbackPtr = &callback; + + callbackPtr->callbackFunc = (BspI2c_TransactionDoneCallback)l1_audio_reg_debug_read_callback; + callbackPtr->callbackVal = (BspI2c_TransactionId)(1); + callbackPtr->i2cTransArrayPtr = (Bsp_Twl3029_I2cTransReqArrayPtr)audo_read_i2cIntTransArray; + + if(audio_reg_read_status==0) + { + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_PWRONSTATUS_OFFSET,&audio_regs[0],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL1_OFFSET,&audio_regs[1],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL2_OFFSET,&audio_regs[2],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET,&audio_regs[3],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL4_OFFSET,&audio_regs[4],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL5_OFFSET,&audio_regs[5],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_CTRL6_OFFSET,&audio_regs[6],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_VULGAIN_OFFSET,&audio_regs[7],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_VDLGAIN_OFFSET,&audio_regs[8],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_OUTEN1_OFFSET,&audio_regs[9],i2cRegArrayPtr++); + BspTwl3029_I2c_regQueRead(BSP_TWL3029_I2C_AUD, + BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET,&audio_regs[10],i2cRegArrayPtr++); + i2cRegArrayPtr = i2cRegArray; + BspTwl3029_I2c_regInfoSend(i2cRegArrayPtr,11,callbackPtr, + (BspI2c_TransactionRequest*)callbackPtr->i2cTransArrayPtr); + } +} + +void l1_audio_reg_debug_read_callback() +{ + int i; + audio_reg_read_status=1; + for(i=0;i<20;i++) + { + audio_regs_cpy[i]=audio_regs[i]; + } +} + +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_afunc.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,1032 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_AFUNC.C + * + * Filename l1audio_afunc.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + #include "l1_time.h" + #include "l1_scen.h" + + #include "l1audio_proto.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "cust_os.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_proto.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added from e-smaple for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif +#if (RF_FAM == 61) +#include "l1_rf61.h" +#endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + + #if (OP_RIV_AUDIO == 1) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_macro_i.h" + #include "audio_const_i.h" + #endif + #endif +// #include "audio_api.h" //Thukaram Test +#if (OP_L1_STANDALONE == 0) + + #include "typedefs.h" + #include "vsi.h" + #include "os_const.h" + #include "os.h" + #include "frm_glob.h" + + #include "typedefs.h" + #include "vsi.h" + #include "os_const.h" + #include "os.h" + #include "frm_glob.h" + + extern T_HANDLE mm_ext_data_pool_handle; + extern T_HANDLE mm_int_data_pool_handle; + #endif + UWORD8 dma_src_port; + // This macro avoids to duplicate the code. + #if (OP_RIV_AUDIO == 1) + #define AUDIO_MSG (p_message) + #else + #define AUDIO_MSG (msg->SigP) + #endif + + /*-------------------------------------------------------*/ + /* l1a_audio_send_confirmation() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : Signal Code ofthe message */ + /* */ + /* Return : */ + /* */ + /* Description : Send a confirmation message to the MMI */ + /* for an audio task. */ + /* */ + /*-------------------------------------------------------*/ + void l1a_audio_send_confirmation(UWORD32 SignalCode) + { + #if (OP_RIV_AUDIO == 1) + + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_RV_HDR), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* fill the message id */ + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + + #else // OP_RIV_AUDIO + + xSignalHeaderRec *msg; + + msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + #endif // OP_RIV_AUDIO + } + +/*-------------------------------------------------------*/ +/* l1a_audio_send_result() */ +/*-------------------------------------------------------*/ +/* Parameters : */ +/* Return : */ +/* Functionality : Send a result message to the MMI. */ +/*-------------------------------------------------------*/ +void l1a_audio_send_result(UWORD32 SignalCode, xSignalHeaderRec *msg, UWORD8 queue) +{ +#if (OP_RIV_AUDIO == 1) + + void *p_message = NULL; //omaps00090550 + T_RVF_MB_STATUS mb_status; //omaps00090550 + + switch (SignalCode) + { + #if (L1_AUDIO_DRIVER == 1) + case AUDIO_DRIVER_NOTIFICATION_MSG: + { + T_AUDIO_DRIVER_SESSION *p_session; + T_RV_RETURN *return_path; + UINT8 channel_id; + + /* get driver session */ + channel_id = ((T_L1_AUDIO_DRIVER_IND *)msg->SigP)->channel_id; + p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); + return_path = &(p_session->session_req.return_path); + + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_AUDIO_DRIVER_NOTIFICATION), + (T_RVF_BUFFER **) (&p_message)); + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for driver notification",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message ID + parameters */ + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->header.msg_id = SignalCode; + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id = channel_id; + ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer = ((T_L1_AUDIO_DRIVER_IND *)(msg->SigP))->p_buffer; + + /* send answer */ + if (return_path->callback_func == NULL) + rvf_send_msg (return_path->addr_id, p_message); + else + { + (*return_path->callback_func)((void *)(p_message)); + rvf_free_buf((T_RVF_BUFFER *)p_message); + } + + // This return is important because there is another rvf_send_msg at the end of the switch + return; + } +//omaps00090550 break; + #endif + #if (L1_VOICE_MEMO_AMR) + case MMI_VM_AMR_RECORD_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_VM_AMR_RECORD_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_VM_AMR_RECORD_STOP_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_VM_AMR_RECORD_CON *)p_message)->recorded_size = ((T_L1_VM_AMR_RECORD_CON *)(msg->SigP))->recorded_size; + } + break; + #endif + #if (VOICE_MEMO) + case MMI_VM_RECORD_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_VM_RECORD_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + ((T_MMI_VM_RECORD_CON *)p_message)->recorded_size = + ((T_L1_VM_RECORD_CON *)(msg->SigP))->recorded_size; + + break; + } + #endif + #if (L1_PCM_EXTRACTION) + case MMI_PCM_UPLOAD_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_PCM_UPLOAD_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + ((T_MMI_PCM_UPLOAD_STOP_CON *)p_message)->uploaded_size = + ((T_L1_PCM_UPLOAD_STOP_CON *)(msg->SigP))->uploaded_size; + + break; + } + #endif /* L1_PCM_EXTRACTION */ + + #if (SPEECH_RECO) + case MMI_SR_ENROLL_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id; + + break; + } + case MMI_SR_UPDATE_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id; + + break; + } + case MMI_SR_RECO_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->second_best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->second_best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->third_best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->third_best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->fourth_best_word_index = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->fourth_best_word_score = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->d_sr_model_size = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->d_sr_db_level = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level; + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->d_sr_db_noise = + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise; + + break; + } + + case MMI_SR_UPDATE_CHECK_STOP_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + /* Fill the message parameter */ + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->error_id; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->second_best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->second_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->second_best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->second_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->third_best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->third_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->third_best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->third_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->fourth_best_word_index = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->fourth_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->fourth_best_word_score = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->fourth_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->d_sr_model_size = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_model_size; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->d_sr_db_level = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_db_level; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->d_sr_db_noise = + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_db_noise; + + break; + } + + #endif /* SPEECH_RECO */ + + + #if (L1_CPORT == 1) + case MMI_CPORT_CONFIGURE_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_CPORT_CONFIGURE_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_CPORT_CONFIGURE_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_CPORT_CONFIGURE_CON *)p_message)->register_id = ((T_L1_CPORT_CONFIGURE_CON *)(msg->SigP))->register_id; + ((T_MMI_CPORT_CONFIGURE_CON *)p_message)->register_value = ((T_L1_CPORT_CONFIGURE_CON *)(msg->SigP))->register_value; + } + break; + #endif + + #if(L1_ANR == 2) + case MMI_AQI_ANR_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_ANR_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_ANR_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_ANR_CON *)p_message)->anr_ul_action = ((T_L1_AQI_ANR_CON *)(msg->SigP))->anr_ul_action; + } + break; + #endif + + #if(L1_IIR == 2) + case MMI_AQI_IIR_DL_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_IIR_DL_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_IIR_DL_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_IIR_DL_CON *)p_message)->iir_dl_action = ((T_L1_AQI_IIR_DL_CON *)(msg->SigP))->iir_dl_action; + } + break; + #endif + + #if(L1_AGC_UL == 1) + case MMI_AQI_AGC_UL_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_AGC_UL_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_AGC_UL_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_AGC_UL_CON *)p_message)->agc_ul_action = ((T_L1_AQI_AGC_UL_CON *)(msg->SigP))->agc_ul_action; + } + break; + #endif + + #if(L1_AGC_DL == 1) + case MMI_AQI_AGC_DL_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_AGC_DL_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_AGC_DL_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_AGC_DL_CON *)p_message)->agc_dl_action = ((T_L1_AQI_AGC_DL_CON *)(msg->SigP))->agc_dl_action; + } + break; + #endif + + #if(L1_WCM == 1) + case MMI_AQI_WCM_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_WCM_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_WCM_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_WCM_CON *)p_message)->wcm_action = ((T_L1_AQI_WCM_CON *)(msg->SigP))->wcm_action; + } + break; + #endif + + + #if(L1_DRC == 1) + case MMI_AQI_DRC_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_DRC_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_DRC_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_DRC_CON *)p_message)->drc_dl_action = ((T_L1_AQI_DRC_CON *)(msg->SigP))->drc_dl_action; + } + break; + #endif + + #if(L1_AEC == 2) + case MMI_AQI_AEC_CON: + { + /* Translate the l1 message into the Riviera compliant message */ + /* Allocate the Riviera buffer */ + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_AQI_AEC_CON), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for MMI_AQI_AEC_CON",RV_TRACE_LEVEL_ERROR); + return; + } + + // recorded size includes the end mask + ((T_MMI_AQI_AEC_CON *)p_message)->aec_action = ((T_L1_AQI_AEC_CON *)(msg->SigP))->aec_action; + } + break; + #endif + + +default: + { + AUDIO_SEND_TRACE("AUDIO entity: wrong L1 confirmation message",RV_TRACE_LEVEL_ERROR); + break; + } + } + + if(p_message != NULL) +{ + /* Fill the message ID */ + ((T_RV_HDR *)p_message)->msg_id = SignalCode; +} + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + +#else // OP_RIV_AUDIO + + // Set flag to avoid the FREE(msg) in L1ASYNC. + l1a.l1_msg_forwarded = TRUE; + + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, queue); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + +#endif // OP_RIV_AUDIO +} + +#if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* l1_send_sr_background_msg() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : Signal Code ofthe message */ + /* */ + /* Return : */ + /* */ + /* Description : Send a message to the SR background */ + /* task. */ + /* */ + /*-------------------------------------------------------*/ + void l1_send_sr_background_msg(UWORD32 SignalCode) + { + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + #else + xSignalHeaderRec *msg; + #endif + + switch (SignalCode) + { + case L1_SRBACK_SAVE_DATA_REQ: + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_L1_SRBACK_SAVE_DATA_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_SRBACK_SAVE_DATA_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + // Fill the message + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->database_id = l1a_l1s_com.speechreco_task.parameters.database_id; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->model_index = l1a_l1s_com.speechreco_task.parameters.word_index; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->model_RAM_address = l1a_l1s_com.speechreco_task.parameters.model_address; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->speech = l1a_l1s_com.speechreco_task.parameters.speech; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->start_buffer = l1a_l1s_com.speechreco_task.parameters.speech_address; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->stop_buffer = l1a_l1s_com.speechreco_task.parameters.speech_address + SC_SR_MMI_2_L1_SPEECH_SIZE; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->start_address = l1a_l1s_com.speechreco_task.parameters.start_address; + ((T_L1_SRBACK_SAVE_DATA_REQ *)(AUDIO_MSG))->stop_address = l1a_l1s_com.speechreco_task.parameters.stop_address; + } + break; + + case L1_SRBACK_LOAD_MODEL_REQ: + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_L1_SRBACK_LOAD_MODEL_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_SRBACK_LOAD_MODEL_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + // Fill the message + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->database_id = l1a_l1s_com.speechreco_task.parameters.database_id; + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->model_index = l1a_l1s_com.speechreco_task.parameters.word_index; + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->model_RAM_address = l1a_l1s_com.speechreco_task.parameters.model_address; + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(AUDIO_MSG))->CTO_enable = l1a_l1s_com.speechreco_task.parameters.CTO_algorithm; + } + break; + + case L1_SRBACK_TEMP_SAVE_DATA_REQ: + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_L1_SRBACK_TEMP_SAVE_DATA_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_SRBACK_TEMP_SAVE_DATA_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + // Fill the message + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(AUDIO_MSG))->model_RAM_address_input = l1a_l1s_com.speechreco_task.parameters.model_address; + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(AUDIO_MSG))->model_RAM_address_output = l1a_l1s_com.speechreco_task.parameters.model_temp_address; + } + break; + } + + #if (OP_RIV_AUDIO == 1) + /* fill the message id */ + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, SRBACK_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + } +#endif +#if (MELODY_E2) + /*-------------------------------------------------------*/ + /* l1_send_melody_e2_background_msg() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : Signal Code of the message */ + /* melody ID (0 or 1) */ + /* */ + /* Return : */ + /* */ + /* Description : Send a message to the audio background */ + /* for the melody E2 feature. */ + /* */ + /*-------------------------------------------------------*/ + void l1_send_melody_e2_background_msg(UWORD32 SignalCode, UWORD8 melody_id) + { + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; //omaps00090550 + #else + xSignalHeaderRec *msg; + #endif + + UWORD8 i; + + if ( SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ ) + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->melody_id = + melody_id; + + if (melody_id == 0) + { + // Load instrument for the melody 0 + // Fill the message + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + for(i=0; i<SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT; i++) + { + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->waves_table_id[i] = + l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]; + } + } + if (melody_id == 1) + { + // Load instrument for the melody 1 + // Fill the message + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + for(i=0; i<SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT; i++) + { + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->waves_table_id[i] = + l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]; + } + } + } + else + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) + { + // Allocate the partition + #if (OP_RIV_AUDIO == 1) + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ), + (T_RVF_BUFFER **) (&p_message)); + + /* If insufficient resources, then report a memory error and abort. */ + if (mb_status == RVF_RED) + { + /* the memory is insufficient to continue the non regression test */ + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + #else // OP_RIV_AUDIO + msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ)); + DEBUGMSG(status,NU_ALLOC_ERR) + #endif // OP_RIV_AUDIO + + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->melody_id = + melody_id; + + if (melody_id == 0) + { + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + } + else + if (melody_id == 1) + { + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(AUDIO_MSG))->number_of_instrument = + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + } + } + + #if (OP_RIV_AUDIO == 1) + ((T_RV_HDR *)p_message)->msg_id = SignalCode; + + /* send the messsage to the audio entity */ + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + msg->SignalCode = SignalCode; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(msg); + #endif + + os_send_sig(msg, SRBACK_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + } +#endif // MELODY_E2 + +#if (OP_L1_STANDALONE == 0) +void *mem_Allocate(UWORD16 size) +{ + +void* p_buffer; + + T_HANDLE hTask; + + hTask = e_running[os_MyHandle()]; + + if(os_AllocateMemory( hTask , (T_VOID_STRUCT **)&p_buffer,size,OS_NO_SUSPEND, mm_int_data_pool_handle) != 0) + { + if(os_AllocateMemory ( hTask, (T_VOID_STRUCT**)&p_buffer,size,OS_NO_SUSPEND, mm_ext_data_pool_handle) != 0) + return NULL; + else + { + dma_src_port =AUDIO_SP_SOURCE_EMIF; + return p_buffer; + } + } + else + { + dma_src_port =AUDIO_SP_SOURCE_IMIF; + return p_buffer; + } + + +} + + +void mem_Deallocate(void *memoryBlock) +{ + T_HANDLE hTask; + + hTask = e_running[os_MyHandle()]; + + if (memoryBlock) + { + os_DeallocateMemory(hTask, (T_VOID_STRUCT *) memoryBlock); + } + } +#endif//op_l1_standalone=0 +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_async.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,10690 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_ASYNC.C + * + * Filename l1audio_async.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "cust_os.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + #include "l1audio_proto.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #if (L1_DYN_DSP_DWNLD==1) + #include "l1_dyn_dwl_defty.h" + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_signa.h" + #endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + + // Layer1 and debug include files. + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + #include "cust_os.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + #include "l1audio_proto.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #if (L1_DYN_DSP_DWNLD==1) + #include "l1_dyn_dwl_defty.h" + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_signa.h" + #endif + +#if (RF_FAM == 61) +#include "l1_rf61.h" +#endif + + #include "l1_defty.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + + #if (OP_RIV_AUDIO == 1) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_macro_i.h" + #include "audio_const_i.h" + #endif + #endif + + #include "l1audio_macro.h" + + #if(L1_DYN_DSP_DWNLD == 1) + #if (TRACE_TYPE == 1) ||(TRACE_TYPE == 4) || (TRACE_TYPE == 5) || (TRACE_TYPE == 7) || (TESTMODE) + #include "l1_trace.h" + #endif + #if(CODE_VERSION == SIMULATION) + extern void trace_fct_simu_dyn_dwnld(CHAR *fct_name); + #endif + #endif + +#if 0 + #if (L1_MP3) + extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR + #endif +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END + +#endif +#if ( L1_AAC) +extern UWORD16 a_aac_dma_input_buffer[2][C_AAC_OUTPUT_BUFFER_SIZE]; +extern UWORD8 d_aac_dma_current_buffer_id; + +#endif + +#if (L1_MP3) +extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR +#endif + /**************************************/ + /* Prototypes for L1 ASYNCH task */ + /**************************************/ + #if (OP_RIV_AUDIO == 1) + #if (L1_AUDIO_DRIVER == 1) + void l1a_audio_driver_process (xSignalHeaderRec *msg); + #endif + #endif + #if (KEYBEEP) + void l1a_mmi_keybeep_process (xSignalHeaderRec *msg); + #endif + #if (TONE) + void l1a_mmi_tone_process (xSignalHeaderRec *msg); + #endif + #if (L1_CPORT == 1) + void l1a_mmi_cport_process (xSignalHeaderRec *msg); + #endif + #if (MELODY_E1) + void l1a_mmi_melody0_process (xSignalHeaderRec *msg); + void l1a_mmi_melody1_process (xSignalHeaderRec *msg); + #endif + #if (VOICE_MEMO) + void l1a_mmi_vm_playing_proccess (xSignalHeaderRec *msg); + void l1a_mmi_vm_recording_process (xSignalHeaderRec *msg); + #endif + #if (L1_PCM_EXTRACTION) + void l1a_mmi_pcm_download_process (xSignalHeaderRec *msg); + void l1a_mmi_pcm_upload_process (xSignalHeaderRec *msg); + #endif + #if (L1_VOICE_MEMO_AMR) + void l1a_mmi_vm_amr_playing_proccess (xSignalHeaderRec *msg); + void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg); + #endif + #if (SPEECH_RECO) + void l1a_mmi_sr_enroll_process (xSignalHeaderRec *msg); + void l1a_mmi_sr_update_process (xSignalHeaderRec *msg); + void l1a_mmi_sr_reco_process (xSignalHeaderRec *msg); + void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg); + #endif + #if (L1_AEC == 1) + void l1a_mmi_aec_process (xSignalHeaderRec *msg); + #endif + #if (L1_AEC == 2) + void l1a_mmi_aec_process (xSignalHeaderRec *msg); + #endif + #if (FIR) + void l1a_mmi_fir_process (xSignalHeaderRec *msg); + #endif + #if (AUDIO_MODE) + void l1a_mmi_audio_mode_process (xSignalHeaderRec *msg); + #endif + #if (MELODY_E2) + void l1a_mmi_melody0_e2_process (xSignalHeaderRec *msg); + void l1a_mmi_melody1_e2_process (xSignalHeaderRec *msg); + #endif + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + void l1a_mmi_audio_onoff_process (xSignalHeaderRec *msg); + #endif + #if (L1_EXT_AUDIO_MGT == 1) + void l1a_mmi_ext_audio_mgt_process (xSignalHeaderRec *msg); + #endif + #if (L1_ANR == 1 || L1_ANR == 2) + void l1a_mmi_anr_process (xSignalHeaderRec *msg); + #endif + #if (L1_AGC_UL == 1) + void l1a_mmi_agc_ul_process (xSignalHeaderRec *msg); + #endif + #if (L1_AGC_DL == 1) + void l1a_mmi_agc_dl_process (xSignalHeaderRec *msg); + #endif + #if (L1_IIR == 1 || L1_IIR == 2) + void l1a_mmi_iir_process (xSignalHeaderRec *msg); + #endif + #if (L1_WCM == 1) + void l1a_mmi_wcm_process (xSignalHeaderRec *msg); + #endif +#if (L1_DRC == 1) + void l1a_mmi_drc_process (xSignalHeaderRec *msg); + #endif + #if (L1_LIMITER == 1) + void l1a_mmi_limiter_process (xSignalHeaderRec *msg); + #endif + #if (L1_ES == 1) + void l1a_mmi_es_process (xSignalHeaderRec *msg); + #endif + #if (L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_vocoder_cfg_process(xSignalHeaderRec *msg); + #endif +#if(L1_BT_AUDIO==1) + void l1a_mmi_bt_process(xSignalHeaderRec *msg); +#endif + /**************************************/ + /* External prototypes */ + /**************************************/ + extern UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst); + extern UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src); + extern UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + #if (MELODY_E2) + extern UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst); + extern UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src); + #endif + #if (L1_EXT_AUDIO_MGT == 1) + T_MIDI_DMA_PARAM midi_buf; + #if (CODE_VERSION == NOT_SIMULATION) +#pragma DATA_SECTION(midi_buf,".l1s_global") +#endif + extern void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status); + #endif + #if(L1_BT_AUDIO ==1) + BOOL midi_task_running; + extern T_L1_BT_AUDIO bt_audio; + extern void l1_audio_bt_init(UINT16 media_buf_size); + #endif + + #if (OP_RIV_AUDIO == 1) + #if (L1_AUDIO_DRIVER == 1) + void l1a_audio_driver_process(xSignalHeaderRec *msg) + { + UWORD32 SignalCode = msg->SignalCode; + + if (SignalCode == L1_AUDIO_DRIVER_IND) + l1a_audio_send_result(AUDIO_DRIVER_NOTIFICATION_MSG, msg, MMI_QUEUE); + } + #endif + #endif + + #if (KEYBEEP) + /*-------------------------------------------------------*/ + /* l1a_mmi_keybeep_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* keybeep feature. */ + /* */ + /* Starting messages: MMI_KEYBEEP_START_REQ */ + /* */ + /* Result messages (input): L1_KEYBEEP_START_CON */ + /* */ + /* Result messages (output): MMI_KEYBEEP_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_KEYBEEP_STOP_REQ */ + /* L1_KEYBEEP_STOP_CON */ + /* */ + /* Stop message (output): MMI_KEYBEEP_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_keybeep_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_KEYBEEP_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.keybeep_task.command.start = FALSE; + l1a_l1s_com.keybeep_task.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_KEYBEEP_START_REQ) + { + // Download the keybeep description in the NDB. + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt0= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt0; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt1= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt1; + l1s_dsp_com.dsp_ndb_ptr->d_dur_kb = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_dur_kb; + + // Start the L1S keybeep task + l1a_l1s_com.keybeep_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // OMPAS00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_KEYBEEP_START_CON) + { + // Disable the start command + l1a_l1s_com.keybeep_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_KEYBEEP_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // ompas00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_KEYBEEP_STOP_REQ) + { + // Stop the L1S keybeep task + l1a_l1s_com.keybeep_task.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_KEYBEEP_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_KEYBEEP_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif // KEYBEEP + + #if (TONE) + /*-------------------------------------------------------*/ + /* l1a_mmi_tone_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* tone feature. */ + /* */ + /* Starting messages: MMI_TONE_START_REQ */ + /* */ + /* Result messages (input): L1_TONE_START_CON */ + /* */ + /* Result messages (output): MMI_TONE_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_TONE_STOP_REQ */ + /* L1_TONE_STOP_CON */ + /* */ + /* Stop message (output): MMI_TONE_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_tone_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_TONE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.tone_task.command.start = FALSE; + l1a_l1s_com.tone_task.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_TONE_START_REQ) + { + // Download the tone description in the NDB. + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t0; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t1; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t2; + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_rep; + l1s_dsp_com.dsp_ndb_ptr->d_pe_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_off; + l1s_dsp_com.dsp_ndb_ptr->d_se_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_se_off; + l1s_dsp_com.dsp_ndb_ptr->d_bu_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_bu_off; + l1s_dsp_com.dsp_ndb_ptr->d_t0_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_on; + l1s_dsp_com.dsp_ndb_ptr->d_t0_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_off; + l1s_dsp_com.dsp_ndb_ptr->d_t1_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_on; + l1s_dsp_com.dsp_ndb_ptr->d_t1_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_off; + l1s_dsp_com.dsp_ndb_ptr->d_t2_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_on; + l1s_dsp_com.dsp_ndb_ptr->d_t2_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_off; + + + // Start the L1S tone task + l1a_l1s_com.tone_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + //omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_TONE_START_CON) + { + // Disable the start command + l1a_l1s_com.tone_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_TONE_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_TONE_STOP_REQ) + { + // Stop the L1S tone task + l1a_l1s_com.tone_task.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_TONE_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_TONE_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // TONE + + + + + + #if (MELODY_E1) + /*-------------------------------------------------------*/ + /* l1a_mmi_melody0_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 0 feature. */ + /* */ + /* Starting messages: MMI_MELODY0_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY0_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY0_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_STOP_REQ */ + /* L1_MELODY0_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY0_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody0_process(xSignalHeaderRec *msg) + { + enum states + { + M0_RESET = 0, + M0_WAIT_START_REQ = 1, + M0_WAIT_START_CON = 2, + M0_WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY0_STATE]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 melody_osc, used_osc; + + while(1) + { + switch(*state) + { + case M0_RESET: + { + // Reset the commands: + l1a_l1s_com.melody0_task.command.start = FALSE; + l1a_l1s_com.melody0_task.command.stop = FALSE; + + // Initialize the translation table + for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++) + l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR; + + *state = M0_WAIT_START_REQ; + } + break; + + case M0_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY0_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody0_task.parameters.session_id = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody0_task.parameters.loopback = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback; + l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_task.parameters.buffer_size, + l1a_l1s_com.melody0_task.parameters.session_id); + + // Read the Header of the melody description to have the melody bitmap + l1a_l1s_com.melody0_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1a_l1s_com.melody0_task.parameters.buffer_size, + (UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf, + 1, + &l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap); + + l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + + // Build the array of translation between the melody mapping and the oscillators used + used_osc = 0; + melody_osc = 0; + while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + { + // find the next oscillator available in the melody + while( ((l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + melody_osc++; + + // find the next oscillator available in the oscillator used + while( ((l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + used_osc++; + + // Fill the translation table + if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = used_osc; + melody_osc++; + used_osc++; + } + + // Start the melody 0 L1S task: + l1a_l1s_com.melody0_task.command.start = TRUE; + + *state = M0_WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case M0_WAIT_START_CON: + { + if (SignalCode == L1_MELODY0_START_CON) + { + // Disable the start command + l1a_l1s_com.melody0_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_START_CON); + + *state = M0_WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case M0_WAIT_STOP: + { + if (SignalCode == L1_MELODY0_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_STOP_CON); + + *state = M0_RESET; + } + else + if (SignalCode == MMI_MELODY0_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody0_task.command.stop = TRUE; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody1_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 1 feature. */ + /* */ + /* Starting messages: MMI_MELODY1_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY1_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY1_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY1_STOP_REQ */ + /* L1_MELODY1_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY1_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody1_process(xSignalHeaderRec *msg) + { + enum states + { + M1_RESET = 0, + M1_WAIT_START_REQ = 1, + M1_WAIT_START_CON = 2, + M1_WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY1_STATE]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 melody_osc, used_osc; + + while(1) + { + switch(*state) + { + case M1_RESET: + { + // Reset the commands: + l1a_l1s_com.melody1_task.command.start = FALSE; + l1a_l1s_com.melody1_task.command.stop = FALSE; + + // Initialize the translation table + for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++) + l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR; + + + *state = M1_WAIT_START_REQ; + } + break; + + case M1_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY1_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody1_task.parameters.session_id = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody1_task.parameters.loopback = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback; + l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_task.parameters.buffer_size, + l1a_l1s_com.melody1_task.parameters.session_id); + + // Read the Header of the melody description to have the melody bitmap + l1a_l1s_com.melody1_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1a_l1s_com.melody1_task.parameters.buffer_size, + (UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf, + 1, + &l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap); + + l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + // Build the array of translation between the melody maaping and the oscillators used + used_osc = 0; + melody_osc = 0; + while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + { + // find the next oscillator available in the melody + while( ((l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + melody_osc++; + + // find the next oscillator available in the oscillator used + while( ((l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) ) + used_osc++; + + // Fill the translation table + if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) ) + l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = used_osc; + melody_osc++; + used_osc++; + } + + // Start the melody 1 L1S task: + l1a_l1s_com.melody1_task.command.start = TRUE; + + *state = M1_WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case M1_WAIT_START_CON: + { + if (SignalCode == L1_MELODY1_START_CON) + { + // Disable the start command + l1a_l1s_com.melody1_task.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_START_CON); + + *state = M1_WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + case M1_WAIT_STOP: + { + if (SignalCode == L1_MELODY1_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_STOP_CON); + + *state = M1_RESET; + } + else + if (SignalCode == MMI_MELODY1_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody1_task.command.stop = TRUE; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // MELODY_E1 + +#if (VOICE_MEMO) + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_playing_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization playing feature. */ + /* */ + /* Starting messages: MMI_VM_PLAY_START_REQ */ + /* */ + /* Result messages (input): L1_VM_PLAY_START_CON */ + /* */ + /* Result messages (output): MMI_VM_PLAY_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_PLAY_STOP_REQ */ + /* L1_VM_PLAY_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_PLAY_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_playing_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_VM_PLAY_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_task.play.command.start = FALSE; + l1a_l1s_com.voicememo_task.play.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_PLAY_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_task.play.parameters.session_id = ((T_MMI_VM_PLAY_REQ *)(msg->SigP))->session_id; + + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_task.play.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_PLAY_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_task.play.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_PLAY_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_PLAY_STOP_REQ) + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_task.play.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_PLAY_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_recording_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization recording feature. */ + /* */ + /* Starting messages: MMI_VM_RECORD_START_REQ */ + /* */ + /* Result messages (input): L1_VM_RECORD_START_CON */ + /* */ + /* Result messages (output): MMI_VM_RECORD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_RECORD_STOP_REQ */ + /* L1_VM_RECORD_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_RECORD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_recording_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_VM_RECORD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_task.record.command.start = FALSE; + l1a_l1s_com.voicememo_task.record.command.stop = FALSE; + l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_RECORD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_task.record.parameters.session_id = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.voicememo_task.record.parameters.maximum_size = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->maximum_size; + l1a_l1s_com.voicememo_task.record.parameters.dtx = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->dtx_used; + + // Download UL/DL audio gain to the NDB + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_ul; + l1s_dsp_com.dsp_ndb_ptr->d_shiftdl = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_dl; + + // Download the tone description in the NDB. + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t0; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t1; + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t2; + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_rep; + l1s_dsp_com.dsp_ndb_ptr->d_pe_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_off; + l1s_dsp_com.dsp_ndb_ptr->d_se_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_se_off; + l1s_dsp_com.dsp_ndb_ptr->d_bu_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_bu_off; + l1s_dsp_com.dsp_ndb_ptr->d_t0_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_on; + l1s_dsp_com.dsp_ndb_ptr->d_t0_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_off; + l1s_dsp_com.dsp_ndb_ptr->d_t1_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_on; + l1s_dsp_com.dsp_ndb_ptr->d_t1_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_off; + l1s_dsp_com.dsp_ndb_ptr->d_t2_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_on; + l1s_dsp_com.dsp_ndb_ptr->d_t2_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_off; + + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_task.record.command.start = TRUE; + + // Start the L1S voice memo tone uplink task + l1a_l1s_com.voicememo_task.record.tone_ul.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_RECORD_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE; + + // Reset the start command + l1a_l1s_com.voicememo_task.record.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_RECORD_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_RECORD_STOP_REQ) + { + // Stop the L1S voice memo recording task + l1a_l1s_com.voicememo_task.record.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_RECORD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_VM_RECORD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // VOICE_MEMO + + #if (L1_PCM_EXTRACTION) + #if (L1_DYN_DSP_DWNLD == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_pcm_download_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* PCM download feature. */ + /* */ + /* Starting messages: MMI_PCM_DOWNLOAD_START_REQ */ + /* */ + /* Result messages (input): L1_PCM_DOWNLOAD_START_CON */ + /* */ + /* Result messages (output): MMI_PCM_DOWNLOAD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_PCM_DOWNLOAD_STOP_REQ */ + /* L1_PCM_DOWNLOAD_STOP_CON */ + /* */ + /* Stop message (output): MMI_PCM_DOWNLOAD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_DOWNLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.download.command.start = FALSE; + l1a_l1s_com.pcm_task.download.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.download.parameters.session_id = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= + ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8); + + if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN) + { + // Start the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.start = TRUE; + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"PCM Extraction SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + end_process = 1; + } + break; + + case WAIT_DYN_DWNLD: + { + if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN)) + { + // Start the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"PCM Extraction SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_DOWNLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.download.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + + UWORD32 maximum_size; + + if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ) + { + maximum_size = ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size; + if(maximum_size == 0) + { + // Stop the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.stop = TRUE; + } + else + { + l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size; + + } + + // End process + return; + } + else + if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_pcm_upload_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* PCM upload feature. */ + /* */ + /* Starting messages: MMI_PCM_UPLOAD_START_REQ */ + /* */ + /* Result messages (input): L1_PCM_UPLOAD_START_CON */ + /* */ + /* Result messages (output): MMI_PCM_UPLOAD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_PCM_UPLOAD_STOP_REQ */ + /* L1_PCM_UPLOAD_STOP_CON */ + /* */ + /* Stop message (output): MMI_PCM_UPLOAD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_UPLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + l1a_l1s_com.pcm_task.upload.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_UPLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.upload.parameters.session_id = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.upload.parameters.maximum_size = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8); + + if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN) + { + // Start the L1S PCM upload task + l1a_l1s_com.pcm_task.upload.command.start = TRUE; + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"PCM Extraction SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + + + } + + // End process + end_process = 1; + } + break; + + case WAIT_DYN_DWNLD: + { + if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN)) + { + // Start the L1S PCM upload task + l1a_l1s_com.pcm_task.upload.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"PCM Extraction SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_UPLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ) + { + // Stop the L1S PCM recording task + l1a_l1s_com.pcm_task.upload.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_PCM_UPLOAD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + +#else /*L1_DYN_DSP_DWNLD == 0 + +// l1a_mmi_pcm_download_process() +// Description: +// This function is a state machine which handles the */ +// PCM download feature. + // Starting messages: MMI_PCM_DOWNLOAD_START_REQ +// Result messages (input): L1_PCM_DOWNLOAD_START_CON + // Result messages (output): MMI_PCM_DOWNLOAD_START_CON +// Reset messages (input): none + // Stop message (input): MMI_PCM_DOWNLOAD_STOP_REQ + //L1_PCM_DOWNLOAD_STOP_CON +// Stop message (output): MMI_PCM_DOWNLOAD_STOP_CON */ + //Rem: */ + + void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_DOWNLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.download.command.start = FALSE; + l1a_l1s_com.pcm_task.download.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.download.parameters.session_id = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= + ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8); + // Start the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_DOWNLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.download.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + + UWORD32 maximum_size; + + if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ) + { + maximum_size = ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size; + if(maximum_size == 0) + { + // Stop the L1S PCM download task + l1a_l1s_com.pcm_task.download.command.stop = TRUE; + } + else + { + l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size; + + } + + // End process + return; + } + else + if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_pcm_upload_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* PCM upload feature. */ + /* */ + /* Starting messages: MMI_PCM_UPLOAD_START_REQ */ + /* */ + /* Result messages (input): L1_PCM_UPLOAD_START_CON */ + /* */ + /* Result messages (output): MMI_PCM_UPLOAD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_PCM_UPLOAD_STOP_REQ */ + /* L1_PCM_UPLOAD_STOP_CON */ + /* */ + /* Stop message (output): MMI_PCM_UPLOAD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_PCM_UPLOAD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + l1a_l1s_com.pcm_task.upload.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_PCM_UPLOAD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.pcm_task.upload.parameters.session_id = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.pcm_task.upload.parameters.maximum_size = ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1); + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8); + + // Start the L1S voice memo recording task + l1a_l1s_com.pcm_task.upload.command.start = TRUE; + + + *state = WAIT_START_CON; + } + + // End process + end_process = 1; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_PCM_UPLOAD_START_CON) + { + // Reset the start command + l1a_l1s_com.pcm_task.upload.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON); + + *state = WAIT_STOP; + } + + // End process + end_process = 1; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ) + { + // Stop the L1S PCM recording task + l1a_l1s_com.pcm_task.upload.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_PCM_UPLOAD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(!end_process) + } + #endif /* L1_DYN_DSP_DWNLD */ + + #endif /* L1_PCM_EXTRACTION */ + + #if (L1_VOICE_MEMO_AMR) + + #if (L1_DYN_DSP_DWNLD==1) + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_playing_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization playing feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_PLAY_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_PLAY_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_PLAY_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_PLAY_STOP_REQ */ + /* L1_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4, + VM_AMR_PLAY = 5, + VM_AMR_PAUSE = 6, + VM_AMR_PAUSE_CON = 7, + WAIT_RESUME_CON = 8 + + + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_PLAY_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.stop = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.pause = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE; + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if(SignalCode == MMI_VM_AMR_PLAY_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id = ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id; + + if (l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE]==GREEN) + { + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE; + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"VOICE PLAY AMR SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } +// omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE] == GREEN)) + { + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"VOICE PLAY AMR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_PLAY_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON); + + *state = VM_AMR_PLAY ; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + case VM_AMR_PLAY: + { + switch (SignalCode) + { + case MMI_VM_AMR_PAUSE_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE; + *state = VM_AMR_PAUSE_CON; + + } + break; + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE; + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + + case VM_AMR_PAUSE_CON: + { + if(SignalCode==L1_VM_AMR_PAUSE_CON) + { + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON); + + // Change state + *state=VM_AMR_PAUSE; + } + else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + return; + } // case WAIT_PAUSE_CON + // ************* + // * VM_AMR_PAUSE * + // ************* + case VM_AMR_PAUSE: + { + switch(SignalCode) + { + // * MMI requests VM_AMR resume * + case MMI_VM_AMR_RESUME_REQ: + { + l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE; + + // Change state + *state=WAIT_RESUME_CON; + + } + break; + // *-----------------------* + // * MMI requests VM_AMR stop * + // *-----------------------* + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Store stop request in L1A/HISR interface + l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE; + + // Change state + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + // case VM_AMR_PAUSE + // ******************* + // * WAIT_RESUME_CON * + // ******************* + case WAIT_RESUME_CON: + { + if(SignalCode==L1_VM_AMR_RESUME_CON) + { + l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE; + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON); + + // Change state + *state=VM_AMR_PLAY; + } + return; + } // case WAIT_RESUME_CON + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_recording_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization recording feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_RECORD_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_RECORD_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_RECORD_STOP_REQ */ + /* L1_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4 + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_RECORD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.record.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_AMR_RECORD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size; + l1a_l1s_com.voicememo_amr_task.record.parameters.dtx = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used; + l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder; + + // Download UL/DL audio gain to the NDB + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul; + + if(l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE]==GREEN) + { + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE; + + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"VOICE MEMO AMR SM blocked \r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE] == GREEN)) + { + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[32]; + sprintf(str,"VOICE MEMO AMR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_RECORD_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ) + { + // Stop the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_AMR_RECORD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + +#else // L1_DYN_DSP_DWNLD = 0 + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_playing_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization playing feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_PLAY_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_PLAY_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_PLAY_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_PLAY_STOP_REQ */ + /* L1_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_PLAY_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + + void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3, + VM_AMR_PLAY = 4, + VM_AMR_PAUSE = 5, + VM_AMR_PAUSE_CON = 6, + WAIT_RESUME_CON = 7 + + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_PLAY_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.stop = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.pause = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE; + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_AMR_PLAY_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id = ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id; + + // Start the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_PLAY_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON); + + *state = VM_AMR_PLAY ; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + case VM_AMR_PLAY: + { + switch (SignalCode) + { + case MMI_VM_AMR_PAUSE_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE; + *state = VM_AMR_PAUSE_CON; + + } + break; + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE; + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + + case VM_AMR_PAUSE_CON: + { + if(SignalCode==L1_VM_AMR_PAUSE_CON) + { + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON); + + // Change state + *state=VM_AMR_PAUSE; + } + else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + return; + } // case WAIT_PAUSE_CON + // ************* + // * VM_AMR_PAUSE * + // ************* + case VM_AMR_PAUSE: + { + switch(SignalCode) + { + // * MMI requests VM_AMR resume * + case MMI_VM_AMR_RESUME_REQ: + { + l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE; + + // Change state + *state=WAIT_RESUME_CON; + + } + break; + // *-----------------------* + // * MMI requests VM_AMR stop * + // *-----------------------* + case MMI_VM_AMR_PLAY_STOP_REQ: + { + // Store stop request in L1A/HISR interface + l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE; + + // Change state + *state=WAIT_STOP; + + } + break; + case L1_VM_AMR_PLAY_STOP_CON: + { + l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON); + + *state = RESET; + } + break; + } + return; + } + // case VM_AMR_PAUSE + // ******************* + // * WAIT_RESUME_CON * + // ******************* + case WAIT_RESUME_CON: + { + if(SignalCode==L1_VM_AMR_RESUME_CON) + { + l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE; + // Send confirmation to upper layers + l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON); + + // Change state + *state=VM_AMR_PLAY; + } + return; + } // case WAIT_RESUME_CON + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_vm_amr_recording_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* voice memorization recording feature. */ + /* */ + /* Starting messages: MMI_VM_AMR_RECORD_START_REQ */ + /* */ + /* Result messages (input): L1_VM_AMR_RECORD_START_CON */ + /* */ + /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_VM_AMR_RECORD_STOP_REQ */ + /* L1_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Stop message (output): MMI_VM_AMR_RECORD_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + + void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_VM_AMR_RECORD_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + l1a_l1s_com.voicememo_amr_task.record.command.stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_VM_AMR_RECORD_START_REQ) + { + // Download the parameters of the message to the l1a_l1s_com structure. + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size; + l1a_l1s_com.voicememo_amr_task.record.parameters.dtx = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used; + l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder; + + // Download UL/DL audio gain to the NDB + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul; + + // Start the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_VM_AMR_RECORD_START_CON) + { + // Reset the start command + l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ) + { + // Stop the L1S voice memo recording task + l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE; + + // End process + return; + } + else + if (SignalCode == L1_VM_AMR_RECORD_STOP_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD + #endif // L1_VOICE_MEMO_AMR + + #if (SPEECH_RECO) + #if(L1_DYN_DSP_DWNLD == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_enroll_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition enrollment feature. */ + /* */ + /* Starting messages: MMI_SR_ENROLL_START_REQ */ + /* */ + /* Result messages (input): L1_SR_ENROLL_START_CON */ + /* */ + /* Result messages (output): MMI_SR_ENROLL_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_ENROLL_STOP_REQ */ + /* L1_SR_ENROLL_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_ENROLL_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4, + WAIT_BACK_TASK_DONE = 5, + WAIT_L1S_STOP = 6, + WAIT_BACK_STOP = 7 + }; + + UWORD8 *state = &l1a.state[L1A_SR_ENROLL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.enroll_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_ENROLL_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address; + + if(l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE]==GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition enrollment task + l1a_l1s_com.speechreco_task.command.enroll_start = TRUE; + + *state = WAIT_START_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition enrollment task + l1a_l1s_com.speechreco_task.command.enroll_start = TRUE; + *state = WAIT_START_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case WAIT_START_CON: + { + if (SignalCode == L1_SR_ENROLL_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop the speech recognition enroll task + l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // There is an error during the acquisition task? + if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + // There is an error + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the stop confirmation message with no error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) ); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + + } + else + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_update_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_STOP_REQ */ + /* L1_SR_UPDATE_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_update_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_MODEL_LOADED = 3, + WAIT_START_CON = 4, + WAIT_STOP = 5, + WAIT_BACK_TASK_DONE = 6, + WAIT_L1S_STOP = 7, + WAIT_BACK_STOP = 8 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_UPDATE_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + + if(l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON); + + *state = WAIT_MODEL_LOADED; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)) + { + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON); + + *state = WAIT_MODEL_LOADED; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + + } + return; + } + break; + case WAIT_MODEL_LOADED: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_reco_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition reco feature. */ + /* */ + /* Starting messages: MMI_SR_RECO_START_REQ */ + /* */ + /* Result messages (input): L1_SR_RECO_START_CON */ + /* */ + /* Result messages (output): MMI_SR_RECO_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_RECO_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_RECO_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_RECO_START = 3, + WAIT_RECO_STOP = 4, + LOAD_MODEL = 5, + WAIT_MODEL_LOADED = 6, + WAIT_PROCESSING_STOP = 7, + WAIT_L1S_STOP = 8, + WAIT_BACK_STOP = 9 + }; + + UWORD8 *state = &l1a.state[L1A_SR_RECO_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + l1a_l1s_com.speechreco_task.command.reco_stop = FALSE; + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_RECO_START_REQ) + { + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + if (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start the speech recognition reco task + l1a_l1s_com.speechreco_task.command.reco_start = TRUE; + + *state = WAIT_RECO_START; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } + break; + + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)) + { + // Start the speech recognition reco task + l1a_l1s_com.speechreco_task.command.reco_start = TRUE; + *state = WAIT_RECO_START; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + + } + return; + } + break; + case WAIT_RECO_START: + { + if (SignalCode == L1_SR_RECO_START_CON) + { + // Reset the start command + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_RECO_START_CON); + + *state = WAIT_RECO_STOP; + } + // End process + return; + } + break; + + case WAIT_RECO_STOP: + { + if (SignalCode == L1_SR_RECO_STOP_CON) + { + // The acqusition is good or not? + if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the message MMI_SR_RECO_STOP_CON with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if(SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the speech recognition task + l1a_l1s_com.speechreco_task.command.reco_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_RECO_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to tSC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Send the MMI_SR_RECO_STOP_CON with an bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // Fill the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*---------------------------------------------------------*/ + /* l1a_mmi_sr_update_check_process() */ + /*---------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update check feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_CHECK_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_CHECK_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_CHECK_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*---------------------------------------------------------*/ + void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_MODEL = 3, + WAIT_UPDATE_START = 4, + WAIT_UPDATE_STOP = 5, + WAIT_TEMP_SAVE_DONE = 6, + LOAD_MODEL = 7, + WAIT_MODEL_LOADED = 8, + WAIT_PROCESSING_STOP = 9, + WAIT_SAVE_DONE = 10, + WAIT_L1S_STOP = 11, + WAIT_BACK_STOP = 12 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_CHECK_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #define AUDIO_MSG (p_message) + #else + xSignalHeaderRec *conf_msg; + #define AUDIO_MSG (conf_msg->SigP) + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if(SignalCode == MMI_SR_UPDATE_CHECK_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.word_to_check = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + + if (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON); + + *state = WAIT_MODEL; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)) + { + + // Start to download the model to the API + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON); + + *state = WAIT_MODEL; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"SPEECH RECO SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + + } + return; + } + break; + case WAIT_MODEL: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_UPDATE_START; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_START: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_UPDATE_STOP; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_STOP: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ); + + *state = WAIT_TEMP_SAVE_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_TEMP_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) + { + // Reset the command + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + *state = LOAD_MODEL; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + // File the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to SC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + + // End process + return; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + // Is it the good word? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index == + l1a_l1s_com.speechreco_task.parameters.word_to_check ) + { + // Save the message informations in the l1a_l1s_com memory + l1a_l1s_com.speechreco_task.parameters.best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index; + l1a_l1s_com.speechreco_task.parameters.best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score; + l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index; + l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score; + l1a_l1s_com.speechreco_task.parameters.third_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index; + l1a_l1s_com.speechreco_task.parameters.third_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_level = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise; + l1a_l1s_com.speechreco_task.parameters.d_sr_model_size = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size; + + // Reset the stop background task + l1_srback_com.emergency_stop = FALSE; + + // Start the background task to save the model in the database + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check; + l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address; + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_SAVE_DONE; + + // End process + return; + } + else + { + // Change the error to SC_CHECK_ERROR + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR; + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + #endif // OP_RIV_AUDIO + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id = SC_NO_ERROR; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index = l1a_l1s_com.speechreco_task.parameters.best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score = l1a_l1s_com.speechreco_task.parameters.best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index = l1a_l1s_com.speechreco_task.parameters.second_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score = l1a_l1s_com.speechreco_task.parameters.second_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index = l1a_l1s_com.speechreco_task.parameters.third_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score = l1a_l1s_com.speechreco_task.parameters.third_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size; + + #if (OP_RIV_AUDIO == 1) + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) || + (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_UPDATE_STOP_CON) || + (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + + // Undefine message pointer macro. + #undef MSG_AUDIO + + } + #else // L1_DYN_DSP_DWNLD = 0 + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_enroll_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition enrollment feature. */ + /* */ + /* Starting messages: MMI_SR_ENROLL_START_REQ */ + /* */ + /* Result messages (input): L1_SR_ENROLL_START_CON */ + /* */ + /* Result messages (output): MMI_SR_ENROLL_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_ENROLL_STOP_REQ */ + /* L1_SR_ENROLL_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_ENROLL_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3, + WAIT_BACK_TASK_DONE = 4, + WAIT_L1S_STOP = 5, + WAIT_BACK_STOP = 6 + }; + + UWORD8 *state = &l1a.state[L1A_SR_ENROLL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.enroll_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_ENROLL_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address; + + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition enrollment task + l1a_l1s_com.speechreco_task.command.enroll_start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_SR_ENROLL_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.enroll_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop the speech recognition enroll task + l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // There is an error during the acquisition task? + if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + // There is an error + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the stop confirmation message with no error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) ); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + + } + else + if (SignalCode == MMI_SR_ENROLL_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_ENROLL_STOP_CON) + { + // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_ENROLL_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON; + + //Fill the message + ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_update_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_STOP_REQ */ + /* L1_SR_UPDATE_STOP_CON */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_update_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_MODEL_LOADED = 2, + WAIT_START_CON = 3, + WAIT_STOP = 4, + WAIT_BACK_TASK_DONE = 5, + WAIT_L1S_STOP = 6, + WAIT_BACK_STOP = 7 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_UPDATE_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Start to download the model to the API + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON); + + *state = WAIT_MODEL_LOADED; + } + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_STOP; + } + + // End process + return; + } + break; + + case WAIT_STOP: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_BACK_TASK_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_TASK_DONE: + { + if (SignalCode == MMI_SR_UPDATE_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_sr_reco_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition reco feature. */ + /* */ + /* Starting messages: MMI_SR_RECO_START_REQ */ + /* */ + /* Result messages (input): L1_SR_RECO_START_CON */ + /* */ + /* Result messages (output): MMI_SR_RECO_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_RECO_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_RECO_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_RECO_START = 2, + WAIT_RECO_STOP = 3, + LOAD_MODEL = 4, + WAIT_MODEL_LOADED = 5, + WAIT_PROCESSING_STOP = 6, + WAIT_L1S_STOP = 7, + WAIT_BACK_STOP = 8 + }; + + UWORD8 *state = &l1a.state[L1A_SR_RECO_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #else + xSignalHeaderRec *conf_msg; + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + l1a_l1s_com.speechreco_task.command.reco_stop = FALSE; + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_RECO_START_REQ) + { + + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + // Start the speech recognition reco task + l1a_l1s_com.speechreco_task.command.reco_start = TRUE; + + *state = WAIT_RECO_START; + } + + // End process + return; + } + break; + + + case WAIT_RECO_START: + { + if (SignalCode == L1_SR_RECO_START_CON) + { + // Reset the start command + l1a_l1s_com.speechreco_task.command.reco_start = FALSE; + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_RECO_START_CON); + + *state = WAIT_RECO_STOP; + } + // End process + return; + } + break; + + case WAIT_RECO_STOP: + { + if (SignalCode == L1_SR_RECO_STOP_CON) + { + // The acqusition is good or not? + if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the message MMI_SR_RECO_STOP_CON with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if(SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the speech recognition task + l1a_l1s_com.speechreco_task.command.reco_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_RECO_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to tSC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_RECO_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // File the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Send the MMI_SR_RECO_STOP_CON with an bad recognition error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_RECO_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_RECO_STOP_CON; + // Fill the message + ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + + /*---------------------------------------------------------*/ + /* l1a_mmi_sr_update_check_process() */ + /*---------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* speech recognition update check feature. */ + /* */ + /* Starting messages: MMI_SR_UPDATE_CHECK_START_REQ */ + /* */ + /* Result messages (input): L1_SR_UPDATE_START_CON */ + /* */ + /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_SR_UPDATE_CHECK_STOP_REQ */ + /* L1_SR_RECO_STOP_IND */ + /* */ + /* Stop message (output): MMI_SR_UPDATE_CHECK_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*---------------------------------------------------------*/ + void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_MODEL = 2, + WAIT_UPDATE_START = 3, + WAIT_UPDATE_STOP = 4, + WAIT_TEMP_SAVE_DONE = 5, + LOAD_MODEL = 6, + WAIT_MODEL_LOADED = 7, + WAIT_PROCESSING_STOP = 8, + WAIT_SAVE_DONE = 9, + WAIT_L1S_STOP = 10, + WAIT_BACK_STOP = 11 + }; + + UWORD8 *state = &l1a.state[L1A_SR_UPDATE_CHECK_STATE]; + UWORD32 SignalCode = msg->SignalCode; + #if (OP_RIV_AUDIO == 1) + void *p_message; + T_RVF_MB_STATUS mb_status; + #define AUDIO_MSG (p_message) + #else + xSignalHeaderRec *conf_msg; + #define AUDIO_MSG (conf_msg->SigP) + #endif + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.update_stop = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_stop = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_START_REQ) + { + // Download the message parameters to the parameters memory + l1a_l1s_com.speechreco_task.parameters.database_id = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id; + l1a_l1s_com.speechreco_task.parameters.word_index = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.word_to_check = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index; + l1a_l1s_com.speechreco_task.parameters.model_address = l1s_dsp_com.dsp_ndb_ptr->a_model; + l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address; + l1a_l1s_com.speechreco_task.parameters.speech = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech; + l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address; + l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size; + + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Start to download the model to the API + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON); + + *state = WAIT_MODEL; + } + + // End process + return; + } + break; + + case WAIT_MODEL: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + else + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Set the start command of the speech recording task + l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech; + + // Start the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_start = TRUE; + + *state = WAIT_UPDATE_START; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_START: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + } + else + if (SignalCode == L1_SR_UPDATE_START_CON) + { + // Reset the commands + l1a_l1s_com.speechreco_task.command.update_start = FALSE; + l1a_l1s_com.speechreco_task.command.speech_start = FALSE; + + *state = WAIT_UPDATE_STOP; + } + + // End process + return; + } + break; + + case WAIT_UPDATE_STOP: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the speech recognition update task + l1a_l1s_com.speechreco_task.command.update_stop = TRUE; + + // Stop the speech recording task (if present) + l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech; + + *state = WAIT_L1S_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SR_UPDATE_STOP_CON) + { + // There is an error during the update task? + if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // Reset the background task emergency stop + l1_srback_com.emergency_stop = FALSE; + + // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task + l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ); + + *state = WAIT_TEMP_SAVE_DONE; + + // End process + return; + } + else + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + } + else + { + // End process + return; + } + } + break; + + case WAIT_TEMP_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) + { + // Reset the command + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + l1a_l1s_com.speechreco_task.command.processing_stop = FALSE; + + // Reset the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter = 0; + + // The CTO algorithm must be used? + if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO) + { + // Enable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE; + + // Double the vocabulary size + l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1; + } + else + { + // Disable the CTO algorithm + l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE; + } + + *state = LOAD_MODEL; + } + else + { + // End process + return; + } + } + break; + + case LOAD_MODEL: + { + // Initialize the background task stop command + l1_srback_com.emergency_stop = FALSE; + + // Start to load the model to the API + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter; + l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ); + + // Increase the index counter + l1a_l1s_com.speechreco_task.parameters.index_counter++; + + *state = WAIT_MODEL_LOADED; + + // End process + return; + } + break; + + case WAIT_MODEL_LOADED: + { + if (SignalCode == L1_SRBACK_LOAD_MODEL_CON) + { + // Start the DSP processing task + l1a_l1s_com.speechreco_task.command.processing_start = TRUE; + + *state = WAIT_PROCESSING_STOP; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + } + + // End process + return; + } + break; + + case WAIT_PROCESSING_STOP: + { + if (SignalCode == L1_SR_PROCESSING_STOP_CON) + { + // The processing phase is good or not? + if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + *state = LOAD_MODEL; + } + else + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = + ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + // File the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + } + else + if (SignalCode == L1_SR_RECO_STOP_IND) + { + // There is an error during the recognition? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR ) + { + // The CTO algorithm is used? + if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm) + { + // The best word is odd? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 ) + { + // Change the error to SC_CTO_WORD + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD; + + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + + // End process + return; + } + else + { + // Devided by 2 the 4 indexes of the best words in the message + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index >>= 1; + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index >>= 1; + } + } + // Is it the good word? + if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index == + l1a_l1s_com.speechreco_task.parameters.word_to_check ) + { + // Save the message informations in the l1a_l1s_com memory + l1a_l1s_com.speechreco_task.parameters.best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index; + l1a_l1s_com.speechreco_task.parameters.best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score; + l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index; + l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score; + l1a_l1s_com.speechreco_task.parameters.third_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index; + l1a_l1s_com.speechreco_task.parameters.third_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index; + l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_level = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level; + l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise; + l1a_l1s_com.speechreco_task.parameters.d_sr_model_size = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size; + + // Reset the stop background task + l1_srback_com.emergency_stop = FALSE; + + // Start the background task to save the model in the database + l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check; + l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address; + l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ); + + *state = WAIT_SAVE_DONE; + + // End process + return; + } + else + { + // Change the error to SC_CHECK_ERROR + ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR; + } + } + // Forward the message in the MMI_SR_RECO_STOP_CON + l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop the L1S processing task + l1a_l1s_com.speechreco_task.command.processing_stop = TRUE; + + *state = WAIT_L1S_STOP; + + // end process + return; + } + else + { + // end process + return; + } + } + break; + + case WAIT_SAVE_DONE: + { + if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ) + { + // Stop immediatly the background task + l1_srback_com.emergency_stop = TRUE; + + *state = WAIT_BACK_STOP; + + // End process + return; + } + else + if (SignalCode == L1_SRBACK_SAVE_DATA_CON) + { + // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + #endif // OP_RIV_AUDIO + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id = SC_NO_ERROR; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index = l1a_l1s_com.speechreco_task.parameters.best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score = l1a_l1s_com.speechreco_task.parameters.best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index = l1a_l1s_com.speechreco_task.parameters.second_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score = l1a_l1s_com.speechreco_task.parameters.second_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index = l1a_l1s_com.speechreco_task.parameters.third_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score = l1a_l1s_com.speechreco_task.parameters.third_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise; + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size; + + #if (OP_RIV_AUDIO == 1) + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_BACK_STOP: + { + if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) || + (SignalCode == L1_SRBACK_LOAD_MODEL_CON) || + (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) ) + { + // Send the message MMI_SR_UPDATE_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + + case WAIT_L1S_STOP: + { + if ( (SignalCode == L1_SR_UPDATE_STOP_CON) || + (SignalCode == L1_SR_PROCESSING_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_CON) || + (SignalCode == L1_SR_RECO_STOP_IND) ) + { + // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error + #if (OP_RIV_AUDIO == 1) + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON; + + // Fill the message parameter + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id = SC_CHECK_ERROR; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId, + p_message); + #else // OP_RIV_AUDIO + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON; + + //Fill the message + ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR; + + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_message(conf_msg); + #endif + + // Send the confirmation message... + os_send_sig(conf_msg, MMI_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + #endif // OP_RIV_AUDIO + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + + // Undefine message pointer macro. + #undef MSG_AUDIO + + } + + #endif // L1_DYN_DSP_DWNLD + #endif // SPEECH_RECO + #if (L1_AEC == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_aec_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AEC feature. */ + /* */ + /* Starting messages: MMI_AEC_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AEC_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ +#if (L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_AEC_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AEC_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control; + #if (L1_NEW_AEC) + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut; + #endif + + #if (L1_ANR == 1) + if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004) + { + // Noise suppression enabled: enable new ANR module for backward compatibility + l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control + + // Enable L1S ANR task (default settings are used) + l1a_l1s_com.anr_task.parameters.anr_enable = 1; + l1a_l1s_com.anr_task.parameters.min_gain = 0x3313; + l1a_l1s_com.anr_task.parameters.div_factor_shift = -2; + l1a_l1s_com.anr_task.parameters.ns_level = 1; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + else + { + // Noise suppression disabled: disable ANR + l1a_l1s_com.anr_task.parameters.anr_enable = 0; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + #endif + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when + // activating the command at L1s level + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case WAIT_AEC_CON: + { + if (SignalCode == L1_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_confirmation(MMI_AEC_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } +#else + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_AEC_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AEC_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control; + #if (L1_NEW_AEC) + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut; + #endif + + #if (L1_ANR == 1) + if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004) + { + // Noise suppression enabled: enable new ANR module for backward compatibility + l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control + + // Enable L1S ANR task (default settings are used) + l1a_l1s_com.anr_task.parameters.anr_enable = 1; + l1a_l1s_com.anr_task.parameters.min_gain = 0x3313; + l1a_l1s_com.anr_task.parameters.div_factor_shift = -2; + l1a_l1s_com.anr_task.parameters.ns_level = 1; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + else + { + // Noise suppression disabled: disable ANR + l1a_l1s_com.anr_task.parameters.anr_enable = 0; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + #endif + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + + // End process + return; + } + break; + + case WAIT_AEC_CON: + { + if (SignalCode == L1_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_confirmation(MMI_AEC_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD == 1 + #endif // AEC + + #if (L1_AEC == 2) + /*-------------------------------------------------------*/ + /* l1a_mmi_aec_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AEC feature. */ + /* */ + /* Starting messages: MMI_AEC_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AEC_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + #if (L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_AEC_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AQI_AEC_REQ) + { + + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control; + + if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP) + { + + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut; + l1a_l1s_com.aec_task.parameters.aec_mode = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode; + l1a_l1s_com.aec_task.parameters.mu = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu; + l1a_l1s_com.aec_task.parameters.scale_input_ul = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul; + l1a_l1s_com.aec_task.parameters.scale_input_dl = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl; + l1a_l1s_com.aec_task.parameters.div_dmax = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax; + l1a_l1s_com.aec_task.parameters.div_swap_good = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good; + l1a_l1s_com.aec_task.parameters.div_swap_bad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad; + l1a_l1s_com.aec_task.parameters.block_init = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init; +// l1a_l1s_com.aec_task.parameters.block_size = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size; + + } + + if (l1a.dyn_dwnld.semaphore_vect[AEC_STATE_MACHINE] == GREEN) + { + // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when + // activating the command at L1s level + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AEC SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_AEC_CON: + { + if (SignalCode == L1_AQI_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #else + void l1a_mmi_aec_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AEC_REQ = 1, + WAIT_AEC_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AEC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.aec_task.command.start = FALSE; + + *state = WAIT_AEC_REQ; + } + break; + + case WAIT_AEC_REQ: + { + if (SignalCode == MMI_AQI_AEC_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control; + + if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP) + { + + l1a_l1s_com.aec_task.parameters.cont_filter = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter; + l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att; + l1a_l1s_com.aec_task.parameters.coef_smooth = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth; + l1a_l1s_com.aec_task.parameters.es_level_max = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max; + l1a_l1s_com.aec_task.parameters.fact_vad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad; + l1a_l1s_com.aec_task.parameters.thrs_abs = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs; + l1a_l1s_com.aec_task.parameters.fact_asd_fil = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil; + l1a_l1s_com.aec_task.parameters.fact_asd_mut = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut; + l1a_l1s_com.aec_task.parameters.aec_mode = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode; + l1a_l1s_com.aec_task.parameters.mu = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu; + l1a_l1s_com.aec_task.parameters.scale_input_ul = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul; + l1a_l1s_com.aec_task.parameters.scale_input_dl = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl; + l1a_l1s_com.aec_task.parameters.div_dmax = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax; + l1a_l1s_com.aec_task.parameters.div_swap_good = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good; + l1a_l1s_com.aec_task.parameters.div_swap_bad = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad; + l1a_l1s_com.aec_task.parameters.block_init = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init; +// l1a_l1s_com.aec_task.parameters.block_size = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size; + + } + + #if (L1_ANR == 1) + if (l1a_l1s_com.aec_task.aec_control & 0x0004) + { + // Noise suppression enabled: enable new ANR module for backward compatibility + l1a_l1s_com.aec_task.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control + + // Enable L1S ANR task (default settings are used) + l1a_l1s_com.anr_task.parameters.anr_enable = 1; + l1a_l1s_com.anr_task.parameters.min_gain = 0x3313; + l1a_l1s_com.anr_task.parameters.div_factor_shift = -2; + l1a_l1s_com.anr_task.parameters.ns_level = 1; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + else + { + // Noise suppression disabled: disable ANR + l1a_l1s_com.anr_task.parameters.anr_enable = 0; + l1a_l1s_com.anr_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for AEC confirmation and + // ANR confirmation would occur on the same frame + } + #endif + + // Start the L1S AEC task + l1a_l1s_com.aec_task.command.start = TRUE; + + *state = WAIT_AEC_CON; + } + + // End process + return; + } + break; + + case WAIT_AEC_CON: + { + if (SignalCode == L1_AQI_AEC_CON) + { + // Send the AEC confirmation message + l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD == 1 + #endif // L1_AEC == 2 + + + #if (FIR) + /*-------------------------------------------------------*/ + /* l1a_mmi_fir_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* FIR feature. */ + /* */ + /* Starting messages: MMI_AUDIO_FIR_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AUDIO_FIR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_fir_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_FIR_REQ = 1, + WAIT_FIR_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_FIR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.fir_task.command.start = FALSE; + + *state = WAIT_FIR_REQ; + } + break; + + case WAIT_FIR_REQ: + { + if (SignalCode == MMI_AUDIO_FIR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.fir_task.parameters.fir_loop = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_loop; + l1a_l1s_com.fir_task.parameters.update_fir = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->update_fir; + l1a_l1s_com.fir_task.parameters.fir_ul_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_ul_coefficient; + + // we update FIR coefficients even if L1_IIR==1 because in case of loop mode + // this is the old FIR API that is used + l1a_l1s_com.fir_task.parameters.fir_dl_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient; + + #if (L1_IIR == 1) + if (l1a_l1s_com.fir_task.parameters.update_fir & DL_FIR) + { + // FIR DL update enabled: enable new IIR/DL module for backward compatibility + + // Enable L1S IIR task + // Settings tuned to have same behavior as DL FIR + l1a_l1s_com.iir_task.parameters.iir_enable = 1; // Filter always enabled + l1a_l1s_com.iir_task.parameters.nb_iir_blocks = 0; // IIR part disabled + l1a_l1s_com.iir_task.parameters.iir_coefs = 0; + l1a_l1s_com.iir_task.parameters.nb_fir_coefs = 0x1f; + l1a_l1s_com.iir_task.parameters.fir_coefs = (WORD16 *)((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient; + l1a_l1s_com.iir_task.parameters.input_scaling = 0; + l1a_l1s_com.iir_task.parameters.fir_scaling = 0; + l1a_l1s_com.iir_task.parameters.input_gain_scaling = 0; + l1a_l1s_com.iir_task.parameters.output_gain_scaling = 0; + l1a_l1s_com.iir_task.parameters.output_gain = 0xffff; // Used for IIR using in FIR mode + l1a_l1s_com.iir_task.parameters.feedback = 0; + l1a_l1s_com.iir_task.command.update = TRUE; + + // Here we do not wait for L1S confirmation to have simple implementation + // because the state machine already wait for FIR confirmation and + // there is no chance that upper layer frees the memory used to store + // DL coefficients before L1S copy them into API + } + #endif + + // Start the L1S FIR task + l1a_l1s_com.fir_task.command.start = TRUE; + + *state = WAIT_FIR_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_FIR_CON: + { + if (SignalCode == L1_AUDIO_FIR_CON) + { + // Send the FIR confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_FIR_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // FIR + #if (AUDIO_MODE) + /*-------------------------------------------------------*/ + /* l1a_mmi_audio_mode_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio mode features. */ + /* */ + /* Starting messages: MMI_AUDIO_MODE_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): MMI_AUDIO_MODE_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_audio_mode_process (xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_AUDIO_MODE_REQ = 1, + WAIT_AUDIO_MODE_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AUDIO_MODE_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.audio_mode_task.command.start = FALSE; + + *state = WAIT_AUDIO_MODE_REQ; + } + break; + + case WAIT_AUDIO_MODE_REQ: + { + if (SignalCode == MMI_AUDIO_MODE_REQ) + { + switch (((T_MMI_AUDIO_MODE *)(msg->SigP))->audio_mode) + { + case GSM_ONLY: + { + // Set the GSM only mode + l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_GSM_ONLY; + break; + } + case BT_CORDLESS: + { + // Set the bluetooth cordless mode + l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_CORDLESS; + break; + } + case BT_HEADSET: + { + // Set the bluetooth headset mode + l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_HEADSET; + break; + } + default : + { + break; + } + } // switch + + // Start the L1S AUDIO MODE task + l1a_l1s_com.audio_mode_task.command.start = TRUE; + + *state = WAIT_AUDIO_MODE_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_AUDIO_MODE_CON: + { + if (SignalCode == L1_AUDIO_MODE_CON) + { + // Send the AUDIO MODE confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_MODE_CON); + + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // AUDIO_MODE + #if (MELODY_E2) + #if(L1_DYN_DSP_DWNLD==1) + /*-------------------------------------------------------*/ + /* l1a_mmi_melody0_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 0 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY0_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY0_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY0_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY0_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY0_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M0_RESET = 0, + M0_WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + M0_WAIT_LOAD_INSTRUMENT = 3, + M0_WAIT_STOP = 4, + M0_WAIT_UNLOAD_INSTRUMENT = 5 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY0_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M0_RESET: + { + // Reset the commands: + l1a_l1s_com.melody0_e2_task.command.start = FALSE; + l1a_l1s_com.melody0_e2_task.command.stop = FALSE; + + *state = M0_WAIT_START_REQ; + } + break; + + case M0_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY0_E2_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody0_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE]==GREEN) + { + + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Reset the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON); + + *state = M0_WAIT_LOAD_INSTRUMENT; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E20 SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN)) + { + // Reset the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON); + + *state = M0_WAIT_LOAD_INSTRUMENT; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E20 SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case M0_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // The load instrument confirmation message is for the melody 0 + if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody0 + l1a_l1s_com.melody0_e2_task.command.start = TRUE; + + *state = M0_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_STOP: + { + if (SignalCode == L1_MELODY0_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody0_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON); +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + + *state = M0_RESET; + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody1_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 1 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY1_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY1_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY1_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY1_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY1_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M1_RESET = 0, + M1_WAIT_START_REQ = 1, + WAIT_DYN_DWNLD = 2, + M1_WAIT_LOAD_INSTRUMENT = 3, + M1_WAIT_STOP = 4, + M1_WAIT_UNLOAD_INSTRUMENT = 5 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY1_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M1_RESET: + { + // Reset the commands: + l1a_l1s_com.melody1_e2_task.command.start = FALSE; + l1a_l1s_com.melody1_e2_task.command.stop = FALSE; + + *state = M1_WAIT_START_REQ; + } + break; + + case M1_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY1_E2_START_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody1_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN) + { + // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Reset the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON); + + *state = M1_WAIT_LOAD_INSTRUMENT; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E21 SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN)) + { +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Reset the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON); + + *state = M1_WAIT_LOAD_INSTRUMENT; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"E21 SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case M1_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // The load instrument confirmation message is for the melody 1 + if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody1 + l1a_l1s_com.melody1_e2_task.command.start = TRUE; + + *state = M1_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_STOP: + { + if (SignalCode == L1_MELODY1_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody1_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON); + + *state = M1_RESET; +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + +#else // L1_DYN_DSP_DWNLD = 0 + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody0_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 0 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY0_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY0_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY0_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY0_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY0_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + + void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M0_RESET = 0, + M0_WAIT_START_REQ = 1, + M0_WAIT_LOAD_INSTRUMENT = 2, + M0_WAIT_STOP = 3, + M0_WAIT_UNLOAD_INSTRUMENT = 4 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY0_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M0_RESET: + { + // Reset the commands: + l1a_l1s_com.melody0_e2_task.command.start = FALSE; + l1a_l1s_com.melody0_e2_task.command.stop = FALSE; + + *state = M0_WAIT_START_REQ; + } + break; + + case M0_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY0_E2_START_REQ) + { +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + // Download the parameters from the message: + l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody0_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + // Reset the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody0_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody0_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1a_l1s_com.melody0_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON); + + *state = M0_WAIT_LOAD_INSTRUMENT; + } + + // End process + return; + } + break; + + case M0_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // The load instrument confirmation message is for the melody 0 + if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody0 + l1a_l1s_com.melody0_e2_task.command.start = TRUE; + + *state = M0_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_STOP: + { + if (SignalCode == L1_MELODY0_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0); + + *state = M0_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY0_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody0_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M0_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON); + + *state = M0_RESET; +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + + /*-------------------------------------------------------*/ + /* l1a_mmi_melody1_e2_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* melody 1 format E2 feature. */ + /* */ + /* Starting messages: MMI_MELODY1_E2_START_REQ */ + /* */ + /* Result messages (input): L1_MELODY1_E2_START_CON */ + /* */ + /* Result messages (output): MMI_MELODY1_E2_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_MELDOY0_E2_STOP_REQ */ + /* L1_MELODY1_E2_STOP_CON */ + /* */ + /* Stop message (output): MMI_MELODY1_E2_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg) + { + enum states + { + M1_RESET = 0, + M1_WAIT_START_REQ = 1, + M1_WAIT_LOAD_INSTRUMENT = 2, + M1_WAIT_STOP = 3, + M1_WAIT_UNLOAD_INSTRUMENT = 4 + }; + + UWORD8 *state = &l1a.state[L1A_MELODY1_E2_STATE], i; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case M1_RESET: + { + // Reset the commands: + l1a_l1s_com.melody1_e2_task.command.start = FALSE; + l1a_l1s_com.melody1_e2_task.command.stop = FALSE; + + *state = M1_WAIT_START_REQ; + } + break; + + case M1_WAIT_START_REQ: + { + if (SignalCode == MMI_MELODY1_E2_START_REQ) + { +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Disable trace DSP upon E2 MELODY activation + l1_disable_dsp_trace(); +#endif + + // Download the parameters from the message: + l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id; + l1a_l1s_com.melody1_e2_task.parameters.loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback; + + // Reset the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE; + + // Initialize the buffer parameters + l1a_l1s_com.melody1_e2_task.parameters.ptr_buf = NULL; + l1a_l1s_com.melody1_e2_task.parameters.buffer_size = 0; + l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit + l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1; + + // Jump the NumberOfOscillator parameter + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + + // Read the Header of the melody description in order to download the time factor + // clean the MSB of the global time factor register + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF; + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + (UWORD8 *)(&(i))); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i; + + + // Find the number of insturment of the melody (jump the header memory) + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument)); + + for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++) + { + // find the beginning of the melody description (after the header field) + // and put it in the buf_ptr buffer + l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1a_l1s_com.melody1_e2_task.parameters.buffer_size, + (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf, + 1, + &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i])); + } + + // Initialize the size (in byte unit) of the header + l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument; + + // download the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1); + + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON); + + *state = M1_WAIT_LOAD_INSTRUMENT; + } + + // End process + return; + } + break; + + case M1_WAIT_LOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // The load instrument confirmation message is for the melody 1 + if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + + } + else + { + // Start to play the melody1 + l1a_l1s_com.melody1_e2_task.command.start = TRUE; + + *state = M1_WAIT_STOP; + } + } + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Set the emergency flag + l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_STOP: + { + if (SignalCode == L1_MELODY1_E2_STOP_CON) + { + // Unload the instrument + l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1); + + *state = M1_WAIT_UNLOAD_INSTRUMENT; + } + else + if (SignalCode == MMI_MELODY1_E2_STOP_REQ) + { + // Stop the melody 0 L1S task: + l1a_l1s_com.melody1_e2_task.command.stop = TRUE; + } + + // End process + return; + } + break; + + case M1_WAIT_UNLOAD_INSTRUMENT: + { + if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON) + { + if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 ) + { + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON); + + *state = M1_RESET; +#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4)) + // Enable trace DSP upon E2 MELODY deactivation + l1_enable_dsp_trace(); +#endif + } + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif // L1_DYN_DSP_DWNLD + #endif // MELODY_E2 + + #if (L1_CPORT == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_cport_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* cport configuration feature. */ + /* */ + /* Starting messages: MMI_CPORT_CONFIGURE_REQ */ + /* */ + /* Result messages (input): L1_CPORT_CONFIGURE_CON */ + /* */ + /* Result messages (output): MMI_CPORT_CONFIGURE_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_cport_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_CPORT_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.cport_task.command.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_CPORT_CONFIGURE_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.cport_task.parameters.configuration = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->configuration; + l1a_l1s_com.cport_task.parameters.cpcfr1 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr1; + l1a_l1s_com.cport_task.parameters.cpcfr2 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr2; + l1a_l1s_com.cport_task.parameters.cpcfr3 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr3; + l1a_l1s_com.cport_task.parameters.cpcfr4 = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr4; + l1a_l1s_com.cport_task.parameters.cptctl = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptctl; + l1a_l1s_com.cport_task.parameters.cptdat = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptdat; + l1a_l1s_com.cport_task.parameters.cpttaddr = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpttaddr; + l1a_l1s_com.cport_task.parameters.cptvs = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptvs; + l1a_l1s_com.cport_task.parameters.ctrl = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->ctrl; + + // Start the L1S cport task + l1a_l1s_com.cport_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_CPORT_CONFIGURE_CON) + { + // Forward the stop confirmation message + l1a_audio_send_result(MMI_CPORT_CONFIGURE_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + + } // switch + } // while(1) + } + #endif // L1_CPORT == 1 + + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_audio_onoff_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio on/off feature. */ + /* */ + /* Starting messages: MMI_AUDIO_ONOFF_REQ */ + /* */ + /* Result messages (input): L1_AUDIO_ONOFF_CON */ + /* */ + /* Result messages (output): MMI_AUDIO_ONOFF_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AUDIO_ONOFF_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_AUDIO_ONOFF_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.audio_onoff_task.parameters.onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->onoff_value; + + // Start the L1S keybeep task + l1a_l1s_com.audio_onoff_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + break; + + case WAIT_START_CON: + { + if (SignalCode == L1_AUDIO_ONOFF_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif + + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_audio_onoff_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio on/off feature. */ + /* */ + /* Starting messages: MMI_AUDIO_ONOFF_REQ */ + /* */ + /* Result messages (input): L1_AUDIO_ONOFF_CON */ + /* */ + /* Result messages (output): MMI_AUDIO_ONOFF_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AUDIO_ONOFF_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_AUDIO_ONOFF_REQ) + { + // Download the parameters from the message: + l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vul_onoff_value; + l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vdl_onoff_value; + // Start the L1S keybeep task + l1a_l1s_com.audio_onoff_task.command.start = TRUE; + + *state = WAIT_START_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_AUDIO_ONOFF_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif + + + #if (L1_EXT_AUDIO_MGT == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_ext_audio_mgt_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* external audio management feature. */ + /* */ + /* Starting messages: MMI_EXT_AUDIO_MGT_START_REQ */ + /* */ + /* Result messages (input): L1_STEREOPATH_DRV_START_CON */ + /* */ + /* Result messages (output): MMI_EXT_AUDIO_MGT_START_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): MMI_EXT_AUDIO_MGT_STOP_REQ */ + /* L1_STEREOPATH_DRV_STOP_CON */ + /* */ + /* Stop message (output): MMI_EXT_AUDIO_MGT_STOP_CON */ + /* */ + /* Rem: */ + /* ---- */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_ext_audio_mgt_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_START_REQ = 1, + WAIT_START_CON = 2, + WAIT_STOP = 3 + }; + + UWORD8 *state = &l1a.state[L1A_EXT_AUDIO_MGT_STATE]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 sample_rate; + while(1) + { + switch(*state) + { + case RESET: + { +#if(L1_BT_AUDIO ==1) + midi_task_running=FALSE; +#endif + *state = WAIT_START_REQ; + } + break; + + case WAIT_START_REQ: + { + if (SignalCode == MMI_EXT_AUDIO_MGT_START_REQ) + { + // save global variable + l1s.ext_audio_mgt.session_id = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->session_id; + #if(L1_BT_AUDIO ==1) + l1_audio_bt_init(AUDIO_EXT_MIDI_BUFFER_SIZE); + if(bt_audio.connected_status==TRUE) + { + bt_audio.pcmconfig.bitsPerSample=16; + bt_audio.pcmconfig.numChannels =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo+1; + sample_rate =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency; + bt_audio.pcmconfig.sampleRate =l1_ext_audio_get_frequencyrate(sample_rate); + bt_audio.audio_configure_callback(&bt_audio.pcmconfig); + } + #endif + if(bt_audio.connected_status==FALSE) + { + // Download the stereopath description. + l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation = AUDIO_SP_DMA_ALLOC_MCU; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct = l1_ext_audio_mgt_dma_handler; + l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->DMA_channel_number; + l1a_l1s_com.stereopath_drv_task.parameters.data_type = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->data_type; + l1a_l1s_com.stereopath_drv_task.parameters.source_port = AUDIO_SP_SOURCE_IMIF; + l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->source_buffer_address; + l1a_l1s_com.stereopath_drv_task.parameters.element_number = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->element_number; + l1a_l1s_com.stereopath_drv_task.parameters.frame_number = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->frame_number; + l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo; + l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier = AUDIO_SP_EXT_AUDIO_ID; + + // Start the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.start = TRUE; +#if(L1_BT_AUDIO ==1) + midi_task_running=TRUE; +#endif + + *state = WAIT_START_CON; + } + else + { + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON); + + *state = WAIT_STOP; + } + // End process + return; + } + } + // omaps00090550 break; + + case WAIT_START_CON: + { + if (SignalCode == L1_STEREOPATH_DRV_START_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON); + + *state = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_EXT_AUDIO_MGT_STOP_REQ) + { + if(bt_audio.connected_status==TRUE) + { + + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON); + midi_task_running=FALSE; + *state = RESET; + } + else + { + // Stop the L1S stereopath task + l1a_l1s_com.stereopath_drv_task.command.stop = TRUE; + + // End process + return; + } + } + + if (SignalCode == L1_STEREOPATH_DRV_STOP_CON) + { + + // Send the stop confirmation message + l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON); + #if(L1_BT_AUDIO ==1) + midi_task_running=FALSE; + #endif + *state = RESET; + } + else + { + // End process + return; + } + } + break; + } // switch + } // while(1) + } + #endif // EXT_AUDIO_MGT == 1 + + #if (L1_ANR == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_anr_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* ANR feature. */ + /* */ + /* Starting messages: MMI_ANR_REQ */ + /* */ + /* Result messages (input): L1_ANR_CON */ + /* */ + /* Result messages (output): MMI_ANR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_enable = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable; + l1a_l1s_com.anr_task.parameters.min_gain = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain; + l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level; + + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_ANR_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ANR_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#else + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_enable = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable; + l1a_l1s_com.anr_task.parameters.min_gain = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain; + l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level; + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_ANR_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ANR_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + #endif // L1_ANR +#if (L1_ANR == 2) // ANR 2.13 + /*-------------------------------------------------------*/ + /* l1a_mmi_anr_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* ANR 2.13 feature. */ + /* */ + /* Starting messages: MMI_AQI_ANR_REQ */ + /* */ + /* Result messages (input): L1_AQI_ANR_CON */ + /* */ + /* Result messages (output): MMI_AQI_ANR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_ul_control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control; + l1a_l1s_com.anr_task.parameters.control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level; + l1a_l1s_com.anr_task.parameters.tone_ene_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th; + l1a_l1s_com.anr_task.parameters.tone_cnt_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th; + + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ANR SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_ANR_CON) + { + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_anr_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_ANR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.anr_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_ANR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.anr_task.parameters.anr_ul_control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control; + l1a_l1s_com.anr_task.parameters.control = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.anr_task.parameters.ns_level = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level; + l1a_l1s_com.anr_task.parameters.tone_ene_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th; + l1a_l1s_com.anr_task.parameters.tone_cnt_th = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th; + + // Enable the L1S task + l1a_l1s_com.anr_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_ANR_CON) + { + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD +#endif // L1_ANR + + #if (L1_IIR == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_iir_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* IIR feature. */ + /* */ + /* Starting messages: MMI_IIR_REQ */ + /* */ + /* Result messages (input): L1_IIR_CON */ + /* */ + /* Result messages (output): MMI_IIR_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_iir_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_IIR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.iir_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_IIR_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.iir_task.parameters.iir_enable = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_enable; + l1a_l1s_com.iir_task.parameters.nb_iir_blocks = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_iir_blocks; + l1a_l1s_com.iir_task.parameters.iir_coefs = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_coefs; + l1a_l1s_com.iir_task.parameters.nb_fir_coefs = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_fir_coefs; + l1a_l1s_com.iir_task.parameters.fir_coefs = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_coefs; + l1a_l1s_com.iir_task.parameters.input_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->input_scaling; + l1a_l1s_com.iir_task.parameters.fir_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_scaling; + l1a_l1s_com.iir_task.parameters.input_gain_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->input_gain_scaling; + l1a_l1s_com.iir_task.parameters.output_gain_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain_scaling; + l1a_l1s_com.iir_task.parameters.output_gain = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain; + l1a_l1s_com.iir_task.parameters.feedback = ((T_MMI_IIR_REQ *)(msg->SigP))->feedback; + + // Enable the L1S task + l1a_l1s_com.iir_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + break; + + case WAIT_CON: + { + if (SignalCode == L1_IIR_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_IIR_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif // L1_IIR + + #if (L1_AGC_UL == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_agc_ul_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AGC UL feature. */ + /* */ + /* Starting messages: MMI_AQI_AGC_UL_REQ */ + /* */ + /* Result messages (input): L1_AQI_AGC_UL_CON */ + /* */ + /* Result messages (output): MMI_AQI_AGC_UL_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_UL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_ul_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_UL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_ul_task.parameters.agc_ul_control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control; + l1a_l1s_com.agc_ul_task.parameters.control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_ul_task.parameters.frame_size = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_ul_task.parameters.targeted_level = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_ul_task.parameters.signal_up = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_ul_task.parameters.signal_down = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_ul_task.parameters.max_scale = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + + if (l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.agc_ul_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_UL SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.agc_ul_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_UL SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_UL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_UL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_ul_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_UL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_ul_task.parameters.agc_ul_control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control; + l1a_l1s_com.agc_ul_task.parameters.control = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_ul_task.parameters.frame_size = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_ul_task.parameters.targeted_level = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_ul_task.parameters.signal_up = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_ul_task.parameters.signal_down = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_ul_task.parameters.max_scale = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + // Enable the L1S task + l1a_l1s_com.agc_ul_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_UL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + +#endif // L1_AGC_UL + + +#if (L1_AGC_DL == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_agc_dl_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* AGC DL feature. */ + /* */ + /* Starting messages: MMI_AQI_AGC_DL_REQ */ + /* */ + /* Result messages (input): L1_AQI_AGC_DL_CON */ + /* */ + /* Result messages (output): MMI_AQI_AGC_DL_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_DL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_dl_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_DL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_dl_task.parameters.agc_dl_control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control; + l1a_l1s_com.agc_dl_task.parameters.control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_dl_task.parameters.frame_size = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_dl_task.parameters.targeted_level = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_dl_task.parameters.signal_up = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_dl_task.parameters.signal_down = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_dl_task.parameters.max_scale = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + + if (l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.agc_dl_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_DL SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.agc_dl_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"AGC_DL SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_DL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_AGC_DL_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.agc_dl_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_AGC_DL_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.agc_dl_task.parameters.agc_dl_control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control; + l1a_l1s_com.agc_dl_task.parameters.control = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control; + l1a_l1s_com.agc_dl_task.parameters.frame_size = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size; + l1a_l1s_com.agc_dl_task.parameters.targeted_level = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level; + l1a_l1s_com.agc_dl_task.parameters.signal_up = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up; + l1a_l1s_com.agc_dl_task.parameters.signal_down = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down; + l1a_l1s_com.agc_dl_task.parameters.max_scale = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta; + l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast; + l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag; + + // Enable the L1S task + l1a_l1s_com.agc_dl_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_AGC_DL_CON) + { + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + +#endif // L1_AGC_DL + + + #if (L1_IIR == 2) + /*-------------------------------------------------------*/ + /* l1a_mmi_iir_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* IIR feature. */ + /* */ + /* Starting messages: MMI_AQI_IIR_DL_REQ */ + /* */ + /* Result messages (input): L1_AQI_IIR_DL_CON */ + /* */ + /* Result messages (output): MMI_AQI_IIR_DL_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_iir_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_IIR_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.iir_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_IIR_DL_REQ) + { + l1a.iir_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.iir_task.parameters = (T_MMI_AQI_IIR_DL_REQ *) (msg->SigP); + + // Enable the L1S task + l1a_l1s_com.iir_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_CON: + { + if (SignalCode == L1_AQI_IIR_DL_CON) + { + os_free_sig(l1a.iir_req_msg_ptr); + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_IIR_DL_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif // L1_IIR + + #if (L1_WCM == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_wcm_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* WCM feature. */ + /* */ + /* Starting messages: MMI_AQI_WCM_REQ */ + /* */ + /* Result messages (input): L1_AQI_WCM_CON */ + /* */ + /* Result messages (output): MMI_AQI_WCM_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_wcm_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_WCM_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.wcm_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_WCM_REQ) + { + l1a.wcm_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + + // Load the message into the l1a_l1s_com memory + l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP); + + if (l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.wcm_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"WCM SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.wcm_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"WCM SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_WCM_CON) + { + os_free_sig(l1a.wcm_req_msg_ptr); + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_wcm_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_WCM_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.wcm_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_WCM_REQ) + { + l1a.wcm_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP); + + // Enable the L1S task + l1a_l1s_com.wcm_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_WCM_CON) + { + os_free_sig(l1a.wcm_req_msg_ptr); + // Send the start confirmation message + l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD + +#endif // L1_WCM + +#if (L1_DRC == 1) // DRC 1.x +// DRC NDB API +T_DRC_MCU_DSP *drc_ndb; +#if (CODE_VERSION == SIMULATION) + T_DRC_MCU_DSP drc_ndb_sim; +#endif + + /*-------------------------------------------------------*/ + /* l1a_mmi_drc_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* DRC 1.x feature. */ + /* */ + /* Starting messages: MMI_AQI_DRC_REQ */ + /* */ + /* Result messages (input): L1_AQI_DRC_CON */ + /* */ + /* Result messages (output): MMI_AQI_DRC_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if(L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_drc_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_DRC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.drc_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_DRC_REQ) + { + l1a.drc_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP); + + if (l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN) + { + // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD + // when activating the task at L1s level + + // Enable the L1S task + l1a_l1s_com.drc_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"DRC SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.drc_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"DRC SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_DRC_CON) + { + os_free_sig(l1a.drc_req_msg_ptr); + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } +#else + void l1a_mmi_drc_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_DRC_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.drc_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_AQI_DRC_REQ) + { + l1a.drc_req_msg_ptr = msg; + l1a.l1_msg_forwarded = TRUE; + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP); + + // Enable the L1S task + l1a_l1s_com.drc_task.command.update = TRUE; + + *state = WAIT_CON; + } + // End process + return; + } + break; + case WAIT_CON: + { + if (SignalCode == L1_AQI_DRC_CON) + { + os_free_sig(l1a.drc_req_msg_ptr); + + // Send the confirmation message + l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } +#endif // L1_DYN_DSP_DWNLD +#endif // L1_DRC + + #if (L1_LIMITER == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_limiter_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* LIMITER feature. */ + /* */ + /* Starting messages: MMI_LIMITER_REQ */ + /* */ + /* Result messages (input): L1_LIMITER_CON */ + /* */ + /* Result messages (output): MMI_LIMITER_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ + void l1a_mmi_limiter_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_LIMITER_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the commands + l1a_l1s_com.limiter_task.command.update = FALSE; + l1a_l1s_com.limiter_task.command.partial_update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_LIMITER_REQ) + { + // Load the message into the l1a_l1s_com memory. + l1a_l1s_com.limiter_task.parameters.limiter_enable = ((T_MMI_LIMITER_REQ *)(msg->SigP))->limiter_enable; + l1a_l1s_com.limiter_task.parameters.block_size = ((T_MMI_LIMITER_REQ *)(msg->SigP))->block_size; + l1a_l1s_com.limiter_task.parameters.slope_update_period = ((T_MMI_LIMITER_REQ *)(msg->SigP))->slope_update_period; + l1a_l1s_com.limiter_task.parameters.nb_fir_coefs = ((T_MMI_LIMITER_REQ *)(msg->SigP))->nb_fir_coefs; + l1a_l1s_com.limiter_task.parameters.filter_coefs = ((T_MMI_LIMITER_REQ *)(msg->SigP))->filter_coefs; + l1a_l1s_com.limiter_task.parameters.thr_low_0 = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_0; + l1a_l1s_com.limiter_task.parameters.thr_low_slope = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_slope; + l1a_l1s_com.limiter_task.parameters.thr_high_0 = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_0; + l1a_l1s_com.limiter_task.parameters.thr_high_slope = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_slope; + l1a_l1s_com.limiter_task.parameters.gain_fall = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_fall; + l1a_l1s_com.limiter_task.parameters.gain_rise = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_rise; + + // Enable the L1S task + l1a_l1s_com.limiter_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_CON: + { + if (SignalCode == L1_LIMITER_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_LIMITER_CON); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + #endif // L1_LIMITER + + #if (L1_ES == 1) + /*-------------------------------------------------------*/ + /* l1a_mmi_es_process() */ + /*-------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* Echo Suppressor feature. */ + /* */ + /* Starting messages: MMI_ES_REQ */ + /* */ + /* Result messages (input): L1_ES_CON */ + /* */ + /* Result messages (output): MMI_ES_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none */ + /* */ + /* Stop message (output): none */ + /* */ + /*-------------------------------------------------------*/ +#if (L1_DYN_DSP_DWNLD == 1) + void l1a_mmi_es_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_DYN_DWNLD = 2, + WAIT_CON = 3 + }; + + UWORD8 *state = &l1a.state[L1A_ES_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.es_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ES_REQ) + { + // Load the message into the l1a_l1s_com memory + l1a_l1s_com.es_task.parameters.es_enable = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable; + l1a_l1s_com.es_task.parameters.es_behavior = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior; + + if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM) + { + // Load every parameters from the message + l1a_l1s_com.es_task.parameters.es_config.es_mode = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode; + l1a_l1s_com.es_task.parameters.es_config.es_gain_dl = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr; + l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr; + l1a_l1s_com.es_task.parameters.es_config.switching_time = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time; + l1a_l1s_com.es_task.parameters.es_config.switching_time_dt = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt; + l1a_l1s_com.es_task.parameters.es_config.hang_time = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3]; + } + if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // WARNING: The following code must be copied in the state WAIT_DYN_DWNLD + // when ES task is activated at L1s level + + // Enable the L1S task + l1a_l1s_com.es_task.command.update = TRUE; + + *state = WAIT_CON; + } + else + { + *state = WAIT_DYN_DWNLD; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ES SM blocked by DYN DWNLD\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + } + + // End process + return; + } + // omaps00090550 break; + case WAIT_DYN_DWNLD: + { + if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN) + { + // Enable the L1S task + l1a_l1s_com.es_task.command.update = TRUE; + + *state = WAIT_CON; + + #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5)) + if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD)) + { + char str[30]; + sprintf(str,"ES SM un-blocked\r\n"); + #if(CODE_VERSION == SIMULATION) + trace_fct_simu_dyn_dwnld(str); + #else + rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT); + #endif + } + #endif // (TRACE_TYPE == 1) || (TRACE_TYPE == 4) + } + return; + } + // omaps00090550 break; + case WAIT_CON: + { + if (SignalCode == L1_ES_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ES_CON); + + *state = RESET; + } + + // End process + return; + } + // omaps00090550 break; + } // switch + } // while(1) + } + +#else + void l1a_mmi_es_process(xSignalHeaderRec *msg) + { + enum states + { + RESET = 0, + WAIT_REQ = 1, + WAIT_CON = 2 + }; + + UWORD8 *state = &l1a.state[L1A_ES_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while(1) + { + switch(*state) + { + case RESET: + { + // Reset the command + l1a_l1s_com.es_task.command.update = FALSE; + + *state = WAIT_REQ; + } + break; + + case WAIT_REQ: + { + if (SignalCode == MMI_ES_REQ) + { + // Load the message into the l1a_l1s_com memory + l1a_l1s_com.es_task.parameters.es_enable = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable; + l1a_l1s_com.es_task.parameters.es_behavior = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior; + + if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM) + { + // Load every parameters from the message + l1a_l1s_com.es_task.parameters.es_config.es_mode = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode; + l1a_l1s_com.es_task.parameters.es_config.es_gain_dl = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1; + l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2 = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr; + l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr; + l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr; + l1a_l1s_com.es_task.parameters.es_config.switching_time = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time; + l1a_l1s_com.es_task.parameters.es_config.switching_time_dt = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt; + l1a_l1s_com.es_task.parameters.es_config.hang_time = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2]; + l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3] = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3]; + } + + // Enable the L1S task + l1a_l1s_com.es_task.command.update = TRUE; + + *state = WAIT_CON; + } + + // End process + return; + } + break; + + case WAIT_CON: + { + if (SignalCode == L1_ES_CON) + { + // Send the start confirmation message + l1a_audio_send_confirmation(MMI_ES_CON); + + *state = RESET; + } + + // End process + return; + } + break; + } // switch + } // while(1) + } + #endif //L1_DYN_DSP_DWNLD + #endif // L1_ES + +// New Vocoder IF process + +#if (L1_VOCODER_IF_CHANGE == 1) + void l1a_mmi_vocoder_cfg_process (xSignalHeaderRec *msg) + { + + BOOL msg_parameter; + + enum states + { + WAIT_REQ = 0, + WAIT_ENABLE_CON = 1, + WAIT_DISABLE_CON = 2 + }; + + enum vocoder_cfg_req + { + VOCODER_DISABLE_REQ = 0, + VOCODER_ENABLE_REQ = 1 + }; + + UWORD8 *state = &l1a.state[L1A_VOCODER_CFG_STATE]; + UWORD32 SignalCode = msg->SignalCode; + + while (1) + { + switch(*state) + { + case WAIT_REQ: + { + + // Waiting PS messages.... + + // If SignalCode is an MPHC_STOP_DEDICATED_REQ and vocoders are enabled, they must be stopped automatically + +#if(L1_CHECK_COMPATIBLE == 1) + if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE)) || (l1a.vch_auto_disable == TRUE)) +#else + if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE))) +#endif + { + // Command vocoder disabling at L1A-L1s interface and set the automatic disable flag to TRUE + l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND; + l1a.vocoder_state.automatic_disable = TRUE; + *state = WAIT_DISABLE_CON; +#if(L1_CHECK_COMPATIBLE == 1) + l1a.vch_auto_disable = FALSE; +#endif + } + else if (SignalCode == MMI_TCH_VOCODER_CFG_REQ) + { + // In case the vocoder START or STOP is commanded by PS + + + msg_parameter = ((T_MMI_TCH_VOCODER_CFG_REQ *) (msg->SigP))->vocoder_state; + // If it is an explicit STOP.... + if (msg_parameter == VOCODER_DISABLE_REQ) + { +#if (AUDIO_DEBUG == 1) + trace_info.audio_debug_var.vocoder_enable_status = 0; +#endif + + //... explicitely disable vocoders if they're enabled commanidng the stop at L1A-L1s interface + if (l1a.vocoder_state.enabled == TRUE) + { + l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND; + l1a.vocoder_state.automatic_disable = FALSE; + *state = WAIT_DISABLE_CON; + } + else + { + // ...else, if vocoders are already disabled but PS is sending erroneously the request + // send him however the confirmation without doing anything (protection check). + // In case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + } + } + else if (msg_parameter == VOCODER_ENABLE_REQ) + { +#if (AUDIO_DEBUG == 1) + trace_info.audio_debug_var.vocoder_enable_status = 1; +#endif + // If it is a START + if (l1a.vocoder_state.enabled == FALSE) + { + // Command the start at L1A-L1s interface if vocoders are disabled + l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_ENABLE_COMMAND; + *state = WAIT_ENABLE_CON; + } + else + { + // ...else, if vocoders are already enabled but PS is sending erroneously the request + // send him however the confirmation without doing anything (protection check). + // In case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + } + } + } + return; + } + // omaps00090550 break; + case WAIT_ENABLE_CON: + { + if (SignalCode == L1_VOCODER_CFG_ENABLE_CON) + { + // when L1s confirms the enabling, forward the confirmation to PS and set the vocoders enabled flag to TRUE + l1a.vocoder_state.enabled = TRUE; + + // in case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + *state = WAIT_REQ; + } + return; + } + // omaps00090550 break; + case WAIT_DISABLE_CON: + { + if (SignalCode == L1_VOCODER_CFG_DISABLE_CON) + { + // when L1s confirms the disabling, forwards the confirmation to PS and set the vocoders enabled flag to FALSE + l1a.vocoder_state.enabled = FALSE; + *state = WAIT_REQ; + + if (l1a.vocoder_state.automatic_disable == FALSE) + { + // Only in case it is an explicit request to STOP the vocoders (made previously by PS) + // send him the confirmation. + // In case L1 standalone or SIMULATION, confirmation message must be + // sent to MMI mailbox, else with complete PS software the message must be + // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined). + + l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE); + } + else + // Reset automatic disable flag + l1a.vocoder_state.automatic_disable = FALSE; + } + return; + } + // omaps00090550 break; + } + } + + } +#endif // L1_VOCODER_IF_CHANGE == 1 + void l1a_mmi_outen_cfg_process (xSignalHeaderRec *msg) + { +#if (OP_RIV_AUDIO == 1) + + UWORD32 SignalCode = msg->SignalCode; + void *p_message; + T_RVF_MB_STATUS mb_status; + + if (SignalCode == MMI_OUTEN_CFG_REQ) + { + l1a_l1s_com.outen_cfg_task.outen1 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen1; + l1a_l1s_com.outen_cfg_task.outen2 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen2; + l1a_l1s_com.outen_cfg_task.outen3 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen3; + l1a_l1s_com.outen_cfg_task.classD = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->classD; + + l1a_l1s_com.outen_cfg_task.command_requested++; + // Send the confirmation message + l1a_audio_send_confirmation(MMI_OUTEN_CFG_CON); + } + else if(SignalCode == MMI_OUTEN_CFG_READ_REQ) + { + // Allocate the Riviera buffer + mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external, + sizeof (T_MMI_OUTEN_CFG_READ_CON), + (T_RVF_BUFFER **) (&p_message)); + + // If insufficient resources, then report a memory error and abort. + if (mb_status == RVF_RED) + { + // the memory is insufficient to continue the non regression test + AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR); + return; + } + + // Fill the message ID + ((T_MMI_OUTEN_CFG_READ_CON *)(p_message))->header.msg_id = MMI_OUTEN_CFG_READ_CON; + + // Fill the message parameter + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen1 = l1a_l1s_com.outen_cfg_task.outen1; + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen2 = l1a_l1s_com.outen_cfg_task.outen2; + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen3 = l1a_l1s_com.outen_cfg_task.outen3; + ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->classD = l1a_l1s_com.outen_cfg_task.classD; + + // send the messsage to the audio entity + rvf_send_msg (p_audio_gbl_var->addrId,p_message); + } +#endif /*OP_RIV_AUDIO*/ + } /* end function l1a_mmi_outen_cfg_process */ + +#if(L1_BT_AUDIO ==1) +void l1a_mmi_bt_process(xSignalHeaderRec *msg) +{ + UWORD32 SignalCode = msg->SignalCode; + + if (SignalCode == MMI_BT_ENABLE_REQ) + bt_audio.connected_status = TRUE; + else if(SignalCode == MMI_BT_DISABLE_REQ) + bt_audio.connected_status = FALSE; + +} +#endif +#endif // AUDIO_TASK +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_back.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,609 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_SRBACK.C + * + * Filename l1audio_back.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#define L1_SRBACK_COM // switch to define the l1_srback_com variable +#define L1_AUDIOBACK_MELODYE2 // switch to define the audio background variable + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) && (L1_AUDIO_BACKGROUND_TASK) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added form e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added form e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added form e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added form e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif + + /****************************************/ + /* Prototypes for audio background task */ + /****************************************/ + void l1_audio_background_task (UWORD32 argc, void *argv); + #if (SPEECH_RECO) + void srback_CTO_algorithm (API *RAM_address); + void srback_save_model_temp (API *RAM_address_input, UWORD16 *RAM_address_output); + #endif + #if (MELODY_E2 && FIR) + void audio_background_melody_e2_download_instrument_manager(xSignalHeaderRec *msg); + #endif + /**************************************/ + /* External prototypes */ + /**************************************/ + #if (SPEECH_RECO) + extern void Cust_srback_save_model (UWORD8 database, UWORD8 index, API *RAM_address); + extern void Cust_srback_save_speech (UWORD8 database, UWORD8 index, UWORD16 *start_buffer, UWORD16 *stop_buffer, UWORD16 *start_speech, UWORD16 *stop_speech); + extern void Cust_srback_load_model (UWORD8 database, UWORD8 index, API *RAM_address); + #endif + #if (MELODY_E2 && FIR) + extern UWORD16 Cust_audio_melody_E2_load_instrument (UWORD8 customer_instrument_id, + API *API_address, + UWORD16 allowed_size); + #endif + +#if (OP_RIV_AUDIO == 0) + /*--------------------------------------------------------*/ + /* l1_audio_background_task() */ + /*--------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio background feature. */ + /* */ + /* Starting messages: L1_SRBACK_SAVE_DATA_REQ */ + /* L1_SRBACK_TEMP_SAVE_DATA_REQ */ + /* L1_SRBACK_LOAD_MODEL_REQ */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): L1_SRBACK_SAVE_DATA_CON */ + /* L1_SRBACK_TEMP_SAVE_DATA_CON */ + /* L1_SRBACK_LOAD_MODEL_CON */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): non */ + /* */ + /* Stop message (output): L1_SRBACK_SAVE_DATA_CON */ + /* L1_SRBACK_TEMP_SAVE_DATA_CON */ + /* L1_SRBACK_LOAD_MODEL_CON */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Rem: to stop immeditly the speech reco feature a flag */ + /* ---- is created: l1_srback_com.emergency_stop */ + /* */ + /*--------------------------------------------------------*/ + void l1_audio_background_task(UWORD32 argc, void *argv) + { + xSignalHeaderRec *receive_msg, *confirm_msg; + UWORD8 index; + + while(1) + { + // Wait until a message is receive + receive_msg = os_receive_sig(SRBACK_QUEUE); + + #if (SPEECH_RECO) + if (receive_msg->SignalCode == L1_SRBACK_SAVE_DATA_REQ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the customer function to save the model + Cust_srback_save_model( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + if ( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->speech ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the customer function to save the speech from a circular buffer to the database + Cust_srback_save_speech( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->start_buffer, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->stop_buffer, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->start_address, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->stop_address); + } + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_SAVE_DATA_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_SAVE_DATA_REQ + else + if (receive_msg->SignalCode == L1_SRBACK_LOAD_MODEL_REQ) + { + if ( ( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->CTO_enable ) == FALSE ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to load a model + Cust_srback_load_model( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + } + else + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Calculate the good index + index = ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index>>1; + + // Call the function to load a model with the good index + Cust_srback_load_model( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->database_id, + index, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + + // The CTO algorithm is used and the model index is odd + if ( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index & 0x01 ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to apply the CTO algorithm to the loaded model + srback_CTO_algorithm( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + } + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_LOAD_MODEL_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_LOAD_MODEL_REQ + else + if (receive_msg->SignalCode == L1_SRBACK_TEMP_SAVE_DATA_REQ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to save the model in a temporary buffer + srback_save_model_temp( ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address_input, + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address_output ); + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_TEMP_SAVE_DATA_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_TEMP_SAVE_DATA_REQ + #endif // SPEECH_RECO + #if (MELODY_E2 && FIR) + if ( (receive_msg->SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ) || + (receive_msg->SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) ) + { + audio_background_melody_e2_download_instrument_manager(receive_msg); + } // L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ + #endif // MELODY_E2 + + // Deallocate the received message + os_free_sig(receive_msg); + DEBUGMSG(status,NU_ALLOC_ERR) + } // while(1) + } +#endif // OP_RIV_AUDIO + + #if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* srback_CTO_algorithm() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : RAM_address */ + /* */ + /* Return : none */ + /* */ + /* Description : apply the CTO algorithm to the model. */ + /* */ + /*-------------------------------------------------------*/ + void srback_CTO_algorithm (API *RAM_address) + { + UWORD16 model_size, frame; + UWORD8 frame_size; + + // This alogrithm changes the model: + // |frame 0|frame 1|frame 2|frame 3|frame 4|frame 5|frame 6|frame 7|... + // into a garbage model: + // |0000000|frame 1|0000000|0000000|frame 4|0000000|0000000|frame 7|... + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address++; + + frame = 0; + + while( (frame <= model_size) && + (l1_srback_com.emergency_stop == FALSE) ) + { + if ((frame % 3) == 1) + { + // This frame is kept + RAM_address += SC_SR_MODEL_FRAME_SIZE; + } + else + { + // This frame is set to 0 + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address++ = 0; + frame_size--; + } + } + + frame++; + } + } + + /*-------------------------------------------------------*/ + /* srback_CTO_algorithm() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : RAM_address_input */ + /* RAM_address_output */ + /* */ + /* Return : none */ + /* */ + /* Description : apply the CTO algorithm to the model. */ + /* */ + /*-------------------------------------------------------*/ + void srback_save_model_temp (API *RAM_address_input, UWORD16 *RAM_address_output) + { + UWORD16 model_size; + UWORD8 frame_size; + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address_input; + + // save the header of the model + *RAM_address_output++ = *RAM_address_input++; + + while( (model_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address_output++ = *RAM_address_input++; + frame_size--; + } + model_size--; + } + } + #endif // SPEECH_RECO + +#if (OP_RIV_AUDIO == 0) + #if (MELODY_E2 && FIR) + /*--------------------------------------------------------*/ + /*audio_background_melody_e2_download_instrument_manager()*/ + /*--------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is used to load/unload the instrument of */ + /* the melodies E2. */ + /* */ + /* Starting messages: */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none. */ + /* */ + /* Stop message (output): */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Rem: to stop immediatly the instrument download flags */ + /* ---- is created: */ + /* l1a_l1s_com.melody0_e2_task.parameters.emergency_stop */ + /* l1a_l1s_com.melody1_e2_task.parameters.emergency_stop */ + /* */ + /*--------------------------------------------------------*/ + void audio_background_melody_e2_download_instrument_manager(xSignalHeaderRec *msg) + { + xSignalHeaderRec *confirm_msg; + UWORD8 instrument_number, max_number_of_instrument, instrument_id, id; + UWORD16 size; + UWORD32 address; + + if (msg->SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ) + { + // Load the instrument + + // Init the first address + address = ( ((UWORD32)(l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_wave)) + - SC_AUDIO_MCU_API_BEGIN_ADDRESS ); + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[0] = + (API)( (address>>1) + SC_AUDIO_DSP_API_BEGIN_ADDRESS ); + + // Download the instrument + max_number_of_instrument = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument; + for(instrument_number=0; instrument_number < max_number_of_instrument ; instrument_number++) + { + // No instrument was previously download + if (audioback_melody_e2.number_of_user[instrument_number] == 0) + { + // load the insturment ID + instrument_id = + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[instrument_number]; + + // Find if this instrument was already downloaded + id = 0; + while ( (id < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT) && + ((instrument_id != audioback_melody_e2.instrument_id[id]) || + (audioback_melody_e2.number_of_user[id] == 0)) ) + { + id++; + } + + if (id < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT) + { + // This insturment was already downloaded + // copy the address of this instrument + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[instrument_number] = + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[id]; + + // The size of this instrument is 0 + audioback_melody_e2.instrument_size[instrument_number] = 0; + } + else + { + // Load the customer instrument + size = Cust_audio_melody_E2_load_instrument ( + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[instrument_number], + audioback_melody_e2.API_address, + audioback_melody_e2.allowed_size); + + // Added to stop the L1 in case of download error + if (size == 0) + { + // Send a message to stop the L1 + /* send the stop command to the audio L1 */ + /* allocate the buffer for the message to the L1 */ + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + + if (confirm_msg != NULL) + { + /* send the stop command to the audio L1 */ + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(confirm_msg->SigP))->melody_id == 0) + { + confirm_msg->SignalCode = MMI_MELODY0_E2_STOP_REQ; + } + else + { + confirm_msg->SignalCode = MMI_MELODY1_E2_STOP_REQ; + } + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Save the size of this instrument + audioback_melody_e2.instrument_size[instrument_number] = size; + } + + // Update the Cust_audio_melody_E2_load_instrument argument + audioback_melody_e2.API_address += audioback_melody_e2.instrument_size[instrument_number]; + audioback_melody_e2.allowed_size -= audioback_melody_e2.instrument_size[instrument_number]; + + // Put the DSP address to the NDB API for the next instrument + if (instrument_number < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT-1) + { + address = ( ((UWORD32)(audioback_melody_e2.API_address)) + - SC_AUDIO_MCU_API_BEGIN_ADDRESS ); + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[instrument_number + 1] = + (API)( (address>>1) + SC_AUDIO_DSP_API_BEGIN_ADDRESS ); + } + + // Save the instrument ID + audioback_melody_e2.instrument_id[instrument_number] = instrument_id; + } + + // Increase the number of user of this instrument number + audioback_melody_e2.number_of_user[instrument_number]++; + } + + // Send the load confirmation message + confirm_msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill the parameter + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON *)(confirm_msg->SigP))->melody_id = + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id; + + confirm_msg->SignalCode = L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON; + + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + else + if (msg->SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) + { + // Unload the instrument + max_number_of_instrument = ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument; + for(instrument_number = max_number_of_instrument; instrument_number > 0 ; instrument_number--) + { + // Decrease the number of user of this instrument number + audioback_melody_e2.number_of_user[instrument_number-1]--; + + // Check if the instrument must be removed + if (audioback_melody_e2.number_of_user[instrument_number-1] == 0) + { + // Increase the size and decrease the pointer to the API with the size + // of the removed instrument + // Update the Cust_audio_melody_E2_load_instrument argument + audioback_melody_e2.API_address -= audioback_melody_e2.instrument_size[instrument_number-1]; + audioback_melody_e2.allowed_size += audioback_melody_e2.instrument_size[instrument_number-1]; + } + } + + // Send the unload confirmation message + confirm_msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill the paramter + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON *)(confirm_msg->SigP))->melody_id = + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id; + + confirm_msg->SignalCode = L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON; + + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + #endif // MELODY_E2 +#endif // OP_RIV_AUDIO +#endif // AUDIO_TASK == 1 && L1_AUDIO_BACKGROUND_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_drive.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,280 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_DRIVE.C + * + * Filename l1audio_drive.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif + + #include "l1audio_macro.h" + + /**************************************/ + /* Prototypes for L1 SYNCH manager */ + /**************************************/ + void vocoder_mute_dl (BOOL mute); + void vocoder_mute_ul (BOOL mute); + #if (AUDIO_DSP_FEATURES == 1) + void L1_audio_sidetone_write(UWORD16 sidetone_value); + void L1_audio_CAL_DlVolume_write(UWORD16 vol_value); + void L1_audio_CAL_UlVolume_write(UWORD16 vol_value); + void L1_audio_volume_speed_write(UWORD16 volspeed_value); + #endif + + /**************************************/ + /* External prototypes */ + /**************************************/ + + /*-------------------------------------------------------*/ + /* vocoder_mute_dl() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Mute the DL vocoder. */ + /* */ + /*-------------------------------------------------------*/ + void vocoder_mute_dl(BOOL mute) + { + if (mute) + { + // Set the DL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= (0x01<<14); + } + else + { + // Reset the DL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(0x01<<14); + } + } + + /*-------------------------------------------------------*/ + /* vocoder_mute_ul() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Mute the UL vocoder. */ + /* */ + /*-------------------------------------------------------*/ + void vocoder_mute_ul(BOOL mute) + { + if (mute) + { + // Set the UL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= (0x01<<15); + } + else + { + // Reset the UL vocoder mute bit in the d_tch_mode register + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(0x01<<15); + } + } + + #if (AUDIO_DSP_FEATURES == 1) + /*-------------------------------------------------------*/ + /* L1_audio_sidetone_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write sidetone gain in API for DSP */ + /* sidetone process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_sidetone_write(UWORD16 sidetone_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_sidetone_level = (API) sidetone_value; + } + + /*-------------------------------------------------------*/ + /* L1_audio_CAL_DlVolume_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write DL gain in API for DSP vol ctrl */ + /* process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_CAL_DlVolume_write(UWORD16 vol_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_vol_dl_level = (API) vol_value; + } + + /*-------------------------------------------------------*/ + /* L1_audio_CAL_UlVolume_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write UL gain in API for DSP vol ctrl */ + /* process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_CAL_UlVolume_write(UWORD16 vol_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_vol_ul_level = (API) vol_value; + } + + /*-------------------------------------------------------*/ + /* L1_audio_volume_speed_write() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : write volume speed in API for DSP vol */ + /* ctrl process */ + /* */ + /*-------------------------------------------------------*/ + void L1_audio_volume_speed_write(UWORD16 volspeed_value) + { + l1s_dsp_com.dsp_ndb_ptr->d_vol_speed = (API) volspeed_value; + } + + #endif /* DSP_AUDIO_FEAT */ + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_func.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,1310 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_FUNC.C + * + * Filename l1audio_func.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + + +/************************************/ +/* Include files... */ +/************************************/ +#include "nucleus.h" //omaps00090550 +#include "l1_macro.h" + +#include "l1_macro.h" +#include "l1_confg.h" +//#include "l1audio_defty.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_abb.h" + #include "l1audio_btapi.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #if TESTMODE + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + #endif // TESTMODE + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "sys_inth.h" + #include "abb.h" + #include "l1audio_stereo.h" + #endif + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_abb.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #include"l1mp3_const.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #include"l1aac_const.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #if TESTMODE + #include "l1tm_msgty.h" + #include "l1tm_signa.h" + #include "l1tm_varex.h" + #endif // TESTMODE + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "sys_inth.h" + #include "abb.h" + #include "l1audio_stereo.h" + #endif + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif +#if (OP_RIV_AUDIO == 1) + #include "rv_general.h" + #include "audio_api.h" + #include "audio_structs_i.h" + #include "audio_var_i.h" + #include "audio_macro_i.h" + #include "audio_const_i.h" + #endif + + #include "l1audio_macro.h" + + /**************************************/ + /* Prototypes for L1S audio function */ + /**************************************/ + UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst); + UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src); + #if (MELODY_E2) + UWORD16 audio_twentyms_to_TDMA_convertion(UWORD16 twentyms_value); + #endif + #if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst); + UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src); + #endif + #if (L1_VOICE_MEMO_AMR) + UWORD8 copy_byte_data_le_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_dst); + UWORD8 copy_byte_data_le_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_src); + #endif + #if (L1_EXT_AUDIO_MGT == 1) + void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status); + #endif + #if (L1_IIR == 2) + void l1_audio_iir4x_copy_params(); + #endif + + #if (L1_AGC_UL== 1) + void l1_audio_agc_ul_copy_params(); + #endif + + #if (L1_AGC_DL== 1) + void l1_audio_agc_dl_copy_params(); + #endif + + #if (L1_DRC == 1) + void l1_audio_drc1x_copy_params(); + #endif + +#if(L1_BT_AUDIO ==1)||(L1_WCM ==1) +void l1_audio_manager(UWORD8 *src, UWORD16 size); +void l1_audio_bt_init(UINT16 media_buf_size); +extern void l1mp3_dma_it_handler(SYS_UWORD16 d_dma_channel_it_status); +extern void l1aac_dma_it_handler(SYS_UWORD16 d_dma_channel_it_status); +#endif +#if(L1_BT_AUDIO ==1) +T_L1_BT_AUDIO bt_audio; + +extern T_MP3_DMA_PARAM *mp3_dma; +extern T_AAC_DMA_PARAM *aac_dma; +extern void l1a_bt_audio_noti_process(); +extern UWORD16 pending_dec_req; + +#endif + /**************************************/ + /* External prototypes */ + /**************************************/ + extern UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + + #if ((L1_STEREOPATH == 1) && (OP_L1_STANDALONE == 1)) + extern void l1tm_stereopath_DMA_handler(SYS_UWORD16 dma_status); + #if TESTMODE + extern T_STP_DRV_MCU_DSP *stp_drv_ndb; + #endif + #endif + + #if (L1_EXT_AUDIO_MGT == 1) + extern NU_HISR EXT_AUDIO_MGT_hisr; + extern T_MIDI_DMA_PARAM midi_buf; + #endif + + #if (L1_DRC == 1) + extern T_DRC_MCU_DSP *drc_ndb; + #endif + + /*-------------------------------------------------------*/ + /* copy_data_from_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies the data from the buffer */ + /* (buffer size: buffer_size, start address: ptr_buf) to */ + /* the destination indicated by ptr_dst. The size of the */ + /* data to download is data_size. The session_id */ + /* indicates to the custom flash manager the type of */ + /* data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst) + { + UWORD8 error_id = 0; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *ptr_dst++ = *(*ptr_buf)++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size != 0) + { + *buffer_size = data_size; + error_id = Cust_get_pointer( ptr_buf, buffer_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + } + } + + return(error_id); + } + + /*-------------------------------------------------------*/ + /* copy_data_to_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies the data to the buffer */ + /* (buffer size: buffer_size, start address: ptr_buf) */ + /* from the source indicated by ptr_src. The size of the */ + /* data to save is data_size. The session_id */ + /* indicates to the custom flash manager the type of */ + /* data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src) + { + UWORD8 error_id = 0; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *(*ptr_buf)++ = *ptr_src++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if (data_size != 0) + { + *buffer_size = data_size; + error_id = Cust_get_pointer(ptr_buf, buffer_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + } + } + + return(error_id); + } + + #if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + /*-------------------------------------------------------*/ + /* copy_byte_data_from_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data from */ + /* the buffer (buffer size (in byte): buffer_size, */ + /* start address: ptr_buf) to the destination indicated */ + /* by ptr_dst. The size of the data to download is */ + /* data_size(in byte). The session_id indicates to the */ + /* custom flash manager the type of data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst) + { + UWORD8 error_id = 0; + UWORD16 requested_size; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *ptr_dst++ = *(*ptr_buf)++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size != 0) + { + // Calculate the size of the data to request in 16-bit word + if (*buffer_size & 0x0001) + { + // The size is a odd value + requested_size = (data_size >> 1) + 1; + } + else + { + // the size is an even value + requested_size = (data_size >> 1); + } + + error_id = Cust_get_pointer( (UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + return(error_id); + } + + /*-------------------------------------------------------*/ + /* copy_data_to_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data to the */ + /* buffer (buffer size in byte: buffer_size, start */ + /* address: ptr_buf) from the source indicated by */ + /* ptr_src. The size in byte of the data to save is */ + /* data_size. The session_id indicates to the custom */ + /* flash manager the type of data. */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src) + { + UWORD8 error_id = 0; + UWORD16 requested_size; + + while (data_size != 0) + { + while( (data_size !=0) && (*buffer_size != 0) ) + { + *(*ptr_buf)++ = *ptr_src++; + data_size--; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if (data_size != 0) + { + // Calculate the size of the data to request in 16-bit word + if (*buffer_size & 0x0001) + { + // The size is a odd value + requested_size = (data_size >> 1) + 1; + } + else + { + // the size is an even value + requested_size = (data_size >> 1); + } + + error_id = Cust_get_pointer((UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + return(error_id); + } + #endif //#if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + + #if (MELODY_E2) + + /*-------------------------------------------------------*/ + /* audio_twentyms_to_TDMA_convertion() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : 20ms value */ + /* */ + /* Return : TDMA value */ + /* */ + /* Description : */ + /* This function convert a duration from 20ms unit to */ + /* TDMA unit. */ + /* */ + /*-------------------------------------------------------*/ + UWORD16 audio_twentyms_to_TDMA_convertion(UWORD16 twentyms_value) + { + UWORD16 TDMA_value; + + // 20ms # 4 TDMA + TDMA_value = twentyms_value << 2; + + // Compensation factor: 1 TDMA each 60ms. + TDMA_value += (twentyms_value/3); + + return(TDMA_value); + } + #endif // MELODY_E2 + + #if (L1_VOICE_MEMO_AMR) + /*-------------------------------------------------------*/ + /* copy_byte_data_le_from_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data from */ + /* the buffer (buffer size (in byte): buffer_size, */ + /* start address: ptr_buf) to the destination indicated */ + /* by ptr_dst. The size of the data to download is */ + /* data_size(in byte). The session_id indicates to the */ + /* custom flash manager the type of data. */ + /* Data in buffer is expected to be big-endian and will */ + /* be copied in order to retrieve little-endian order in */ + /* ptr_dst */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_le_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_dst) + { + UWORD8 error_id = 0; + UWORD16 requested_size; + UWORD16 data_size_inv = 0; + UWORD16 temp_uword16 = 0 ; //omaps00090550 + + while (data_size_inv != data_size) + { + /* we go from 0 to data_size copying to MSB (even numbers) then LSB (odd numbers) of DSP */ + while( (data_size_inv != data_size) && (*buffer_size != 0) ) + { + if (data_size_inv & 0x0001) + { + temp_uword16 |= *(*ptr_buf)++; + *(ptr_dst)++ = temp_uword16; + } + else + { + temp_uword16 = (*(*ptr_buf)++ << 8); + } + data_size_inv++; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size_inv != data_size) + { + // Calculate the size of the data to request in 16-bit word + if ((data_size - data_size_inv) & 0x0001) + { + // The size is an odd value + requested_size = ((data_size - data_size_inv) >> 1) + 1; + } + else + { + // the size is an even value + requested_size = ((data_size - data_size_inv) >> 1); + } + + error_id = Cust_get_pointer((UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error is occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + if (data_size & 0x0001) + { + *(ptr_dst)++ = temp_uword16; + } + + return(error_id); + } + + /*-------------------------------------------------------*/ + /* copy_byte_data_le_to_buffer() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : session_id */ + /* buffer_size */ + /* data_size */ + /* ptr_dst */ + /* ptr_src */ + /* */ + /* Return : error_id */ + /* */ + /* Description : */ + /* This function copies byte per byte the data to the */ + /* buffer (buffer size in byte: buffer_size, start */ + /* address: ptr_buf) from the source indicated by */ + /* ptr_src. The size in byte of the data to save is */ + /* data_size. The session_id indicates to the custom */ + /* flash manager the type of data. */ + /* Data is expected to be little-endian in ptr_src and */ + /* will be copied in order to retrieve big-endian */ + /* order in buffer */ + /* */ + /*-------------------------------------------------------*/ + UWORD8 copy_byte_data_le_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_src) + { + UWORD8 error_id = 0; + UWORD8 data_size_inv = 0; + UWORD16 requested_size; + UWORD16 temp_uword16=0; //omaps00090550 + + /* we go from 0 to data_size copying MSB (even numbers) then LSB (odd numbers) from DSP */ + while (data_size_inv != data_size) + { + while( (data_size_inv != data_size) && (*buffer_size != 0) ) + { + /* if data_size_inv is odd, we need the LSB of the DSP word */ + if (data_size_inv & 0x0001) + { + *(*ptr_buf)++ = (UWORD8)(temp_uword16 & 0x00FF); + } + /* if data_size_inv is even, we need the MSB of the DSP word */ + else + { + temp_uword16 = *(ptr_src)++; + *(*ptr_buf)++ = (UWORD8)(temp_uword16 >> 8); + } + data_size_inv++; + (*buffer_size)--; + } + // A new buffer is requested in order to finish to copy the data + if ( data_size_inv != data_size) + { + // Calculate the size of the data to request in 16-bit word + if ((data_size - data_size_inv) & 0x0001) + { + // The size is a odd value + requested_size = ((data_size - data_size_inv) >> 1) + 1; + } + else + { + // the size is an even value + requested_size = ((data_size - data_size_inv) >> 1); + } + + error_id = Cust_get_pointer((UWORD16 **)ptr_buf, &requested_size, session_id); + + // An error occured + if (error_id) + return(error_id); + + *buffer_size = (requested_size << 1); + } + } + + return(error_id); + } + #endif + + #if (L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) + /*-------------------------------------------------------*/ + /* l1_audio_api_handler() */ + /*-------------------------------------------------------*/ + /* Parameters : */ + /* Return : */ + /* Functionality : API int management */ + /*-------------------------------------------------------*/ + void l1_audio_api_handler(void) + { + UWORD16 rootcause; + + if (l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier == AUDIO_SP_TESTS_ID) + { + #if (TESTMODE && (OP_L1_STANDALONE == 1)) + rootcause = stp_drv_ndb->d_cport_api_dma_rootcause; + + l1tm_stereopath_DMA_handler((SYS_UWORD16) rootcause); + #endif + } + } /* l1_audio_api_handler() */ + #endif // (L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) + + #if (L1_EXT_AUDIO_MGT == 1) + /*-------------------------------------------------------*/ + /* l1_ext_audio_mgt_dma_handler() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : dma_status */ + /* */ + /* Return : none */ + /* */ + /* Description : */ + /* This function is used to handle a DMA interrupt */ + /* that will notify to the external midi play process */ + /* that a new buffer is needed. */ + /* */ + /*-------------------------------------------------------*/ + void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status) + { + NU_Activate_HISR(&EXT_AUDIO_MGT_hisr); // activate external MIDI HISR + } + #endif + + #if (L1_LIMITER == 1) + /*-------------------------------------------------------*/ + /* l1_audio_lim_update_mul_low_high() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to update mul_low and mul_high */ + /* Limiter parameters in function to volume gain (Q15) */ + /* First the function read the last controlled volume */ + /* in the MCU/DSP API then it processed mul_low[0/1] */ + /* and mul_high[0/1] according to following equations: */ + /* */ + /* thr_low = - thr_low_slope x volume + thr_low_0 */ + /* thr_high = - thr_high_slope x volume + thr_high_0 */ + /* */ + /* mul_low[0] = 32767 / thr_low */ + /* mul_low[1] = 32767 x thr_low */ + /* mul_high[0] = 32767 / thr_high */ + /* mul_high[1] = 32767 x thr_high */ + /*-------------------------------------------------------*/ + void l1_audio_lim_update_mul_low_high() + { +#if (CODE_VERSION != SIMULATION) + #if (ANLG_FAM == 3) + WORD16 volume_q15 = ABB_Read_DLGain(); + #endif + #if (ANLG_FAM == 11) + WORD16 volume_q15 = (WORD16)(l1_audio_abb_Read_DLGain()); + #endif +#else + WORD16 volume_q15 = 0x4000; // -6 dB for example in simulation +#endif + WORD16 thr_low, thr_high; + + /* Process Thr_low */ + thr_low = (- (l1a_l1s_com.limiter_task.parameters.thr_low_slope * volume_q15)>>15) + + l1a_l1s_com.limiter_task.parameters.thr_low_0; +// if (thr_low > 32767) //OMAPS00090550 +// thr_low = 32767; + + /* Process Thr_high */ + thr_high = (- (l1a_l1s_com.limiter_task.parameters.thr_high_slope * volume_q15)>>15) + + l1a_l1s_com.limiter_task.parameters.thr_high_0; +// if (thr_high > 32767) //OMAPS00090550 +// thr_high = 32767; + + /* Process amd store mul_low[0/1] */ + if (thr_low != 0) + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_low[0] = 32767 / thr_low; // Q0 + else + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_low[0] = 32767; // should never happen + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_low[1] = thr_low; // Q15 + + /* Process and store mul_high[0/1] */ + if (thr_high != 0) + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_high[0] = 32767 / thr_high; // Q0 + else + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_high[0] = 32767; // should never happen + l1s_dsp_com.dsp_ndb_ptr->a_lim_mul_high[1] = thr_high; // Q15 + } + + /*-------------------------------------------------------*/ + /* l1_audio_lim_update_mul_low_high() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function MUST be called at each volume change in */ + /* order to request a limiter partial update. */ + /*-------------------------------------------------------*/ + void l1_audio_lim_partial_update() + { + // Set partial update command + l1a_l1s_com.limiter_task.command.partial_update = TRUE; + // Force L1S execution + l1a_l1s_com.time_to_next_l1s_task = 0; + } + #endif // L1_LIMITER == 1 + + + + #if (L1_AGC_UL == 1) + /*-------------------------------------------------------*/ + /* l1_audio_agc_ul_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the AGC UL 1x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_agc_ul_copy_params() + { + + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_control = l1a_l1s_com.agc_ul_task.parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_frame_size = l1a_l1s_com.agc_ul_task.parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_targeted_level = l1a_l1s_com.agc_ul_task.parameters.targeted_level; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_up = l1a_l1s_com.agc_ul_task.parameters.signal_up; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_down = l1a_l1s_com.agc_ul_task.parameters.signal_down; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_max_scale = l1a_l1s_com.agc_ul_task.parameters.max_scale; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha_fast = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta_fast = l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_intp_flag = l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag; + + } + #endif + + #if (L1_AGC_DL == 1) + /*-------------------------------------------------------*/ + /* l1_audio_agc_dl_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the AGC DL 1x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_agc_dl_copy_params() + { + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_control = l1a_l1s_com.agc_dl_task.parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_frame_size = l1a_l1s_com.agc_dl_task.parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_targeted_level = l1a_l1s_com.agc_dl_task.parameters.targeted_level; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_up = l1a_l1s_com.agc_dl_task.parameters.signal_up; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_down = l1a_l1s_com.agc_dl_task.parameters.signal_down; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_max_scale = l1a_l1s_com.agc_dl_task.parameters.max_scale; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha_fast = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta_fast = l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_intp_flag = l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag; + + } + #endif + + + #if (L1_IIR == 2) + /*-------------------------------------------------------*/ + /* l1_audio_iir4x_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the IIR 4x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_iir4x_copy_params() + { + UWORD8 i; + UWORD8 j; + + // Set IIR parameters + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_control = l1a_l1s_com.iir_task.parameters->parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_frame_size = l1a_l1s_com.iir_task.parameters->parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_swap = l1a_l1s_com.iir_task.parameters->parameters.fir_swap; + + // Set parameter os FIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_enable = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_enable; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_length = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_length; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_shift = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_shift; + + for (i=0; i < (l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_length); i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_fir_taps[i] = l1a_l1s_com.iir_task.parameters->parameters.fir_filter.fir_taps[i]; + } + + // Set parameters for IIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_enable = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_enable; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_number = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_number; + + // Set parameters for IIR part - SOS 1 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_1 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_1 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_1[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_1[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_1 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[0].sos_num_form; + + + // Set parameters for IIR part - SOS 2 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_2 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_2 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_2[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_2[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_2 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[1].sos_num_form; + + + // Set parameters for IIR part - SOS 3 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_3 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_3 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_3[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_3[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_3 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[2].sos_num_form; + + + // Set parameters for IIR part - SOS 4 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_4 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_4 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_4[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_4[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_4 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[3].sos_num_form; + + + // Set parameters for IIR part - SOS 5 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_5 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_5 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_5[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_5[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_5 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[4].sos_num_form; + + + // Set parameters for IIR part - SOS 6 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_6 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_fact; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_6 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_fact_form; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_6[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_den[j]; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_6[j] = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_num[j]; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_6 = l1a_l1s_com.iir_task.parameters->parameters.sos_filter.sos_filter[5].sos_num_form; + + + + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_gain = l1a_l1s_com.iir_task.parameters->parameters.gain; + + } + + #endif // L1_IIR == 2 + + +#if (L1_DRC == 1) + /*-------------------------------------------------------*/ + /* l1_audio_drc1x_copy_params */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : */ + /* ------------- */ + /* This function is used to copy the DRC 1x parameter */ + /* to API memory using a pointer */ + /*-------------------------------------------------------*/ + + void l1_audio_drc1x_copy_params() + { + UWORD8 i; + + // Set DRC parameters + drc_ndb->d_drc_speech_mode_samp_f = l1a_l1s_com.drc_task.parameters->parameters.speech_mode_samp_f; + drc_ndb->d_drc_num_subbands = l1a_l1s_com.drc_task.parameters->parameters.num_subbands; + drc_ndb->d_drc_frame_len = l1a_l1s_com.drc_task.parameters->parameters.frame_len; + drc_ndb->d_drc_expansion_knee_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.expansion_knee_fb_bs; + drc_ndb->d_drc_expansion_knee_md_hg = l1a_l1s_com.drc_task.parameters->parameters.expansion_knee_md_hg; + drc_ndb->d_drc_expansion_ratio_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.expansion_ratio_fb_bs; + drc_ndb->d_drc_expansion_ratio_md_hg = l1a_l1s_com.drc_task.parameters->parameters.expansion_ratio_md_hg; + drc_ndb->d_drc_max_amplification_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.max_amplification_fb_bs; + drc_ndb->d_drc_max_amplification_md_hg = l1a_l1s_com.drc_task.parameters->parameters.max_amplification_md_hg; + drc_ndb->d_drc_compression_knee_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.compression_knee_fb_bs; + drc_ndb->d_drc_compression_knee_md_hg = l1a_l1s_com.drc_task.parameters->parameters.compression_knee_md_hg; + drc_ndb->d_drc_compression_ratio_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.compression_ratio_fb_bs; + drc_ndb->d_drc_compression_ratio_md_hg = l1a_l1s_com.drc_task.parameters->parameters.compression_ratio_md_hg; + drc_ndb->d_drc_energy_limiting_th_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.energy_limiting_th_fb_bs; + drc_ndb->d_drc_energy_limiting_th_md_hg = l1a_l1s_com.drc_task.parameters->parameters.energy_limiting_th_md_hg; + drc_ndb->d_drc_limiter_threshold_fb = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_fb; + drc_ndb->d_drc_limiter_threshold_bs = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_bs; + drc_ndb->d_drc_limiter_threshold_md = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_md; + drc_ndb->d_drc_limiter_threshold_hg = l1a_l1s_com.drc_task.parameters->parameters.limiter_threshold_hg; + drc_ndb->d_drc_limiter_hangover_spect_preserve = l1a_l1s_com.drc_task.parameters->parameters.limiter_hangover_spect_preserve; + drc_ndb->d_drc_limiter_release_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.limiter_release_fb_bs; + drc_ndb->d_drc_limiter_release_md_hg = l1a_l1s_com.drc_task.parameters->parameters.limiter_release_md_hg; + drc_ndb->d_drc_gain_track_fb_bs = l1a_l1s_com.drc_task.parameters->parameters.gain_track_fb_bs; + drc_ndb->d_drc_gain_track_md_hg = l1a_l1s_com.drc_task.parameters->parameters.gain_track_md_hg; + + for (i=0; i < DRC_LPF_LENGTH; i++) + { + drc_ndb->a_drc_low_pass_filter[i] = l1a_l1s_com.drc_task.parameters->parameters.low_pass_filter[i]; + } + for (i=0; i < DRC_BPF_LENGTH; i++) + { + drc_ndb->a_drc_mid_band_filter[i] = l1a_l1s_com.drc_task.parameters->parameters.mid_band_filter[i]; + } + + } + + #endif // L1_DRC == 1 + +#if(L1_BT_AUDIO == 1) +BOOL L1Audio_InformBtAudioPathState (BOOL connected) +{ + if(connected==bt_audio.connected_status) + return BT_STATUS_OK; + else + return BT_STATUS_ERROR; +} + +void L1Audio_RegisterBthal (L1AudioPcmCallback pcmCallback, L1AudioConfigureCallback configCallback) +{ + bt_audio.audio_configure_callback=configCallback; + bt_audio.audio_pcmblock_callback=pcmCallback; +} +UWORD8 bt_flag=1; + + +L1AudioPcmStatus L1Audio_PullPcmBlock (L1AudioPcmBlock *pcmBlock) +{ + UWORD8 status=0; + if(bt_flag == 0) + { + AUDIO_SEND_TRACE("pull back bef init",RV_TRACE_LEVEL_ERROR); + bt_audio.pcm_data_ready = 0; + // return L1_PCM_PENDING; + } +// AUDIO_SEND_TRACE("pull back called",RV_TRACE_LEVEL_ERROR); + + if(bt_audio.pcm_data_end == 1) + { + AUDIO_SEND_TRACE("abnormal BT request mp3/aac",RV_TRACE_LEVEL_ERROR); + + if(bt_audio.pcmblock.lengthInBytes==2*C_MP3_OUTPUT_BUFFER_SIZE) + l1mp3_dma_it_handler(0); + else if(bt_audio.pcmblock.lengthInBytes==2*C_AAC_OUTPUT_BUFFER_SIZE) + l1aac_dma_it_handler(0); + + bt_audio.pcm_data_end = 0; + bt_audio.pcm_data_ready = 0; + bt_flag = 0; + return L1_PCM_MEDIA_ENDED; + } + + + if(bt_audio.pcm_data_failed==0) + { + if(bt_audio.pcm_data_ready>0) + { + //AUDIO_SEND_TRACE("Data ready for BT-Pull event",RV_TRACE_LEVEL_ERROR); + pcmBlock->pcmBuffer= bt_audio.pcmblock.pcmBuffer; + pcmBlock->lengthInBytes=bt_audio.pcmblock.lengthInBytes; + + bt_audio.pcm_data_ready=0; + + if( bt_audio.pcm_data_end==1) + { + AUDIO_SEND_TRACE("Data ended for BT-Pull event",RV_TRACE_LEVEL_ERROR); + return L1_PCM_MEDIA_ENDED; + } + else + if(bt_audio.pcmblock.lengthInBytes==2*AUDIO_EXT_MIDI_BUFFER_SIZE) + return L1_PCM_READY; + else + status= L1_PCM_READY; + } + else + { + if( bt_audio.pcm_data_end==1) + { + AUDIO_SEND_TRACE("Data ended for BT-Pull event",RV_TRACE_LEVEL_ERROR); + return L1_PCM_MEDIA_ENDED; + } + // AUDIO_SEND_TRACE("Data pending for BT-Pull event",RV_TRACE_LEVEL_ERROR); + bt_audio.pcm_data_pending=1; + status= L1_PCM_PENDING; + } + } + else + { + AUDIO_SEND_TRACE("Data failed for BT-Pull event",RV_TRACE_LEVEL_ERROR); + return L1_PCM_FAILED; + } +if((bt_audio.pcmblock.lengthInBytes==2*C_MP3_OUTPUT_BUFFER_SIZE)&& bt_flag==1) +{ + if(l1a_apihisr_com.mp3.command.stop==TRUE) + { + bt_flag=0; + l1mp3_dma_it_handler(0); + bt_audio.pcm_data_end = 0; + return L1_PCM_MEDIA_ENDED; + } + else + l1mp3_dma_it_handler(0); + +} +else if(bt_audio.pcmblock.lengthInBytes==2*C_AAC_OUTPUT_BUFFER_SIZE&& bt_flag==1) +{ + if(l1a_apihisr_com.aac.command.stop==TRUE) + { + bt_flag=0; + AUDIO_SEND_TRACE("Media ended for BT-Pull event",RV_TRACE_LEVEL_ERROR); + l1aac_dma_it_handler(0); + bt_audio.pcm_data_end = 0; + return L1_PCM_MEDIA_ENDED; + } + else + l1aac_dma_it_handler(0); +} +else if(bt_audio.pcmblock.lengthInBytes==2*AUDIO_EXT_MIDI_BUFFER_SIZE && bt_flag==1) + if( bt_audio.pcm_data_end==1) + { + bt_flag=0; + return L1_PCM_MEDIA_ENDED; + } + else + l1a_bt_audio_noti_process(); +return status; + + +} + +void l1_audio_bt_init(UINT16 media_buf_size) +{ + bt_audio.pcm_data_pending =0; + bt_audio.pcm_data_end =0; + bt_audio.pcm_data_ready =1; + bt_audio.pcm_data_failed =0; + + bt_flag=1; + +if(media_buf_size==C_MP3_OUTPUT_BUFFER_SIZE) +{ + bt_audio.pcmblock.pcmBuffer=(UWORD8 *)&mp3_dma->a_mp3_dma_input_buffer[0][0]; + bt_audio.pcmblock.lengthInBytes=2*media_buf_size; +} +else if(media_buf_size==C_AAC_OUTPUT_BUFFER_SIZE) +{ + bt_audio.pcmblock.pcmBuffer=(UWORD8 *)&aac_dma->a_aac_dma_input_buffer[0][0]; + bt_audio.pcmblock.lengthInBytes=2*media_buf_size; +} +else if(media_buf_size==AUDIO_EXT_MIDI_BUFFER_SIZE) +{ + bt_audio.pcmblock.pcmBuffer=(UWORD8 *)&midi_buf.audio_play_buffer[0]; + bt_audio.pcmblock.lengthInBytes=2*media_buf_size; +} +} +#endif//L1_BT_AUDIO == 1 + +#if(L1_BT_AUDIO==1) ||(L1_WCM==1) +void l1_audio_manager(UWORD8 *src, UWORD16 size) +{ + UWORD16 i ; +#if(L1_BT_AUDIO==1) + bt_audio.pcmblock.pcmBuffer=src; + bt_audio.pcmblock.lengthInBytes=2*size; +#endif + + #if (OP_L1_STANDALONE == 0) + #if 0 + // l1_audio_wcm(src,size); + if( wcm_enable == 1) + { + switch(size) + { + case 2048: + + arm_wcm_module( AAC, (T_SINT16 *)src , &wcm_output[0]); + break; + case 1152: + + arm_wcm_module( MP3, (T_SINT16 *)src , &wcm_output[0]); + break; + + + } + + for (i=0 ; i< size ; i++) + while(size>0) + { + *src++=(API)*wcm_output++; + size--; + } + + /* for (i=0 ; i< size ; i++) + { + *src++ = (UINT8 )wcm_output[i]&0x00ff; + *src++ = (UINT8 )(wcm_output[i] & 0xff00) >> 8; + } + */ + + } + + + #endif + #endif + + #if(L1_BT_AUDIO==1) + if(bt_audio.connected_status==TRUE) + { + if(bt_audio.pcm_data_pending>0) + { + bt_audio.pcm_data_pending = 0; + AUDIO_SEND_TRACE("Pending callback",RV_TRACE_LEVEL_ERROR); + bt_audio.audio_pcmblock_callback(&bt_audio.pcmblock); + + } + else + bt_audio.pcm_data_ready = 1; + } + #endif +} +#endif + +UWORD16 l1_ext_audio_get_frequencyrate(UWORD16 frequency_index) +{ + UWORD16 sampling_frequency=0; + + switch(frequency_index) + { + case 1: + sampling_frequency=8000; + break; + case 2: + sampling_frequency=11025; + break; + case 3: + sampling_frequency=16000; + break; + case 4: + sampling_frequency=22050; + break; + case 5: + sampling_frequency=32000; + break; + case 6: + sampling_frequency=44100; + break; + case 7: + sampling_frequency=48000; + break; + } + + // Sampling frequency should never be zero + return sampling_frequency; +} +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_init.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,707 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_INIT.C + * + * Filename l1audio_init.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#include "l1_macro.h" +#include "l1_confg.h" + + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + #include "l1_time.h" + #include "l1_scen.h" + #else // NOT SIMULATION + + // Layer1 and debug include files. + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added here from e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + #include "l1_time.h" + + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif // NOT_SIMULATION + +#if (L1_DRC == 1) + extern T_DRC_MCU_DSP *drc_ndb; + #if (CODE_VERSION == SIMULATION) + extern T_DRC_MCU_DSP drc_ndb_sim; + #endif +#endif +#if(L1_BT_AUDIO ==1) +extern T_L1_BT_AUDIO bt_audio; +#endif + /**************************************/ + /* Prototypes for L1 initialization */ + /**************************************/ + void l1audio_dsp_init (void); + void l1audio_initialize_var (void); + + /**************************************/ + /* External prototypes */ + /**************************************/ + + /*-------------------------------------------------------*/ + /* l1audio_dsp_init() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Initialize the part of the API */ + /* dedicated to the audio task. */ + /* */ + /*-------------------------------------------------------*/ + void l1audio_dsp_init(void) + { + UWORD8 i, j; + + #if (KEYBEEP) + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt0 = 0; // keybeep variable + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt1 = 0; // keybeep variable + l1s_dsp_com.dsp_ndb_ptr->d_dur_kb = 0; // keybeep variable + #endif + + #if ((TONE) || (VOICE_MEMO)) + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_pe_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_se_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_bu_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t0_on = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t0_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t1_on = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t1_off = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t2_on = 0; // tone variable + l1s_dsp_com.dsp_ndb_ptr->d_t2_off = 0; // tone variable + + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = 0x100; + l1s_dsp_com.dsp_ndb_ptr->d_shiftdl = 0x100; + #endif // (TONE) || (VOICE_MEMO) + #if (L1_PCM_EXTRACTION) + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = 0; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = 0; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_error = 0; + #endif + + // Correction of PR G23M/L1_MCU-SPR-15494 + #if ((CHIPSET == 12) || (CHIPSET == 15)) + #if (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tdat = 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tvs = 0; + #endif + #endif + + #if (L1_VOICE_MEMO_AMR) + l1s_dsp_com.dsp_ndb_ptr->d_shiftul = 0x100; + #endif // L1_VOICE_MEMO_AMR + + #if (MELODY_E1) + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used = 0; + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active = 0; + + l1s_dsp_com.dsp_ndb_ptr->a_melo_note0[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note1[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note2[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note3[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note4[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note5[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note6[0] = SC_END_OSCILLATOR_MASK; + l1s_dsp_com.dsp_ndb_ptr->a_melo_note7[0] = SC_END_OSCILLATOR_MASK; + #endif // MELODY_E1 + + // Initialize the FIR as an all band pass + // IMPORTANT NOTE: FIR/DL parameters are also initialized for DSP 36 when L1_IIR == 1 because + // in FIR loop mode, the old FIR API is still used + #if (DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)// The FIR coefficents are in param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_downlink[0] = 0x4000; + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[0] = 0x4000; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_downlink[0] = 0x4000; + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[0] = 0x4000; + #endif + + for (i=1; i<MAX_FIR_COEF; i++) + { + #if (DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)// The FIR coefficents are in param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_downlink[i] = 0; + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[i] = 0; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_downlink[i] = 0; + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[i] = 0; + #endif + } + #if (DSP == 17) || (DSP == 32) + // start the FIR task + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_FIR_START; + #endif + + #if (L1_IIR == 1) + // IIR enabled by default + // Set the default configuration (all band pass - FIR only mode) + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_iir_blocks = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_fir_coefs = 0x1f; + + l1s_dsp_com.dsp_ndb_ptr->a_iir_fir_coefs[0] = 0x4000; + for (i=1; i < (l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_fir_coefs - 1); i++) + l1s_dsp_com.dsp_ndb_ptr->a_iir_fir_coefs[i] = 0; + + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_fir_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_gain_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain_scaling = 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain = 0xffff; + l1s_dsp_com.dsp_ndb_ptr->d_iir_feedback = 0; + #endif + + #if (AUDIO_MODE) + // Reset the FIR loopback and the audio mode + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_LOOP | B_GSM_ONLY | B_BT_HEADSET | B_BT_CORDLESS); + // Set the GSM mode + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_GSM_ONLY; + #else + // Reset the loopback + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_LOOP); + #endif + + #if (W_A_DSP_SR_BGD) + // Initialize the DSP speech reco background task + + // DSP background enabled for SR. + l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt = (B_DSPBGD_RECO | B_DSPBGD_UPD); + l1s_dsp_com.dsp_ndb_ptr->d_max_background = 7; + + // TEMPORARY: Init DSP background interface for RECO. + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_RECO) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_RECOGN); + l1s_dsp_com.dsp_ndb_ptr->d_background_abort &= ~(1 << C_BGD_RECOGN); + l1s_dsp_com.dsp_ndb_ptr->a_background_tasks[C_BGD_RECOGN] = (C_BGD_RECOGN<<11) | 1; + l1s_dsp_com.dsp_ndb_ptr->a_back_task_io[C_BGD_RECOGN] = (API)(0x0000); // Not used by Recognition task. + } + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_UPD) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_ALIGN); + l1s_dsp_com.dsp_ndb_ptr->d_background_abort &= ~(1 << C_BGD_ALIGN); + l1s_dsp_com.dsp_ndb_ptr->a_background_tasks[C_BGD_ALIGN] = (C_BGD_ALIGN<<11) | 1; + l1s_dsp_com.dsp_ndb_ptr->a_back_task_io[C_BGD_ALIGN] = (API)(0x0000); // Not used by Alignement task. + } + #elif (DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + // DSP background task through pending task queue + l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt = 0; + #endif + + #if (MELODY_E2) + // Initalize the Audio compressor used for E2 + l1s_dsp_com.dsp_ndb_ptr->d_audio_compressor_ctrl = 0x0401; + + // Initialize the melody E2 variables + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_stop = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_active = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore = 0x0000; + for(i=0; i<SC_MELODY_E2_NUMBER_OF_OSCILLATOR; i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[i][0] = 0x0000; + } + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = 0x0000; + + for (i=0; i<(SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT); i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[i] = 0x0000; + } + + // Reset the flag to know if the DSP melody E2 task runs + l1s.melody_e2.dsp_task = FALSE; + #endif // MELODY_E2 + + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + + //----------------------------------- + // AUDIO control words initialization + //----------------------------------- + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init = 0; // MCU/DSP audio task com. register + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status = 0; // MCU/DSP audio task com. register + + + #if ((CHIPSET == 4) || (CHIPSET == 12) || (CHIPSET == 15) || ((CHIPSET==10) && (OP_WCP==1))) && ((DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = 0; // ES control + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = 0; // ANR control + #if (L1_IIR == 1) + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; // IIR control: enabled by default + #else + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = 0; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = 0; // Limiter control + + #endif + + + +#if (DSP == 38) || (DSP == 39) + + //----------------------------------- + // AUDIO control words initialization + //----------------------------------- + + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = 0; // ES control + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = 0; // ANR control + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = 0; // AEC control + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = 0; // AGC control + + #if (L1_IIR == 1) + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; // IIR control: enabled by default + #else + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = 0; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = 0; // Limiter control + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = 0; // DRC control + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = 0; // AGC control + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = 0; // WCM control + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_status = 0; // WCM status + l1s_dsp_com.dsp_ndb_ptr->d_aqi_status = 0; // Initialise the status word + +#if(L1_ANR == 2) + l1s_dsp_com.dsp_ndb_ptr->d_anr_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_anr_ns_level = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_ene_th = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_cnt_th = (API) 0; +#endif + + +#if(L1_IIR == 2) + // Set IIR parameters + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_swap = (API) 0; + + // Set parameter os FIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_enable = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_length = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_fir_shift = (API) 0; + + for (i=0; i < IIR_4X_FIR_MAX_LENGTH; i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_fir_taps[i] = (API) 0; + } + + // Set parameters for IIR part + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_enable = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_number = (API) 0; + + // Set parameters for IIR part - SOS 1 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_1 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_1 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_1[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_1[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_1 = (API) 0; + + + // Set parameters for IIR part - SOS 2 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_2 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_2 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_2[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_2[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_2 = (API) 0; + + + // Set parameters for IIR part - SOS 3 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_3 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_3 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_3[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_3[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_3 = (API) 0; + + + // Set parameters for IIR part - SOS 4 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_4 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_4 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_4[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_4[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_4 = (API) 0; + + + // Set parameters for IIR part - SOS 5 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_5 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_5 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_5[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_5[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_5 = (API) 0; + + + // Set parameters for IIR part - SOS 6 + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_6 = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_fact_form_6 = (API) 0; + + for (j=0; j < IIR_4X_ORDER_OF_SECTION; j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_den_6[j] = (API) 0; + } + for (j=0; j < (IIR_4X_ORDER_OF_SECTION + 1); j++) + { + l1s_dsp_com.dsp_ndb_ptr->a_iir4x_sos_num_6[j] = (API) 0; + } + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_sos_num_form_6 = (API) 0; + + + + l1s_dsp_com.dsp_ndb_ptr->d_iir4x_gain = (API) 0; + +#endif + +#if(L1_AGC_UL == 1) + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_targeted_level = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_up = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_signal_down = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_max_scale = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_alpha_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_smooth_beta_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_gain_intp_flag = (API) 0; +#endif + +#if(L1_AGC_DL == 1) + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_control = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_targeted_level = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_up = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_signal_down = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_max_scale = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_alpha_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_smooth_beta_fast = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_gain_intp_flag = (API) 0; +#endif + +#if(L1_WCM == 1) + + l1s_dsp_com.dsp_ndb_ptr->d_wcm_mode = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_frame_size = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_num_sub_frames = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_ratio = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_threshold = (API) 0; +#endif + +#endif // DSP 38 + +} + + +#if (AUDIO_TASK == 1) + + /*-------------------------------------------------------*/ + /* l1audio_initialize_var() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Initialize the part of l1a, l1s and */ + /* l1a_l1s_com dedicated to the audio task.*/ + /* */ + /*-------------------------------------------------------*/ + void l1audio_initialize_var(void) + { + UWORD8 i, j; + + // Initialize the state of the L1S maanger... + //-------------------------------------------- + for(i=0; i<NBR_AUDIO_MANAGER; i++) + { + l1s.audio_state[i] = 0; + } + + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + l1a_l1s_com.audio_onoff_task.parameters.onoff_value = FALSE; + #endif + l1a_l1s_com.audio_forced_by_l1s = FALSE; + + #if (MELODY_E1) + l1s.melody0.oscillator[0] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note0[0]); + l1s.melody0.oscillator[1] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note1[0]); + l1s.melody0.oscillator[2] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note2[0]); + l1s.melody0.oscillator[3] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note3[0]); + l1s.melody0.oscillator[4] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note4[0]); + l1s.melody0.oscillator[5] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note5[0]); + l1s.melody0.oscillator[6] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note6[0]); + l1s.melody0.oscillator[7] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note7[0]); + + l1s.melody1.oscillator[0] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note0[0]); + l1s.melody1.oscillator[1] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note1[0]); + l1s.melody1.oscillator[2] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note2[0]); + l1s.melody1.oscillator[3] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note3[0]); + l1s.melody1.oscillator[4] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note4[0]); + l1s.melody1.oscillator[5] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note5[0]); + l1s.melody1.oscillator[6] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note6[0]); + l1s.melody1.oscillator[7] = &(l1s_dsp_com.dsp_ndb_ptr->a_melo_note7[0]); + #endif // MELODY_E1 + + #if (MELODY_E2) + // Initialization ofthe audio background melody E2 load insturment variable + audioback_melody_e2.allowed_size = + SC_AUDIO_MELODY_E2_MAX_SIZE_OF_INSTRUMENT; + audioback_melody_e2.API_address = + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_wave; + + for (i=0; i < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT; i++) + { + audioback_melody_e2.number_of_user[i] = 0; + } + #endif // MELODY_E2 + + #if (L1_STEREOPATH == 1) + // Reset the stereopath L1S commands + l1a_l1s_com.stereopath_drv_task.command.start = FALSE; + l1a_l1s_com.stereopath_drv_task.command.stop = FALSE; + #endif + +// Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request = 0; + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request = 0; + + l1s.audio_on_off_ctl.l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + l1s.audio_on_off_ctl.l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + + l1s.audio_on_off_ctl.l1_audio_ul_action = L1_AUDIO_NO_ACTION; + l1s.audio_on_off_ctl.l1_audio_dl_action = L1_AUDIO_NO_ACTION; + + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = FALSE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_on = FALSE; + + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; +#endif // L1_AUDIO_MCU_ONOFF + + +#if (L1_DRC == 1) + + // init DRC NDB + drc_ndb = (T_DRC_MCU_DSP *)API_address_dsp2mcu(C_DRC_API_BASE_ADDRESS); + #if (CODE_VERSION == SIMULATION) + { + drc_ndb = &drc_ndb_sim; + } + #endif + + drc_ndb->d_drc_speech_mode_samp_f =(API)0; + drc_ndb->d_drc_num_subbands =(API)0; + drc_ndb->d_drc_frame_len =(API)0; + drc_ndb->d_drc_expansion_knee_fb_bs =(API)0; + drc_ndb->d_drc_expansion_knee_md_hg =(API)0; + drc_ndb->d_drc_expansion_ratio_fb_bs =(API)0; + drc_ndb->d_drc_expansion_ratio_md_hg =(API)0; + drc_ndb->d_drc_max_amplification_fb_bs =(API)0; + drc_ndb->d_drc_max_amplification_md_hg =(API)0; + drc_ndb->d_drc_compression_knee_fb_bs =(API)0; + drc_ndb->d_drc_compression_knee_md_hg =(API)0; + drc_ndb->d_drc_compression_ratio_fb_bs =(API)0; + drc_ndb->d_drc_compression_ratio_md_hg =(API)0; + drc_ndb->d_drc_energy_limiting_th_fb_bs =(API)0; + drc_ndb->d_drc_energy_limiting_th_md_hg =(API)0; + drc_ndb->d_drc_limiter_threshold_fb =(API)0; + drc_ndb->d_drc_limiter_threshold_bs =(API)0; + drc_ndb->d_drc_limiter_threshold_md =(API)0; + drc_ndb->d_drc_limiter_threshold_hg =(API)0; + drc_ndb->d_drc_limiter_hangover_spect_preserve =(API)0; + drc_ndb->d_drc_limiter_release_fb_bs =(API)0; + drc_ndb->d_drc_limiter_release_md_hg =(API)0; + drc_ndb->d_drc_gain_track_fb_bs =(API)0; + drc_ndb->d_drc_gain_track_md_hg =(API)0; + for (j=0; j < DRC_LPF_LENGTH; j++) + { + drc_ndb->a_drc_low_pass_filter[j] = (API)0; + } + for (j=0; j < DRC_BPF_LENGTH; j++) + { + drc_ndb->a_drc_mid_band_filter[j] = (API)0; + } +#endif + + l1a_l1s_com.outen_cfg_task.outen1 = + l1a_l1s_com.outen_cfg_task.outen2 = + l1a_l1s_com.outen_cfg_task.outen3 = + l1a_l1s_com.outen_cfg_task.command_requested = + l1a_l1s_com.outen_cfg_task.command_commited = 0; + //voice and stereo path configuration for L1 standalone mode CQ- OMAPS00088143 +#if (OP_L1_STANDALONE == 1) +// Voice path and Stereo path +l1a_l1s_com.outen_cfg_task.outen3 = 0; +l1a_l1s_com.outen_cfg_task.outen2 = 0x03; +l1a_l1s_com.outen_cfg_task.outen1 = 0; +#endif +#if(L1_BT_AUDIO ==1) +bt_audio.pcm_data_pending = 0; +bt_audio.pcm_data_end = 0; +bt_audio.pcm_data_ready = 0; +bt_audio.pcm_data_failed = 0; +bt_audio.connected_status = FALSE; +#endif +} + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_stereo.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,685 @@ +/* + * l1audio_stereo.c + * + * Control audio + * + * Filename l1audio_stereo.c + * Copyright 2003 (C) Texas Instruments + * + * + */ + +#include "l1_macro.h" +#include "l1_confg.h" + +#define _L1AUDIO_STEREO_C_ + +#if (AUDIO_TASK == 1) + +#include "l1_types.h" +#include "sys_types.h" + +#if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + +#include <stdlib.h> +#include <string.h> + +#include "iq.h" // Debug / Init hardware ("eva3.lib") +#include "l1_ver.h" +#include "l1_const.h" +#include "l1_signa.h" + +#if TESTMODE +#include "l1tm_defty.h" +#endif + +#include "l1audio_const.h" +#include "l1audio_cust.h" +#include "l1audio_signa.h" +#include "l1audio_defty.h" +#include "l1audio_msgty.h" + +#if (L1_GTT == 1) +#include "l1gtt_const.h" +#include "l1gtt_defty.h" +#endif +//added here from e-sample for AAC +#if (L1_DYN_DSP_DWNLD == 1) +#include "l1_dyn_dwl_const.h" +#include "l1_dyn_dwl_defty.h" +#endif +#if (L1_MP3 == 1) +#include "l1mp3_defty.h" +#endif + +#if (L1_MIDI == 1) +#include "l1midi_defty.h" +#endif +//added here from e-sample for AAC +#if (L1_AAC == 1) +#include "l1aac_defty.h" +#endif + +#include "l1_defty.h" +#include "cust_os.h" +#include "l1_msgty.h" +#include "l1_varex.h" + +#include "l1_mftab.h" +#include "l1_tabs.h" +#include "l1_ctl.h" + +#include "l1_time.h" +#include "l1_scen.h" + +#if (L1_STEREOPATH == 1) +#include "sys_dma.h" +#include "sys_inth.h" +#include "abb.h" +#if TESTMODE +#include "l1tm_msgty.h" +#endif +#include "l1audio_stereo.h" +#endif + +#else +// Layer1 and debug include files. + +#include <ctype.h> +#include <math.h> +#include "l1_ver.h" +#include "l1_const.h" +#include "l1_signa.h" + +#if TESTMODE +#include "l1tm_defty.h" +#endif + +#include "l1audio_const.h" +#include "l1audio_cust.h" +#include "l1audio_signa.h" +#include "l1audio_defty.h" +#include "l1audio_msgty.h" + +#if (L1_GTT == 1) +#include "l1gtt_const.h" +#include "l1gtt_defty.h" +#endif +//added here from e-sample for AAC +#if (L1_DYN_DSP_DWNLD == 1) +#include "l1_dyn_dwl_const.h" +#include "l1_dyn_dwl_defty.h" +#endif +#if (L1_MP3 == 1) +#include "l1mp3_defty.h" +#endif + +#if (L1_MIDI == 1) +#include "l1midi_defty.h" +#endif +//added here from e-sample for AAC +#if (L1_AAC == 1) +#include "l1aac_defty.h" +#endif +#include "l1_defty.h" +#include "cust_os.h" +#include "l1_msgty.h" +#include "tpudrv.h" // TPU drivers. ("eva3.lib") +#include "l1_varex.h" + +#include "l1_proto.h" +#include "l1_mftab.h" +#include "l1_tabs.h" +#include "mem.h" +#include "armio.h" +#include "timer.h" +#include "timer1.h" +#include "dma.h" +#include "inth.h" +#include "ulpd.h" +#include "rhea_arm.h" +#include "clkm.h" // Clockm ("eva3.lib") +#include "l1_ctl.h" + +#include "l1_time.h" +#if L2_L3_SIMUL +#include "l1_scen.h" +#endif + +#if (L1_STEREOPATH == 1) +#include "sys_dma.h" +#include "sys_inth.h" +#include "abb.h" +#if TESTMODE +#include "l1tm_msgty.h" +#endif +#include "l1audio_stereo.h" +#endif + +#include "l1audio_abb.h" +#endif + +#include "l1audio_macro.h" + +//add the extern reference of abb_write_done +#if (ANLG_FAM == 11) +#include "bspTwl3029_I2c.h" +#include "bspTwl3029_Aud_Map.h" +#endif + +#if (ANLG_FAM == 11) +Bsp_Twl3029_I2cTransReqArray l1audio_i2cTransArray; +#endif + +#if (L1_STEREOPATH == 1) && (CODE_VERSION == NOT_SIMULATION) + +#if (ANLG_FAM == 11) + #include "bspTwl3029_Int_Map.h" + + +//Add the call back function of the stereo path. +void l1s_stereopath_callback(UWORD8 cbvalue) +{ + BspTwl3029_ReturnCode returnVal = BSP_TWL3029_RETURN_CODE_FAILURE; + UWORD16 count = 0; + UINT8 triton_classD = 0; + + /* callback function info pointer */ + BspTwl3029_I2C_Callback i2c_callback; + BspTwl3029_I2C_CallbackPtr callbackPtr= &i2c_callback; + + /* I2C array */ + Bsp_Twl3029_I2cTransReqArray i2cTransArray; + Bsp_Twl3029_I2cTransReqArrayPtr i2cTransArrayPtr= &i2cTransArray; + + /* twl3029 I2C reg info struct */ + BspTwl3029_I2C_RegisterInfo regInfo[10] ; + BspTwl3029_I2C_RegisterInfo* regInfoPtr = regInfo; + + BspTwl3029_I2C_RegData tmpAudioHFTest1RegData=0; + BspTwl3029_I2C_RegData tmpCtrl3RegData=0; + + bspTwl3029_Audio_getClassD_mode(&triton_classD); + + //Set the valud of abb_write_done to 1 + l1s.abb_write_done = 1; + switch(cbvalue) + { + case L1S_TWL3029_STEROPATH_START: + { + l1a_l1s_com.outen_cfg_task.command_commited = l1a_l1s_com.outen_cfg_task.command_requested; + + returnVal = BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + &tmpCtrl3RegData); + returnVal = BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + &tmpAudioHFTest1RegData); + + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN1_OFFSET, + l1a_l1s_com.outen_cfg_task.outen1, regInfoPtr++); + count++; + + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET, + l1a_l1s_com.outen_cfg_task.outen2, regInfoPtr++); + count++; + + if(l1a_l1s_com.outen_cfg_task.classD == 0x01) // User wants to configure classD + { + if(triton_classD == 0x00) // User wants to switch on and Triton not configured for classD + { + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_CKG_TESTUNLOCK_OFFSET, + 0xb6, regInfoPtr++); + count++; + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + + tmpCtrl3RegData |= 0x80; // AUDIO_CTRL3_SPKDIGON + tmpAudioHFTest1RegData = 0x01; // AUDIO_HFTEST1_SPKALLZB + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + tmpCtrl3RegData, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + tmpAudioHFTest1RegData, regInfoPtr++); + count++; + } + } + else if(l1a_l1s_com.outen_cfg_task.classD == 0x00) + { + if(triton_classD != 0x00) // User wants no to classD and Triton configured for classD + { + tmpCtrl3RegData &= 0x7F; // AUDIO_CTRL3_SPKDIGON + tmpAudioHFTest1RegData = 0x00; // AUDIO_HFTEST1_SPKALLZB + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + tmpAudioHFTest1RegData, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + tmpCtrl3RegData, regInfoPtr++); + count++; + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_CKG_TESTUNLOCK_OFFSET, + 0x00, regInfoPtr++); + count++; + } + else // User no classD & Triton also no classD + { + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET, + l1a_l1s_com.outen_cfg_task.outen2, regInfoPtr++); + count++; + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + } + } + /*Switch OFF all pop modes unconditionally , it is turned on before turning on STON*/ + returnVal=BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_POPMAN_OFFSET, 0x00,regInfoPtr++); + count++; + + callbackPtr->callbackFunc = l1s_stereopath_callback; + callbackPtr->callbackVal = L1S_TWL3029_STEROPATH_OUTEN_CONFIG; + + if (returnVal != BSP_TWL3029_RETURN_CODE_FAILURE) + { + regInfoPtr = regInfo; + /* now request to I2C manager to write to Triton registers */ + + returnVal = BspTwl3029_I2c_regInfoSend(regInfo,count,callbackPtr, + (BspI2c_TransactionRequest*)i2cTransArrayPtr); + } + break; + } + case L1S_TWL3029_STEROPATH_CONFIG: + case L1S_TWL3029_STEROPATH_OUTEN_CONFIG: + case L1S_TWL3029_STEROPATH_STOP: + break; + default: + break; + }/* end switch */ +} /* end function l1s_stereopath_callback */ + +#endif + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_config_ABB() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : mono_stereo: indicates if buffer is made */ +/* of mono or stereo samples */ +/* sampling_frequency: sampling freq */ +/* */ +/* Return : none */ +/* */ +/* Description : ABB configuration function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_config_ABB(UWORD8 mono_stereo,UWORD8 sampling_frequency) +{ +#if (ANLG_FAM == 3) + UWORD16 regist; + + // Get the VAUDCTRL register + regist = l1s_dsp_com.dsp_ndb_ptr->d_vaud_cfg >> 6; + + // reset sampling frequency and stereo/mono conversion + regist &= 0x319; + + // stereo/mono conversion ? + if (mono_stereo == AUDIO_SP_MONO_OUTPUT) + regist |= 6; + + // apply the request sampling frequency + regist |= (sampling_frequency << 5); + + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_vaud_cfg = ABB_L1_WRITE(VAUDCTRL, regist); + + // Get the VBCTRL2 register + regist = l1s_dsp_com.dsp_ndb_ptr->d_vbctrl2 >> 6; + // activate HSOVMID and VMIDFBYP + regist |= 0x90; + l1s_dsp_com.dsp_ndb_ptr->d_vbctrl2 = ABB_L1_WRITE(VBCTRL2, regist); + + // Get the VAUDPLL register + regist = l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll >> 6; + // reset PLL + regist &= 0x3fd; + // switch PLL on + regist |= 0x2; + + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll = ABB_L1_WRITE(VAUDPLL, regist); + + // Get the VBPOP register + regist = l1s_dsp_com.dsp_ndb_ptr->d_vbpop >> 6; + // deactivate vbpop for HSO + regist &= 0x3F8; + + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_vbpop = ABB_L1_WRITE(VBPOP, regist); + +#endif + +#if (ANLG_FAM == 11) + // Call to the Triton API which would configure the Audio path. + UWORD8 monostereo; + UWORD8 pll; + //Call back function + BspTwl3029_I2C_Callback stereo_callbackFunc; + + //Switch on the Stereo path PLL - Set the STPLLON to 1 + pll = 0x02; + //Check if stereo2mono is required + if (mono_stereo == AUDIO_SP_MONO_OUTPUT) + monostereo = 0x03; + else + monostereo = 0x00; + + //Set the call back function to be called after the Audio configuration + stereo_callbackFunc.callbackFunc = l1s_stereopath_callback ; + //stereo_callbackFunc.callbackVal = L1S_TWL3029_STEROPATH_CONFIG; + stereo_callbackFunc.callbackVal = L1S_TWL3029_STEROPATH_START; + stereo_callbackFunc.i2cTransArrayPtr = &l1audio_i2cTransArray; + + //Call the Triton audio path configuration function + if(BSP_TWL3029_RETURN_CODE_SUCCESS == bspTwl3029_Audio_Configure_Stereopath(&stereo_callbackFunc, + pll, + monostereo, + sampling_frequency )) + { + //Set the valud of abb_write_done to 1 + l1s.abb_write_done = 1; + } + +#endif +} + + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_start_ABB() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : none */ +/* */ +/* Return : none */ +/* */ +/* Description : ABB start function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_start_ABB(void) +{ +#if (ANLG_FAM == 3) + // Get VAUDPLL register + UWORD16 regist = l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll >> 6; + + // Reset I2S + regist &= 0x2ff; + // I2S on + regist |= 0x100; + + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll = ABB_L1_WRITE(VAUDPLL, regist); + + // Set AUDON bit of the PWRDNRG register + regist = 0x100; + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_togbr2 = ABB_L1_WRITE(TOGBR2, regist); +#endif +#if (ANLG_FAM == 11) + //Call back function + BspTwl3029_I2C_Callback stereo_callbackFunc; + //Set the call back function to be called after the Audio start + stereo_callbackFunc.callbackFunc = l1s_stereopath_callback ; + stereo_callbackFunc.callbackVal = L1S_TWL3029_STEROPATH_CONFIG; + stereo_callbackFunc.i2cTransArrayPtr = &l1audio_i2cTransArray; + + //call the Triton audio path start function + if (BSP_TWL3029_RETURN_CODE_SUCCESS == bspTwl3029_Audio_Start_Stereopath(&stereo_callbackFunc)) + { + l1s.abb_write_done = 1; + }; +#endif + +} + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_stop_ABB() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : none */ +/* */ +/* Return : none */ +/* */ +/* Description : ABB stop function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_stop_ABB(void) +{ +#if (ANLG_FAM == 3) + UWORD16 regist; + + // Reset AUDON bit of the PWRDNRG register + regist = 0x80; + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_togbr2 = ABB_L1_WRITE(TOGBR2, regist); + + // Get VAUDPLL register + regist = l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll >> 6; + // PLL/I2S off + regist &= 0x2fd; + ABB_Write_Register_on_page(PAGE1, VAUDPLL, regist); + // update DSP API + l1s_dsp_com.dsp_ndb_ptr->d_vaud_pll = ABB_L1_WRITE(VAUDPLL, regist); +#endif +#if (ANLG_FAM == 11) + //Call back function + BspTwl3029_I2C_Callback stereo_callbackFunc; + + UWORD8 dl_control = 1; // OUTEN_DISABLE + + // Set the call back function to be called after the Audio start + stereo_callbackFunc.callbackFunc = l1s_stereopath_callback ; + stereo_callbackFunc.callbackVal = L1S_TWL3029_STEROPATH_STOP; + stereo_callbackFunc.i2cTransArrayPtr = &l1audio_i2cTransArray; + + if( (l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON) || + (l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_SWITCHON_STARTED)) + { + dl_control = 0; // OUTEN_ENABLE + } + + //call the Triton audio path start function + if (BSP_TWL3029_RETURN_CODE_SUCCESS == bspTwl3029_Audio_Stop_Stereopath(&stereo_callbackFunc, dl_control)) + { + l1s.abb_write_done = 1; + }; +#endif +} + + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_start_DMA() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : d_dma_channel_parameter: DMA parameters */ +/* DMA_allocation: allocation of the DMA */ +/* (MCU/DSP) */ +/* */ +/* Return : none */ +/* */ +/* Description : DMA config and start function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_start_DMA(T_DMA_TYPE_CHANNEL_PARAMETER d_dma_channel_parameter,UWORD8 DMA_allocation) +{ +#if ((CHIPSET == 12) || (CHIPSET == 15)) +#if (L1_MP3_SIX_BUFFER == 1) + // allocate the DMA to the MCU + f_dma_channel_allocation_set(d_dma_channel_parameter.d_dma_channel_number, C_DMA_CHANNEL_ARM); + + // set parameters + f_dma_channel_parameter_set((T_DMA_TYPE_CHANNEL_PARAMETER *)&d_dma_channel_parameter); +#else + // set parameters + f_dma_channel_parameter_set((T_DMA_TYPE_CHANNEL_PARAMETER *)&d_dma_channel_parameter); + + // allocate the DMA to the MCU + f_dma_channel_allocation_set(d_dma_channel_parameter.d_dma_channel_number, C_DMA_CHANNEL_ARM); + +#endif + // Enable the DMA channel + f_dma_channel_enable(d_dma_channel_parameter.d_dma_channel_number); + + + // DMA allocation ? + if (DMA_allocation == AUDIO_SP_DMA_ALLOC_MCU) + { + // DMA is allocate to MCU, just unmask DMA IT + F_INTH_ENABLE_ONE_IT(C_INTH_DMA_IT); + } + else + { + // DMA is allocate to DSP, unmask API IT + F_INTH_ENABLE_ONE_IT(C_INTH_API_IT); + + // Re-allocate DMA to the DSP + f_dma_channel_allocation_set(d_dma_channel_parameter.d_dma_channel_number, C_DMA_CHANNEL_DSP); + } +#endif +} + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_reset_DMA() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : d_dma_channel_parameter: DMA parameters */ +/* */ +/* Return : none */ +/* */ +/* Description : DMA reset function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_reset_DMA(T_DMA_TYPE_CHANNEL_PARAMETER d_dma_channel_parameter) +{ +#if ((CHIPSET == 12) || (CHIPSET == 15)) + // Allocate DMA to MCU + f_dma_channel_allocation_set(d_dma_channel_parameter.d_dma_channel_number, C_DMA_CHANNEL_ARM); + + // Disable DMA channel + f_dma_channel_disable(d_dma_channel_parameter.d_dma_channel_number); + + // Reset DMA channel + f_dma_channel_soft_reset(d_dma_channel_parameter.d_dma_channel_number); +#endif +} + + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_reset_CPORT() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : none */ +/* */ +/* Return : none */ +/* */ +/* Description : Cport reset function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_reset_CPORT(void) +{ +#if ((CHIPSET == 12) || (CHIPSET == 15)) + // init = 1 --> write ctrl register + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = (API) 0x0001; + // set SW_RESET field to 1 to generate a software reset + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = (API) 0x0FFD; +#endif +} + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_stop_CPORT() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : none */ +/* */ +/* Return : none */ +/* */ +/* Description : Cport stop function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_stop_CPORT(void) +{ +#if (CHIPSET == 12) || (CHIPSET == 15) + // init = 1 --> write ctrl register + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = (API) 0x0001; + // Set EXT_MCLK_EN field to 1 to enable external clock + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = (API) 0x0000; +#endif +} + + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_config_CPORT() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : none */ +/* */ +/* Return : none */ +/* */ +/* Description : Cport config function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_config_CPORT(void) +{ +#if (CHIPSET == 12) || (CHIPSET == 15) + // init = 0x281F --> write cfr1,2,3,4 and ctrl register + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = (API) 0x281F; + // 2 timeslots per frame, I2S mode + // 20 CLK_BIT cycles, 16 data bits per time slot + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = (API) 0x0C0B; + // one cycle delay, enable data serial output + // CSYNC signal generate with the negative edge of CSCLK + // clk direction set to input + // l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = (API) 0xEB00; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = (API) 0xFB00; // L1_DSP-SPR-18866 + // mask receive/transmit interrupt request + // Set threshold to 2 (nb of elements = 2) + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = (API) 0x012C; +#endif +} + + +/*-------------------------------------------------------*/ +/* l1s_stereopath_drv_start_CPORT() */ +/*-------------------------------------------------------*/ +/* */ +/* Parameters : none */ +/* */ +/* Return : none */ +/* */ +/* Description : Cport start function */ +/* */ +/*-------------------------------------------------------*/ +void l1s_stereopath_drv_start_CPORT(void) +{ +#if (CHIPSET == 12) || (CHIPSET == 15) + // init = 0x20 --> write tcl_tadt register + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = (API) 0x0020; + // CPEN = 1 --> cport enable + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = (API) 0x0800; +#endif +} + +#endif // L1_STEREOPATH && CODE_VERSION + +#endif // AUDIO_TASK
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/L1/audio_cfile/l1audio_sync.c Fri Aug 29 03:25:51 2014 +0000 @@ -0,0 +1,8085 @@ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_SYNC.C + * + * Filename l1audio_sync.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + #include <stdlib.h> + #include <string.h> + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_const.h" + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_const.h" + #include "l1midi_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_const.h" + #include "l1aac_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + #include "l1_time.h" + #include "l1_scen.h" + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "abb.h" + #if TESTMODE + #include "l1tm_msgty.h" + #endif + #include "l1audio_stereo.h" + #endif + + #include "mem.h" + + #else + // Layer1 and debug include files. + + #include <ctype.h> + #include <math.h> + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + + #if (L1_MP3 == 1) + #include "l1mp3_const.h" + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_const.h" + #include "l1midi_defty.h" + #endif + + #if (L1_AAC == 1) + #include "l1aac_const.h" + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + + #if (L1_STEREOPATH == 1) + #include "sys_dma.h" + #include "abb.h" + #if TESTMODE + #include "l1tm_msgty.h" + #endif + #include "l1audio_stereo.h" + #endif + + #include "mem.h" + + #endif + + #include "l1audio_macro.h" + #include "l1_trace.h" + #if (CODE_VERSION != SIMULATION) + #include "bspTwl3029.h" + #include "bspTwl3029_I2c.h" + #include "bspTwl3029_Aud_Map.h" + #include "bspTwl3029_Int_Map.h" +#endif + /**************************************/ + /* Prototypes for L1 SYNCH manager */ + /**************************************/ + void l1s_audio_manager(void); + #if (KEYBEEP) + void l1s_keybeep_manager(void); + #endif + #if (TONE) + void l1s_tone_manager(void); + #endif + #if (L1_CPORT == 1) + void l1s_cport_manager(void); + #endif + #if (MELODY_E1) + void l1s_melody0_manager(void); + void l1s_melody1_manager(void); + #endif + #if (VOICE_MEMO) + void l1s_vm_play_manager (void); + void l1s_vm_record_manager(void); + void l1s_tone_ul_manager (void); + #endif + #if (L1_PCM_EXTRACTION) + void l1s_pcm_download_manager (void); + void l1s_pcm_upload_manager (void); + #endif + #if (L1_VOICE_MEMO_AMR) + void l1s_vm_amr_play_manager (void); + void l1s_vm_amr_record_manager(void); + #endif + #if (SPEECH_RECO) + void l1s_sr_enroll_manager (void); + void l1s_sr_update_manager (void); + void l1s_sr_reco_manager (void); + void l1s_sr_processing_manager(void); + void l1s_sr_speech_manager (void); + #endif + #if (L1_AEC == 1) + void l1s_aec_manager (void); + #endif + #if (L1_AEC == 2) + void l1s_aec_manager (void); + #endif + #if (FIR) + void l1s_fir_manager (void); + void l1s_fir_set_params (void); + + #endif + #if (AUDIO_MODE) + void l1s_audio_mode_manager (void); + #endif + #if (MELODY_E2) + void l1s_melody0_e2_manager(void); + void l1s_melody1_e2_manager(void); + #endif + #if (L1_MP3 == 1) + void l1s_mp3_manager(void); + #endif + #if (L1_MIDI == 1) + void l1s_midi_manager(void); + #endif + #if (L1_AAC == 1) + void l1s_aac_manager(void); + #endif + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + void l1s_audio_onoff_manager(void); + #endif + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + void l1s_audio_voice_onoff_manager(void); + #endif + #if (L1_STEREOPATH == 1) + void l1s_stereopath_drv_manager(void); + #endif + #if (L1_ANR == 1 || L1_ANR == 2) + void l1s_anr_manager(void); + #endif + #if (L1_IIR == 1 || L1_IIR == 2) + void l1s_iir_manager(void); + #endif + #if (L1_WCM == 1) + void l1s_wcm_manager(void); + #endif + #if (L1_AGC_UL == 1) + void l1s_agc_ul_manager(void); + #endif + #if (L1_AGC_DL == 1) + void l1s_agc_dl_manager(void); + #endif + #if (L1_DRC == 1) + void l1s_drc_manager(void); + #endif + #if (L1_LIMITER == 1) + void l1s_limiter_manager(void); + #endif + #if (L1_ES == 1) + void l1s_es_manager(void); + #endif + + void l1s_audio_it_manager(void); + /**************************************/ + /* External prototypes */ + /**************************************/ + extern UWORD8 copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst); + extern UWORD8 copy_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src); + extern UWORD8 Cust_get_pointer (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id); + #if (MELODY_E2) + extern UWORD16 audio_twentyms_to_TDMA_convertion (UWORD16 twentyms_value); + #endif + #if (MELODY_E2) || (L1_VOICE_MEMO_AMR) + extern UWORD8 copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst); + extern UWORD8 copy_byte_data_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src); + #endif + #if (L1_VOICE_MEMO_AMR) + extern UWORD8 copy_byte_data_le_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_dst); + extern UWORD8 copy_byte_data_le_to_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, API *ptr_src); + #endif + + #if (L1_LIMITER == 1) + void l1_audio_lim_update_mul_low_high (); + #endif + + #if (L1_AGC_UL == 1) + extern void l1_audio_agc_ul_copy_params(); + #endif + + #if (L1_AGC_DL == 1) + extern void l1_audio_agc_dl_copy_params(); + #endif + + #if (L1_IIR == 2) + extern void l1_audio_iir4x_copy_params(); + #endif + +#if (L1_DRC == 1) + extern void l1_audio_drc1x_copy_params(); + #endif + + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + static void l1s_audio_ul_onoff_manager(); + static void l1s_audio_dl_onoff_manager(); + + void l1_audio_abb_ul_on_callback(void); + void l1_audio_abb_ul_off_callback(void); + void l1_audio_abb_dl_on_callback(void); + void l1_audio_abb_dl_off_callback(void); + void l1_audio_abb_ul_off_dl_off_callback(void); + void l1_audio_abb_ul_off_dl_on_callback(void); + void l1_audio_abb_ul_on_dl_off_callback(void); + void l1_audio_abb_ul_on_dl_on_callback(void); + void l1_audio_ul_onoff_trace(); + void l1_audio_dl_onoff_trace(); +#if (CODE_VERSION != SIMULATION) + BspTwl3029_ReturnCode l1_outen_update(void); +#endif + +#if (CODE_VERSION == SIMULATION) + signed char l1_outen_update(void); +#endif +#endif // L1_AUDIO_MCU_ONOFF + +#if (CODE_VERSION == SIMULATION)&&(L1_AUDIO_MCU_ONOFF == 1) + +// Triton Audio ON/OFF Changes +void l1_audio_abb_ul_on_req ( void(*callback_fn)(void) ); +void l1_audio_abb_dl_on_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_dl_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_off_dl_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_off_dl_on_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_on_dl_off_req ( void(*callback_fn)(void) ); +void l1_audio_abb_ul_on_dl_on_req ( void(*callback_fn)(void) ); + + +#endif + +#if (ANLG_FAM == 11) +//sundi: add the abb_write_done variable for I2C write acknowledgement +//UWORD8 abb_write_done = 0; +#endif + + /*-------------------------------------------------------*/ + /* l1s_audio_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Global manager of the L1S audio task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_manager(void) + { + BOOL l1_audio_it_com = FALSE; + + // Initialize the ITCOM for audio task + l1s.l1_audio_it_com = FALSE; + + #if (KEYBEEP) + // the keybeep task is activated? + if ((l1a_l1s_com.keybeep_task.command.start) || + (l1s.audio_state[L1S_KEYBEEP_STATE] != 0)) + { + l1s_keybeep_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (TONE) + // the tone task is activated? + if ((l1a_l1s_com.tone_task.command.start) || + (l1s.audio_state[L1S_TONE_STATE] != 0)) + { + l1s_tone_manager(); + l1_audio_it_com = TRUE; + } + #endif + + #if (MELODY_E1) + // the melody0 task is activated? + if ((l1a_l1s_com.melody0_task.command.start) || + (l1s.audio_state[L1S_MELODY0_STATE] != 0)) + { + l1s_melody0_manager(); + l1_audio_it_com = TRUE; + } + // the melody1 task is activated? + if ((l1a_l1s_com.melody1_task.command.start) || + (l1s.audio_state[L1S_MELODY1_STATE] != 0)) + { + l1s_melody1_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (VOICE_MEMO) + // the voicememo playing task is activated? + if ((l1a_l1s_com.voicememo_task.play.command.start) || + (l1s.audio_state[L1S_VM_PLAY_STATE] != 0)) + { + l1s_vm_play_manager(); + l1_audio_it_com = TRUE; + } + else // voicememo playing task and voice memo recoding task isn't compatible + { + // the voicememo recording task is activated? + if ((l1a_l1s_com.voicememo_task.record.command.start) || + (l1s.audio_state[L1S_VM_RECORD_STATE] != 0)) + { + l1s_vm_record_manager(); + l1_audio_it_com = TRUE; + } + // the voicememo tone uplink task is activated? + if ((l1a_l1s_com.voicememo_task.record.tone_ul.start) || + (l1s.audio_state[L1S_TONE_UL_STATE] != 0)) + { + l1s_tone_ul_manager(); + l1_audio_it_com = TRUE; + } + } + #endif + #if (L1_PCM_EXTRACTION) + // the PCM download task is activated? + if ((l1a_l1s_com.pcm_task.download.command.start) || + (l1s.audio_state[L1S_PCM_DOWNLOAD_STATE] != 0)) + { + l1s_pcm_download_manager(); + l1_audio_it_com = TRUE; + } + // the PCM upload task is activated? + if ((l1a_l1s_com.pcm_task.upload.command.start) || + (l1s.audio_state[L1S_PCM_UPLOAD_STATE] != 0)) + { + l1s_pcm_upload_manager(); + l1_audio_it_com = TRUE; + } + #endif /* L1_PCM_EXTRACTION */ + #if (L1_VOICE_MEMO_AMR) + // the voicememo playing task is activated? + if ((l1a_l1s_com.voicememo_amr_task.play.command.start) || + (l1s.audio_state[L1S_VM_AMR_PLAY_STATE] != 0)) + { + l1s_vm_amr_play_manager(); + l1_audio_it_com = TRUE; + } + else // voicememo playing task and voice memo recoding task isn't compatible + { + // the voicememo recording task is activated? + if ((l1a_l1s_com.voicememo_amr_task.record.command.start) || + (l1s.audio_state[L1S_VM_AMR_RECORD_STATE] != 0)) + { + l1s_vm_amr_record_manager(); + l1_audio_it_com = TRUE; + } + } + #endif + #if (SPEECH_RECO) + // the speech recognition enroll task is activated? + if ((l1a_l1s_com.speechreco_task.command.enroll_start) || + (l1s.audio_state[L1S_SR_ENROLL_STATE] != 0)) + { + l1s_sr_enroll_manager(); + l1_audio_it_com = TRUE; + } + else + // the speech recognition update task is activated? + if ((l1a_l1s_com.speechreco_task.command.update_start) || + (l1s.audio_state[L1S_SR_UPDATE_STATE] != 0)) + { + l1s_sr_update_manager(); + l1_audio_it_com = TRUE; + } + else + // the speech recognition reco task is activated? + if ((l1a_l1s_com.speechreco_task.command.reco_start) || + (l1s.audio_state[L1S_SR_RECO_STATE] != 0)) + { + l1s_sr_reco_manager(); + l1_audio_it_com = TRUE; + } + else + // the speech recognition processing task is activated? + if ((l1a_l1s_com.speechreco_task.command.processing_start) || + (l1s.audio_state[L1S_SR_PROCESSING_STATE] != 0)) + { + l1s_sr_processing_manager(); + l1_audio_it_com = TRUE; + } + // the speech recognition speech recording task is activated? + if ((l1a_l1s_com.speechreco_task.command.speech_start) || + (l1s.audio_state[L1S_SR_SPEECH_STATE] != 0)) + { + l1s_sr_speech_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_AEC == 1) + // the AEC is activated? + if ((l1a_l1s_com.aec_task.command.start) || + (l1s.audio_state[L1S_AEC_STATE] != 0)) + { + l1s_aec_manager(); + // It's not necessary to enable the IT DSP because the + // AEC works with the dedicated speech therefor an IT DSP is + // already requested by the modem + } + #endif + #if (L1_AEC == 2) + // the AEC is activated? + if ((l1a_l1s_com.aec_task.command.start) || + (l1s.audio_state[L1S_AEC_STATE] != 0)) + { + l1s_aec_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (FIR) + // the FIR is activated? +if ((l1a_l1s_com.fir_task.command.start) || + (l1s.audio_state[L1S_FIR_STATE] !=0 )) + { + l1s_fir_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (AUDIO_MODE) + // the AUDIO MODE is activated? + if (l1a_l1s_com.audio_mode_task.command.start) + { + l1s_audio_mode_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (MELODY_E2) + // Handling counters + if (l1s.melody_e2.dsp_task == TRUE) + { + l1s.melody_e2.timebase++; + l1s.melody_e2.timebase_mod_60ms++; + if (l1s.melody_e2.timebase_mod_60ms == 13) + l1s.melody_e2.timebase_mod_60ms = 0; + } + else + { + l1s.melody_e2.timebase = 0; + l1s.melody_e2.timebase_mod_60ms = 0; + } + + // Update the oscillator active fields with DSP active oscillators + l1s.melody_e2.global_osc_active = l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_active; + l1s.melody_e2.global_osc_to_start = 0; + + // oscillator active fields can't be updated until dsp has acknowledged new notes + if (l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore == 0) + { + l1s.melody0_e2.oscillator_active &= l1s.melody_e2.global_osc_active; + l1s.melody1_e2.oscillator_active &= l1s.melody_e2.global_osc_active; + } + + // Both states machines are inactive => Start or Stop DSP module + if ( (l1s.audio_state[L1S_MELODY0_E2_STATE] == 0) && + (l1s.audio_state[L1S_MELODY1_E2_STATE] == 0) ) + { + // Start command + DSP module not running => Start DSP module + if( ((l1a_l1s_com.melody0_e2_task.command.start) || + (l1a_l1s_com.melody1_e2_task.command.start)) && + (l1s.melody_e2.dsp_task == FALSE) ) + { + // Set the bit TONE to do the init only at the first start + // of the first melody (in case of 2 melodies) + // Select the melody E2 instead of E1 or tones + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E2_SELECTED; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_MELO | B_TONE); + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0; + + // set delta_time as non valid + l1s.melody0_e2.delta_time = 0xFFFF; + l1s.melody1_e2.delta_time = 0xFFFF; + + // Set the flag to confirm that the DSP melody E2 task is started + l1s.melody_e2.dsp_task = TRUE; + } + // No command, DSP module running => Stop DSP module + else + if (l1s.melody_e2.dsp_task) + { + // The 2 melodies are stopped therefore the DSP must be + // stopped so the bit B_MELO must be reset. + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E2_SELECTED; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_MELO | B_TONE); + + // Reset the flag to know if the DSP melody E2 task runs + l1s.melody_e2.dsp_task = FALSE; + + l1_audio_it_com = TRUE; + } + } + + // the melody0 task is activated? + if ( (l1a_l1s_com.melody0_e2_task.command.start) || + (l1s.audio_state[L1S_MELODY0_E2_STATE] != 0) ) + { + l1s_melody0_e2_manager(); + l1_audio_it_com = TRUE; + } + // the melody0 task is activated? + if ( (l1a_l1s_com.melody1_e2_task.command.start) || + (l1s.audio_state[L1S_MELODY1_E2_STATE] != 0) ) + { + l1s_melody1_e2_manager(); + l1_audio_it_com = TRUE; + } + + // We updated some oscillators so we must set the semaphore + if (l1s.melody_e2.global_osc_to_start != 0x0000) + { + // Set the melody E2 semaphore + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore = 0x0001; + + // Update delta_time by min_delta_time(melo0, melo1) + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = l1s.melody0_e2.delta_time; + if (l1s.melody1_e2.delta_time < l1s.melody0_e2.delta_time) + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = l1s.melody1_e2.delta_time; + + l1s.melody0_e2.delta_time = 0xFFFF; + l1s.melody1_e2.delta_time = 0xFFFF; + } + #endif + + #if (L1_MP3 == 1) + if ((l1a_l1s_com.mp3_task.command.start) || + (l1s.audio_state[L1S_MP3_STATE] != 0)) + { + l1s_mp3_manager(); + l1_audio_it_com=TRUE; + } + #endif // L1_MP3 + + #if (L1_AAC == 1) + if ((l1a_l1s_com.aac_task.command.start) || + (l1s.audio_state[L1S_AAC_STATE] != 0)) + { + l1s_aac_manager(); + l1_audio_it_com=TRUE; + } + #endif // L1_AAC + #if (L1_CPORT == 1) + // the Cport task is activated? + if ((l1a_l1s_com.cport_task.command.start) || + (l1s.audio_state[L1S_CPORT_STATE] != 0)) + { + l1s_cport_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + // the audio on off task is activated? + if (l1a_l1s_com.audio_onoff_task.command.start || + (l1s.audio_state[L1S_AUDIO_ONOFF_STATE] != 0)) + { + l1s_audio_onoff_manager(); + l1_audio_it_com = TRUE; + } + #endif + + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + // the audio on off task is activated? + if (l1a_l1s_com.audio_onoff_task.command.start || + (l1s.audio_state[L1S_AUDIO_ONOFF_STATE] != 0)) + { + l1s_audio_voice_onoff_manager(); + l1_audio_it_com = TRUE; + } + #endif + + #if (L1_STEREOPATH == 1) + // the Stereopath task is activated? + if ((l1a_l1s_com.stereopath_drv_task.command.start) || + (l1s.audio_state[L1S_STEREOPATH_DRV_STATE] != 0)) + { + l1s_stereopath_drv_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_ANR == 1 || L1_ANR == 2) + // the ANR task is activated? + if (l1a_l1s_com.anr_task.command.update || + (l1s.audio_state[L1S_ANR_STATE] != 0)) + { + l1s_anr_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_IIR == 1 || L1_IIR == 2) + // the IIR task is activated? + if (l1a_l1s_com.iir_task.command.update || + (l1s.audio_state[L1S_IIR_STATE] != 0)) + { + l1s_iir_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_WCM == 1) + // the WCM task is activated? + if (l1a_l1s_com.wcm_task.command.update || + (l1s.audio_state[L1S_WCM_STATE] != 0)) + { + l1s_wcm_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_DRC == 1) + // the DRC task is activated? + if (l1a_l1s_com.drc_task.command.update || + (l1s.audio_state[L1S_DRC_STATE] != 0)) + { + l1s_drc_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_AGC_UL == 1) + // the AGC UL task is activated? + if (l1a_l1s_com.agc_ul_task.command.update || + (l1s.audio_state[L1S_AGC_UL_STATE] != 0)) + { + l1s_agc_ul_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_AGC_DL == 1) + // the AGC DL task is activated? + if (l1a_l1s_com.agc_dl_task.command.update || + (l1s.audio_state[L1S_AGC_DL_STATE] != 0)) + { + l1s_agc_dl_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_LIMITER == 1) + // the LIMITER task is activated? + if (l1a_l1s_com.limiter_task.command.update || + l1a_l1s_com.limiter_task.command.partial_update || + (l1s.audio_state[L1S_LIMITER_STATE] != 0)) + { + l1s_limiter_manager(); + l1_audio_it_com = TRUE; + } + #endif + #if (L1_ES == 1) + // the echo suppressor task is activated? + if (l1a_l1s_com.es_task.command.update || + (l1s.audio_state[L1S_ES_STATE] != 0)) + { + l1s_es_manager(); + l1_audio_it_com = TRUE; + } + #endif + + // the audio It task is activated? + if (l1a_l1s_com.audioIt_task.command.start) + { + l1s_audio_it_manager(); + l1_audio_it_com = TRUE; + } + + #if (L1_MIDI == 1) + if ((l1a_l1s_com.midi_task.command.start) || + (l1s.audio_state[L1S_MIDI_STATE] != 0)) + { + l1s_midi_manager(); + l1_audio_it_com=TRUE; + } + #endif // L1_MIDI + + // The audio IT shall be foprwarded to the DSP in case the L1S is forcing the audio + if (l1a_l1s_com.audio_forced_by_l1s == TRUE) + l1_audio_it_com = TRUE; + + l1s.l1_audio_it_com = l1_audio_it_com; + } + + +#if (L1_AUDIO_MCU_ONOFF == 1) + void l1s_audio_onoff_manager(void) + { + T_L1S_AUDIO_ONOFF_MANAGER *onoff_ctl = &(l1s.audio_on_off_ctl); + + //l1_audio_onoff_entry_sim_log(); +#if (AUDIO_DEBUG == 1) + trace_info.audio_debug_var.ul_state = l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + trace_info.audio_debug_var.dl_state = l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + trace_info.audio_debug_var.ul_onoff_counter = onoff_ctl->l1_audio_switch_on_ul_request; + trace_info.audio_debug_var.dl_onoff_counter = onoff_ctl->l1_audio_switch_on_dl_request; +#endif + + l1s_audio_ul_onoff_manager(); + l1s_audio_dl_onoff_manager(); + + // Call the driver depending on the actions + switch(onoff_ctl->l1_audio_ul_action) + { + case L1_AUDIO_NO_ACTION: + { + switch(onoff_ctl->l1_audio_dl_action) + { + case L1_AUDIO_NO_ACTION: + { + // UL No Action and DL No Action Do nothing + } + break; + case L1_AUDIO_TURN_ON: + { + // UL No Action and DL Turn on + l1_audio_abb_dl_on_req(l1_audio_abb_dl_on_callback); + } + break; + case L1_AUDIO_TURN_OFF: + { + // UL No Action and DL Turn off + l1_audio_abb_dl_off_req(l1_audio_abb_dl_off_callback); + } + break; + default: + { + // Invalid Action send error trace here + } + break; + } // end switch(l1_audio_dl_action) + } + break; + case L1_AUDIO_TURN_ON: + { + switch(onoff_ctl->l1_audio_dl_action) + { + case L1_AUDIO_NO_ACTION: + { + // UL Action ON and DL No Action + l1_audio_abb_ul_on_req(l1_audio_abb_ul_on_callback); + } + break; + case L1_AUDIO_TURN_ON: + { + // UL Action ON and DL Action ON + l1_audio_abb_ul_on_dl_on_req(l1_audio_abb_ul_on_dl_on_callback); + } + break; + case L1_AUDIO_TURN_OFF: + { + // UL Action ON and DL Action OFF + l1_audio_abb_ul_on_dl_off_req(l1_audio_abb_ul_on_dl_off_callback); + } + break; + default: + { + // Invalid Action Send error trace here + } + break; + } // end switch(l1_audio_dl_action) + + } + break; + case L1_AUDIO_TURN_OFF: + { + switch(onoff_ctl->l1_audio_dl_action) + { + case L1_AUDIO_NO_ACTION: + { + // UL Action OFF DL No Action + l1_audio_abb_ul_off_req(l1_audio_abb_ul_off_callback); + } + break; + case L1_AUDIO_TURN_ON: + { + // UL Action OFF DL Action ON + l1_audio_abb_ul_off_dl_on_req(l1_audio_abb_ul_off_dl_on_callback); + } + break; + case L1_AUDIO_TURN_OFF: + { + // UL Action OFF DL Action OFF + l1_audio_abb_ul_off_dl_off_req(l1_audio_abb_ul_off_dl_off_callback); + } + break; + default: + { + } + break; + } // end switch(l1_audio_dl_action) + + } + break; + default: + { + // Invalid Action send error trace here + } + break; + } // end switch(l1_audio_ul_action) + + } // end l1s_audio_triton_onoff_manager() + + static void l1s_audio_ul_onoff_manager() + { + + T_L1S_AUDIO_ONOFF_MANAGER *onoff_ctl = &(l1s.audio_on_off_ctl); + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + + onoff_ctl->l1_audio_ul_action = L1_AUDIO_NO_ACTION; + + + if(onoff_ctl->l1_audio_switch_on_ul_request >= 1) + { + // At least one module requires UL audio path to be on + switch(*state) + { + case L1_AUDIO_UL_OFF: + { + // UL audio path is OFF and needs to be started + onoff_ctl->l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + onoff_ctl->l1_audio_ul_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_UL_SWITCHON_STARTED; + onoff_ctl->l1_audio_ul_switched_on = FALSE; + onoff_ctl->l1_audio_ul_switched_off = TRUE; + } + break; + case L1_AUDIO_UL_SWITCHON_STARTED: + { + // UL audio path in the process of turning on + // Check if it is turned on, if so change state to UL on + if(onoff_ctl->l1_audio_ul_switched_on == TRUE) + { + onoff_ctl->l1_audio_ul_switched_off = FALSE; + *state = L1_AUDIO_UL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_ON: + { + // UL audio path is on and some module wants it to be so + // Do nothing essentially except initialize the hold time + onoff_ctl->l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_SWITCHOFF_STARTED: + { + // UL is being switched off and some module requests switch on! + // Since the driver is required to maintain the order of requests + // we perform the same actions as in the UL_OFF state + onoff_ctl->l1_audio_ul_on2off_hold_time = + L1_AUDIO_ON2OFF_UL_HOLD_TIME; + onoff_ctl->l1_audio_ul_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_UL_SWITCHON_STARTED; + onoff_ctl->l1_audio_ul_switched_on = FALSE; + onoff_ctl->l1_audio_ul_switched_off = TRUE; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state put error trace here + } + break; + } // end switch(l1_audio_ul_state) + + } // end if(l1_audio_switch_on_ul_req >= 1) + else + { + // No module requires UL Audio path to be on + switch(*state) + { + case L1_AUDIO_UL_OFF: + { + // UL audio path is off and all modules want it that way, do nothing + } + break; + case L1_AUDIO_UL_SWITCHON_STARTED: + { + // UL audio path being switched on. Modules want it turned off! + // Allow UL to be turned on, still if modules want it turned off + // we will wait for ON2OFF hold time and turn it off + if(onoff_ctl->l1_audio_ul_switched_on == TRUE) + { + onoff_ctl->l1_audio_ul_switched_off = FALSE; + *state = L1_AUDIO_UL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_ON: + { + // UL audio path is on and all modules want turn off. We wait + // for the ON2OFF hold time and then actually turn it off + if(onoff_ctl->l1_audio_ul_on2off_hold_time == 0) + { + onoff_ctl->l1_audio_ul_action = L1_AUDIO_TURN_OFF; + *state = L1_AUDIO_UL_SWITCHOFF_STARTED; + onoff_ctl->l1_audio_ul_switched_off = FALSE; + onoff_ctl->l1_audio_ul_switched_on = TRUE; + } + else + onoff_ctl->l1_audio_ul_on2off_hold_time--; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_UL_SWITCHOFF_STARTED: + { + if(onoff_ctl->l1_audio_ul_switched_off == TRUE) + { + *state = L1_AUDIO_UL_OFF; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state send error trace here + } + break; + } // end switch(l1_audio_ul_state) + + } // end if(l1_audio_switch_on_ul_req >= 1)else + +#if (CODE_VERSION == SIMULATION) + l1_audio_ul_onoff_simu_trace(); +#else + l1_audio_ul_onoff_trace(); +#endif + + } // end l1s_audio_ul_onoff_manager() + + static void l1s_audio_dl_onoff_manager() + { + + T_L1S_AUDIO_ONOFF_MANAGER *onoff_ctl = &(l1s.audio_on_off_ctl); + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + + onoff_ctl->l1_audio_dl_action = L1_AUDIO_NO_ACTION; + + + if(onoff_ctl->l1_audio_switch_on_dl_request >= 1) + { + // At least one module requires DL audio path to be on + switch(*state) + { + case L1_AUDIO_DL_OFF: + { + // DL audio path is OFF and needs to be started + onoff_ctl->l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + onoff_ctl->l1_audio_dl_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_DL_SWITCHON_STARTED; + onoff_ctl->l1_audio_dl_switched_on = FALSE; + onoff_ctl->l1_audio_dl_switched_off = TRUE; + } + break; + case L1_AUDIO_DL_SWITCHON_STARTED: + { + // DL audio path in the process of turning on + // Check if it is turned on, if so change state to DL on + if(onoff_ctl->l1_audio_dl_switched_on == TRUE) + { + onoff_ctl->l1_audio_dl_switched_off = FALSE; + *state = L1_AUDIO_DL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_ON: + { + + /* OUTEN registers have been updated */ + if(l1a_l1s_com.outen_cfg_task.command_requested != l1a_l1s_com.outen_cfg_task.command_commited) + { + #if (CODE_VERSION != SIMULATION) + l1_outen_update(); + #endif + } + // DL audio path is on and some module wants it to be so + // Do nothing essentially except initialize the hold time + onoff_ctl->l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_SWITCHOFF_STARTED: + { + // DL is being switched off and some module requests switch on! + // Since the driver is required to maintain the order of requests + // we perform the same actions as in the DL_OFF state + onoff_ctl->l1_audio_dl_on2off_hold_time = + L1_AUDIO_ON2OFF_DL_HOLD_TIME; + onoff_ctl->l1_audio_dl_action = L1_AUDIO_TURN_ON; + *state = L1_AUDIO_DL_SWITCHON_STARTED; + onoff_ctl->l1_audio_dl_switched_on = FALSE; + onoff_ctl->l1_audio_dl_switched_off = TRUE; + + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state put error trace here + } + break; + } // end switch(l1_audio_dl_state) + + } // end if(l1_audio_switch_on_dl_req >= 1) + else + { + // No module requires DL Audio path to be on + switch(*state) + { + case L1_AUDIO_DL_OFF: + { + // DL audio path is off and all modules want it that way, do nothing + } + break; + case L1_AUDIO_DL_SWITCHON_STARTED: + { + // DL audio path being switched on. Modules want it turned off! + // Allow DL to be turned on, still if modules want it turned off + // we will wait for ON2OFF hold time and turn it off + if(onoff_ctl->l1_audio_dl_switched_on == TRUE) + { + onoff_ctl->l1_audio_dl_switched_off = FALSE; + *state = L1_AUDIO_DL_ON; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_ON: + { + // DL audio path is on and all modules want turn off. We wait + // for the ON2OFF hold time and then actually turn it off + if(onoff_ctl->l1_audio_dl_on2off_hold_time == 0) + { + onoff_ctl->l1_audio_dl_action = L1_AUDIO_TURN_OFF; + *state = L1_AUDIO_DL_SWITCHOFF_STARTED; + onoff_ctl->l1_audio_dl_switched_off = FALSE; + onoff_ctl->l1_audio_dl_switched_on = TRUE; + } + else + onoff_ctl->l1_audio_dl_on2off_hold_time--; + + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + case L1_AUDIO_DL_SWITCHOFF_STARTED: + { + if(onoff_ctl->l1_audio_dl_switched_off == TRUE) + { + *state = L1_AUDIO_DL_OFF; + } + #if(CODE_VERSION == NOT_SIMULATION) + l1s.l1_audio_it_com = TRUE; + #endif + } + break; + default: + { + // Invalid state send error trace here + } + break; + } // end switch(l1_audio_dl_state) + + } // end if(l1_audio_switch_on_dl_req >= 1)else + +#if (CODE_VERSION == SIMULATION) + l1_audio_dl_onoff_simu_trace(); +#else + l1_audio_dl_onoff_trace(); +#endif + + + } // end l1s_audio_dl_onoff_manager() + +#if (CODE_VERSION == NOT_SIMULATION) +void l1_audio_ul_onoff_trace() +{ + static T_L1_AUDIO_UL_STATE prev_state = L1_INVALID; + UWORD8 *curr_state = &l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + + if(*curr_state != prev_state) + { + prev_state =(T_L1_AUDIO_UL_STATE) *curr_state; + switch(prev_state) + { + case L1_AUDIO_UL_OFF: + { + //L1_trace_string("UL AUDIO OFF\r\n"); + l1_trace_ul_audio_onoff(L1_AUDIO_UL_OFF); + } + break; + case L1_AUDIO_UL_SWITCHON_STARTED: + { + l1_trace_ul_audio_onoff(L1_AUDIO_UL_SWITCHON_STARTED); + } + break; + case L1_AUDIO_UL_ON: + { + l1_trace_ul_audio_onoff(L1_AUDIO_UL_ON); + } + break; + case L1_AUDIO_UL_SWITCHOFF_STARTED: + { + l1_trace_ul_audio_onoff(L1_AUDIO_UL_SWITCHOFF_STARTED); + } + break; + + } // End switch(prev_state) + } // end if(l1s.ul_state == prev_state) + +} + +void l1_audio_dl_onoff_trace() +{ + static T_L1_AUDIO_DL_STATE prev_state = L1_DL_INVALID; + UWORD8 *curr_state = &l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + + if(*curr_state != prev_state) + { + prev_state = (T_L1_AUDIO_DL_STATE) *curr_state; + switch(prev_state) + { + case L1_AUDIO_DL_OFF: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_OFF); + } + break; + case L1_AUDIO_DL_SWITCHON_STARTED: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_SWITCHON_STARTED); + } + break; + case L1_AUDIO_DL_ON: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_ON); + } + break; + case L1_AUDIO_DL_SWITCHOFF_STARTED: + { + l1_trace_dl_audio_onoff(L1_AUDIO_DL_SWITCHOFF_STARTED); + } + break; + + } // End switch(prev_state) + } // end if(l1s.ul_state == prev_state) +} + +#endif // CODE_VERSION == NOT_SIMULATION + + void l1_audio_abb_ul_on_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = TRUE; + } + void l1_audio_abb_ul_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + } + void l1_audio_abb_dl_on_callback(void) + { + l1_outen_update(); + } + void l1_audio_abb_dl_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; + } + void l1_audio_abb_ul_off_dl_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; + } + void l1_audio_abb_ul_off_dl_on_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_off = TRUE; + l1_outen_update(); + } + void l1_audio_abb_ul_on_dl_off_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = TRUE; + l1s.audio_on_off_ctl.l1_audio_dl_switched_off = TRUE; + } + void l1_audio_abb_ul_on_dl_on_callback(void) + { + l1s.audio_on_off_ctl.l1_audio_ul_switched_on = TRUE; + + l1_outen_update(); + } + + void l1_audio_abb_outen_cfg_callback(UWORD8 argument) + { + (void)(argument); + l1s.audio_on_off_ctl.l1_audio_dl_switched_on = TRUE; + } +#if (CODE_VERSION != SIMULATION) + +BspTwl3029_ReturnCode l1_outen_update(void) +{ + BspTwl3029_ReturnCode returnVal = BSP_TWL3029_RETURN_CODE_FAILURE; + UWORD16 count = 0; + UINT8 triton_classD = 0; + + /* callback function info pointer */ + BspTwl3029_I2C_Callback i2c_callback; + BspTwl3029_I2C_CallbackPtr callbackPtr= &i2c_callback; + + /* I2C array */ + Bsp_Twl3029_I2cTransReqArray i2cTransArray; + Bsp_Twl3029_I2cTransReqArrayPtr i2cTransArrayPtr= &i2cTransArray; + + /* twl3029 I2C reg info struct */ + BspTwl3029_I2C_RegisterInfo regInfo[11] ; + BspTwl3029_I2C_RegisterInfo* regInfoPtr = regInfo; + + BspTwl3029_I2C_RegData tmpAudioHFTest1RegData=0; + BspTwl3029_I2C_RegData tmpCtrl3RegData=0; + + + l1a_l1s_com.outen_cfg_task.command_requested = l1a_l1s_com.outen_cfg_task.command_commited; + + bspTwl3029_Audio_getClassD_mode(&triton_classD); + + returnVal = BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + &tmpCtrl3RegData); + returnVal = BspTwl3029_I2c_shadowRegRead(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + &tmpAudioHFTest1RegData); + + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN1_OFFSET, + l1a_l1s_com.outen_cfg_task.outen1, regInfoPtr++); + count++; + + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET, + l1a_l1s_com.outen_cfg_task.outen2, regInfoPtr++); + count++; + + if(l1a_l1s_com.outen_cfg_task.classD == 0x01) // User wants to configure classD + { + if(triton_classD == 0x00) // User wants to switch on and Triton not configured for classD + { + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_CKG_TESTUNLOCK_OFFSET, + 0xb6, regInfoPtr++); + count++; + + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + + tmpCtrl3RegData |= 0x80; // AUDIO_CTRL3_SPKDIGON + tmpAudioHFTest1RegData = 0x01; // AUDIO_HFTEST1_SPKALLZB + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + tmpCtrl3RegData, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + tmpAudioHFTest1RegData, regInfoPtr++); + count++; + } + } + else if(l1a_l1s_com.outen_cfg_task.classD == 0x00) + { + if(triton_classD != 0x00) // User wants no to classD and Triton configured for classD + { + tmpCtrl3RegData &= 0x7F; // AUDIO_CTRL3_SPKDIGON + tmpAudioHFTest1RegData = 0x00; // AUDIO_HFTEST1_SPKALLZB + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_HFTEST1_OFFSET, + tmpAudioHFTest1RegData, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_AUDIO_CTRL3_OFFSET, + tmpCtrl3RegData, regInfoPtr++); + count++; + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + + BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD, BSP_TWL_3029_MAP_CKG_TESTUNLOCK_OFFSET, + 0x00, regInfoPtr++); + count++; + + } + else // User no classD & Triton also no classD + { + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + returnVal = BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN2_OFFSET, + l1a_l1s_com.outen_cfg_task.outen2, regInfoPtr++); + count++; + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_OUTEN3_OFFSET, + l1a_l1s_com.outen_cfg_task.outen3, regInfoPtr++); + count++; + } + } + + returnVal= BspTwl3029_I2c_regQueWrite(BSP_TWL3029_I2C_AUD,BSP_TWL_3029_MAP_AUDIO_POPMAN_OFFSET, + 0x00,regInfoPtr++); + count++; + callbackPtr->callbackFunc = l1_audio_abb_outen_cfg_callback; + callbackPtr->callbackVal = 0; + + if (returnVal != BSP_TWL3029_RETURN_CODE_FAILURE) + { + regInfoPtr = regInfo; + /* now request to I2C manager to write to Triton registers */ + + returnVal = BspTwl3029_I2c_regInfoSend(regInfo,count,callbackPtr, + (BspI2c_TransactionRequest*)i2cTransArrayPtr); + } + + return returnVal; + } /* end function l1s_outen_update */ + + +#endif +#if (CODE_VERSION == SIMULATION) + // This function is written to turn on the flag l1_audio_dl_switched_on during simulation +signed char l1_outen_update(void) + { + l1s.audio_on_off_ctl.l1_audio_dl_switched_on = TRUE; + } +#endif +#endif // L1_AUDIO_MCU_ONOFF + +// END Triton Audio ON/OFF Changes + + + #if (KEYBEEP) + /*-------------------------------------------------------*/ + /* l1s_keybeep_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Keybeep L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_keybeep_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_KEYBEEP_START = 2, + WAIT_KEYBEEP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_KEYBEEP_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + + case IDLE: + { + // Triton Audio ON/OFF Changes +#if(L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Start the DSP keybeep task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_KEYBEEP; + *state = WAIT_KEYBEEP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Start the DSP keybeep task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_KEYBEEP; + *state = WAIT_KEYBEEP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_KEYBEEP_START: + { + // the DSP acknowledges the L1S start request. + if ((!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_KEYBEEP)) && + (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_KEYBEEP)) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_KEYBEEP_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_KEYBEEP_STOP; + } + } + break; + + case WAIT_KEYBEEP_STOP: + { + // the DSP is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_KEYBEEP)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_KEYBEEP_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + else + // the MMI requests to stop the current keybeep + if (l1a_l1s_com.keybeep_task.command.stop) + { + // Stop the DSP keybeep task + l1s_dsp_com.dsp_ndb_ptr->d_dur_kb = 0; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_KEYBEEP; + + // Disable the stop command + l1a_l1s_com.keybeep_task.command.stop = FALSE; + } + } + break; + } // switch + } + #endif // KEYBEEP + #if (TONE) + /*-------------------------------------------------------*/ + /* l1s_tone_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Tone L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_tone_manager(void) + { + enum states + { + IDLE = 0, +// Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF== 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_TONE_START = 2, + WAIT_TONE_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_TONE_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Start the DSP tone task + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init &= ~(B_MELO); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + *state = WAIT_TONE_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Start the DSP tone task + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init &= ~(B_MELO); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + *state = WAIT_TONE_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_TONE_START: + { + // the DSP acknowledges the L1S start request. + if ((!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_TONE)) && + (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE)) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_TONE_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_TONE_STOP; + } + } + break; + + case WAIT_TONE_STOP: + { + // the DSP is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_TONE_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + else + // the MMI requests to stop the current tone + if (l1a_l1s_com.tone_task.command.stop) + { + // Stop the DSP tone task + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = 0; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + // Disable the stop command + l1a_l1s_com.tone_task.command.stop = FALSE; + } + } + break; + } // switch + } + #endif // TONE + #if (MELODY_E1) + /*-------------------------------------------------------*/ + /* l1s_melody0_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Melody 0 L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody0_manager(void) + { + enum states + { + M0_INACTIVE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + M0_WAIT_AUDIO_START = 1, +#endif + M0_WAIT_DSP_START = 2, + M0_WAIT_COUNTER_EQUAL_0 = 3, + M0_WAIT_DESCRIPTION_START = 4, + M0_WAIT_END_MELO = 5 + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY0_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 i, load_size; + UWORD16 melo_header[2], trash[4]; + API *osc_used; + + switch(*state) + { + case M0_INACTIVE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = M0_WAIT_AUDIO_START; +#else + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody0.ptr_buf = l1a_l1s_com.melody0_task.parameters.ptr_buf; + l1s.melody0.buffer_size = l1a_l1s_com.melody0_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 1, + &l1s.melody0.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M0_WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; +#if (L1_AUDIO_MCU_ONOFF == 1) + case M0_WAIT_AUDIO_START: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody0.ptr_buf = l1a_l1s_com.melody0_task.parameters.ptr_buf; + l1s.melody0.buffer_size = l1a_l1s_com.melody0_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 1, + &l1s.melody0.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M0_WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case M0_WAIT_DSP_START: + { + // The DSP is started + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_TONE) ) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY0_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + } + break; + + case M0_WAIT_COUNTER_EQUAL_0: + { + // The MMI resquests to stop the current melody 0. + if (l1a_l1s_com.melody0_task.command.stop) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody0_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody0_task.command.stop = FALSE; + + *state = M0_WAIT_END_MELO; + } + else + { + // Decrease the download coundter + l1s.melody0.counter--; + + // The description must be downloaded. + if (l1s.melody0.counter == 0) + { + // Set the oscillator used in the following description + l1s.melody0.oscillator_used_in_desc = Field(l1s.melody0.melody_header, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + l1s.melody0.oscillator_started = 0; + + // Download the new description + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (Field(l1s.melody0.oscillator_used_in_desc, (0x01<<i), i)) + { + // This oscillator description must be used. + if (l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[i] != SC_NUMBER_OSCILLATOR) + { + osc_used = l1s.melody0.oscillator[l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[i]]; + l1s.melody0.oscillator_started |= (0x01<<(l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[i])); + } + else + // The oscillator description isn't used and put to the "trash" + { + osc_used = trash; + } + + // Download the two first words of the oscillator description + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 2, + osc_used); + + load_size = 0; + if (Field(*(osc_used+1), SC_MELO_LOAD1_MASK, SC_MELO_LOAD1_SHIFT)) + load_size++; + if (Field(*(osc_used+1), SC_MELO_LOAD2_MASK, SC_MELO_LOAD2_SHIFT)) + load_size++; + + // Download the next word(s) of the oscillator description + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + load_size, + osc_used+2); + + // Enable this new description + *osc_used |= 1; + } + } + + *state = M0_WAIT_DESCRIPTION_START; + } + } + } + break; + + case M0_WAIT_DESCRIPTION_START: + { + + // The new description is started or no oscillator of the description was allocated. + if ((l1s.melody0.oscillator_started & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active) || + (l1s.melody0.oscillator_started == 0) ) + { + // Download the header of the next description of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 1, + &l1s.melody0.melody_header); + + // Is it the end of the melody? + if (l1s.melody0.melody_header == 0x0000) + { + *state = M0_WAIT_END_MELO; + // Header is wrong - L1 needs a forcible stop here +#if (CODE_VERSION == SIMULATION) + // l1a_l1s_com.melody1_task.command.stop = TRUE; +#else + l1a_l1s_com.melody1_task.command.stop = TRUE; +#endif + } + else + { + // Initialize the counter with the next offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + } + } + break; + + case M0_WAIT_END_MELO: + { + if (l1a_l1s_com.melody0_task.command.stop) + { + // Initialize the oscillators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody0.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody0_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody0_task.command.stop = FALSE; + + *state = M0_WAIT_END_MELO; + } + else + // All oscillators used are stopped. + if (!( l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active)) + { + // The melody is in loopback mode? + if (l1a_l1s_com.melody0_task.parameters.loopback) + { + // Reset the buffer description + #if (OP_RIV_AUDIO == 0) + l1s.melody0.ptr_buf = NULL; + #endif + l1s.melody0.buffer_size = 0; + l1s.melody0.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody0.ptr_buf, + &l1s.melody0.buffer_size, + l1a_l1s_com.melody0_task.parameters.session_id); + + // Download the 2 first words of the melody + l1s.melody0.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id, + &l1s.melody0.buffer_size, + (UWORD16 **)&l1s.melody0.ptr_buf, + 2, + (UWORD16 *)&melo_header); + + // Save the header of the first melody score description + l1s.melody0.melody_header = melo_header[1]; + + // Initialize the counter with the first offset time: + l1s.melody0.counter = ( ( Field(l1s.melody0.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + else + { + // Disable the oscillator dedicated to this melody + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used &= ~(l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap); + + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY0_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M0_INACTIVE; + } + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_melody1_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Melody 1 L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody1_manager(void) + { + enum states + { + M1_INACTIVE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + M1_WAIT_AUDIO_START = 1, +#endif + M1_WAIT_DSP_START = 2, + M1_WAIT_COUNTER_EQUAL_0 = 3, + M1_WAIT_DESCRIPTION_START = 4, + M1_WAIT_END_MELO = 5 + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY1_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 i, load_size; + UWORD16 melo_header[2], trash[4]; + API *osc_used; + + switch(*state) + { + case M1_INACTIVE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = M1_WAIT_AUDIO_START; +#else + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody1.ptr_buf = l1a_l1s_com.melody1_task.parameters.ptr_buf; + l1s.melody1.buffer_size = l1a_l1s_com.melody1_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 1, + &l1s.melody1.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M1_WAIT_DSP_START; +#endif + } + break; +#if (L1_AUDIO_MCU_ONOFF == 1) + case M1_WAIT_AUDIO_START: + { + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + // Initialize the pointer to the buffer, the buffer size + l1s.melody1.ptr_buf = l1a_l1s_com.melody1_task.parameters.ptr_buf; + l1s.melody1.buffer_size = l1a_l1s_com.melody1_task.parameters.buffer_size; + + // Download the header of the first description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 1, + &l1s.melody1.melody_header); + + // Initialize the counter with the first offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + // Enable the oscillator used + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used |= l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap; + + // Start the DSP melody task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = MELODY_E1_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (B_TONE | B_MELO); + + *state = M1_WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case M1_WAIT_DSP_START: + { + // The DSP is started + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_TONE) ) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY1_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + } + break; + + case M1_WAIT_COUNTER_EQUAL_0: + { + // The MMI resquests to stop the current melody 1. + if (l1a_l1s_com.melody1_task.command.stop) + { + // Initialize the oscilators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody1_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody1_task.command.stop = FALSE; + + *state = M1_WAIT_END_MELO; + } + else + { + // Decrease the download coundter + l1s.melody1.counter--; + + // The description must be downloaded. + if (l1s.melody1.counter == 0) + { + // Set the oscillator used in the following description + l1s.melody1.oscillator_used_in_desc = Field(l1s.melody1.melody_header, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT); + l1s.melody1.oscillator_started = 0; + + // Download the new description + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (Field(l1s.melody1.oscillator_used_in_desc, (0x01<<i), i)) + { + // This oscillator description must be used. + if (l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[i] != SC_NUMBER_OSCILLATOR) + { + osc_used = l1s.melody1.oscillator[l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[i]]; + l1s.melody1.oscillator_started |= (0x01<<(l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[i])); + } + else + // The oscillator description isn't used and put to the "trash" + { + osc_used = trash; + } + + // Download the two first words of the oscillator description + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 2, + osc_used); + + load_size = 0; + if (Field(*(osc_used+1), SC_MELO_LOAD1_MASK, SC_MELO_LOAD1_SHIFT)) + load_size++; + if (Field(*(osc_used+1), SC_MELO_LOAD2_MASK, SC_MELO_LOAD2_SHIFT)) + load_size++; + + // Download the next word(s) of the oscillator description + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + load_size, + osc_used+2); + + // Enable this new description + *osc_used |= 1; + } + } + + *state = M1_WAIT_DESCRIPTION_START; + } + } + } + break; + + case M1_WAIT_DESCRIPTION_START: + { + // The new description is started or no oscillator of the description was allocated. + if ((l1s.melody1.oscillator_started & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active) || + (l1s.melody1.oscillator_started == 0) ) + { + // Download the header of the next description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 1, + &l1s.melody1.melody_header); + + // Is it the end of the melody? + if (l1s.melody1.melody_header == 0x0000) + { + *state = M1_WAIT_END_MELO; + /* Header is wrong - L1 needs a forcible stop here */ +#if (CODE_VERSION == SIMULATION) + // l1a_l1s_com.melody1_task.command.stop = TRUE; +#else + l1a_l1s_com.melody1_task.command.stop = TRUE; +#endif + + } + else + { + // Initialize the counter with the next offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + } + } + break; + + case M1_WAIT_END_MELO: + { + if (l1a_l1s_com.melody1_task.command.stop) + { + // Initialize the oscillators used: + for (i=0; i<SC_NUMBER_OSCILLATOR; i++) + { + if (l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<i)) + *(l1s.melody1.oscillator[i]) = SC_END_OSCILLATOR_MASK; + } + + // Disable the loopback + l1a_l1s_com.melody1_task.parameters.loopback = FALSE; + + // Disable the stop command + l1a_l1s_com.melody1_task.command.stop = FALSE; + + *state = M1_WAIT_END_MELO; + } + else + // All oscillators used are stopped. + if (!( l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_active)) + { + // The melody is in loopback mode? + if (l1a_l1s_com.melody1_task.parameters.loopback) + { + // Reset the pointer to the buffer + #if (OP_RIV_AUDIO == 0) + l1s.melody1.ptr_buf = NULL; + #endif + l1s.melody1.buffer_size = 0; + l1s.melody1.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody1.ptr_buf, + &l1s.melody1.buffer_size, + l1a_l1s_com.melody1_task.parameters.session_id); + + // Download the 2 first words of the first description of the melody + l1s.melody1.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id, + &l1s.melody1.buffer_size, + (UWORD16 **)&l1s.melody1.ptr_buf, + 2, + (UWORD16 *)&melo_header); + + // Save the header of the first melody score description + l1s.melody1.melody_header = melo_header[1]; + + // Initialize the counter with the first offset time: + l1s.melody1.counter = ( ( Field(l1s.melody1.melody_header, SC_MELO_TIME_OFFSET_MASK, SC_MELO_TIME_OFFSET_SHIFT) ) * SC_MELO_DOWNLOAD_TIME_UNIT ) - 1; + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + else + { + // Disable the oscillator dedicated to this melody + l1s_dsp_com.dsp_ndb_ptr->d_melo_osc_used &= ~(l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap); +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY1_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = M1_INACTIVE; + } + } + } + break; + } // switch + } + #endif // MELODY_E1 + #if (VOICE_MEMO) + /*-------------------------------------------------------*/ + /* l1s_vm_play_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo playing L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_play_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_DSP_START = 2, + WAIT_DSP_REQUEST = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_PLAY_STATE]; + xSignalHeaderRec *conf_msg; + UWORD16 sample_header; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + // Triton Audio ON/OFF Changes + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo.play.ptr_buf = NULL; + l1s.voicememo.play.buffer_size = 0; + l1s.voicememo.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.play.ptr_buf, + &l1s.voicememo.play.buffer_size, + l1a_l1s_com.voicememo_task.play.parameters.session_id); + + // Start the voice memo playing DSP task + #if ((DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_START; + + // Determine which a_du buffer is currently used + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // Download the header of the new speech sample + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + 1, + &sample_header); + + // Download the data to the a_du_x buffer if the sample isn't a noise sample. + if (sample_header & B_VM_SPEECH) + { + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + SC_VM_SPEECH_SAMPLE-1, + l1s.voicememo.play.a_du_x+1); + } + // Send the header to the DSP + *l1s.voicememo.play.a_du_x = sample_header; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo.play.ptr_buf = NULL; + l1s.voicememo.play.buffer_size = 0; + l1s.voicememo.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.play.ptr_buf, + &l1s.voicememo.play.buffer_size, + l1a_l1s_com.voicememo_task.play.parameters.session_id); + + // Start the voice memo playing DSP task + #if (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_START; + + // Determine which a_du buffer is currently used + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // Download the header of the new speech sample + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + 1, + &sample_header); + + // Download the data to the a_du_x buffer if the sample isn't a noise sample. + if (sample_header & B_VM_SPEECH) + { + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + SC_VM_SPEECH_SAMPLE-1, + l1s.voicememo.play.a_du_x+1); + } + // Send the header to the DSP + *l1s.voicememo.play.a_du_x = sample_header; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_PLAY_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_PLAY_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_REQUEST; + } + } + break; + + case WAIT_DSP_REQUEST: + { + // The MMI requests to stop the voice memorization playing task + if (l1a_l1s_com.voicememo_task.play.command.stop) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block + { + // Determine which a_du buffer is currently used + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + if (!(*(l1s.voicememo.play.a_du_x) & B_BLOCK_READY)) + { + // Download the header of the new speech sample + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + 1, + &sample_header); + + // Is it the end of the voice memo data buffer? + if ( sample_header == SC_VM_END_MASK ) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + { + // Download the data to the a_du_x buffer if the sample isn't a noise sample. + if (sample_header & B_VM_SPEECH) + { + l1s.voicememo.play.error_id = copy_data_from_buffer (l1a_l1s_com.voicememo_task.play.parameters.session_id, + &l1s.voicememo.play.buffer_size, + (UWORD16 **)&l1s.voicememo.play.ptr_buf, + SC_VM_SPEECH_SAMPLE-1, + l1s.voicememo.play.a_du_x+1); + } + // Send the header to the DSP + *l1s.voicememo.play.a_du_x = sample_header; + } + } + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_PLAY_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_PLAY_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_vm_record_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo recoding L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_record_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif // L1_AUDIO_MCU_ONOFF + WAIT_DSP_START = 2, + WAIT_DSP_SAMPLE = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_RECORD_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 size; + UWORD16 data; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo.record.ptr_buf = NULL; + l1s.voicememo.record.buffer_size = 0; + l1s.voicememo.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.record.ptr_buf, + &l1s.voicememo.record.buffer_size, + l1a_l1s_com.voicememo_task.record.parameters.session_id); + + // Initialize the size of the Voice memo to record + l1s.voicememo.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + #if ((DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_START; + + *state = WAIT_DSP_START; + +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo.record.ptr_buf = NULL; + l1s.voicememo.record.buffer_size = 0; + l1s.voicememo.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo.record.ptr_buf, + &l1s.voicememo.record.buffer_size, + l1a_l1s_com.voicememo_task.record.parameters.session_id); + + // Initialize the size of the Voice memo to record + l1s.voicememo.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + #if (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_RECORD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_SAMPLE; + } + } + break; + + case WAIT_DSP_SAMPLE: + { + // The MMI requests to stop the voice memorization recording task + if (l1a_l1s_com.voicememo_task.record.command.stop) + { + // Write the end mask at the end of the voice data RAM buffer + data = SC_VM_END_MASK; + l1s.voicememo.record.error_id = copy_data_to_buffer (l1a_l1s_com.voicememo_task.record.parameters.session_id, + &l1s.voicememo.record.buffer_size, + (UWORD16 **)&l1s.voicememo.record.ptr_buf, + 1, + &data); + + // Increase the recorded size + l1s.voicememo.record.recorded_size++; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + // Clear the a_du_x header: + *(l1s.voicememo.record.a_du_x) = 0; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block + { + // Determine which a_du buffer is currently used + l1s.voicememo.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // The DSP sends a new block? + if ( (*(l1s.voicememo.record.a_du_x)) & B_BLOCK_READY ) + { + // Check if the block contains a sample of noise or speech + if ( (*(l1s.voicememo.record.a_du_x)) & B_VM_SPEECH ) + size = SC_VM_SPEECH_SAMPLE; + else + size = SC_VM_NOISE_SAMPLE; + + // The maximum allocated size is reached? + if ( (l1s.voicememo.record.recorded_size+size+1) <= l1a_l1s_com.voicememo_task.record.parameters.maximum_size) + { + // Download the data to the a_du_x buffer. + l1s.voicememo.record.error_id = copy_data_to_buffer (l1a_l1s_com.voicememo_task.record.parameters.session_id, + &l1s.voicememo.record.buffer_size, + (UWORD16 **)&l1s.voicememo.record.ptr_buf, + size, + l1s.voicememo.record.a_du_x); + + // Increase the recorded size + l1s.voicememo.record.recorded_size += size; + + // Clear the a_du_x header: + *(l1s.voicememo.record.a_du_x) = 0; + } + else + { + // Write the end mask at the end of the voice data RAM buffer + data = SC_VM_END_MASK; + l1s.voicememo.record.error_id = copy_data_to_buffer (l1a_l1s_com.voicememo_task.record.parameters.session_id, + &l1s.voicememo.record.buffer_size, + (UWORD16 **)&l1s.voicememo.record.ptr_buf, + 1, + &data); + + // Increase the recorded size + l1s.voicememo.record.recorded_size++; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + // Clear the a_du_x header: + *(l1s.voicememo.record.a_du_x) = 0; + + *state = WAIT_DSP_STOP; + } + } + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_VM_RECORD_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_RECORD_STOP_CON; + //Fill the message + ((T_L1_VM_RECORD_CON *)(conf_msg->SigP))->recorded_size = l1s.voicememo.record.recorded_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_tone_ul_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : tone uplink L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_tone_ul_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_DEDIC_SPEECH_MODE = 2, + WAIT_TONE_UL_START = 3, + WAIT_TONE_UL_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_TONE_UL_STATE]; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Start the tone uplink task + if (l1a_l1s_com.voicememo_task.record.tone_ul.start) + { + // Set the tone uplink option: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_TONE_UL; + } + + *state = WAIT_DEDIC_SPEECH_MODE; +#endif + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Start the tone uplink task + if (l1a_l1s_com.voicememo_task.record.tone_ul.start) + { + // Set the tone uplink option: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_TONE_UL; + } + + *state = WAIT_DEDIC_SPEECH_MODE; + } + } + break; +#endif // (L1_AUDIO_MCU_ONOFF == 1) + + case WAIT_DEDIC_SPEECH_MODE: + { + // The voice memorization task is stopping: + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_VM_TONE_UL)) + { + // Reset the start command + l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE; +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + *state = IDLE; + } + else + // Dedicated mode speech start? + if (l1a_l1s_com.dedic_set.aset != NULL) + { + #if (AMR == 1) + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_HS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_EFR_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_FS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_AFS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_AHS_MODE) ) + #else + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_HS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_EFR_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_FS_MODE) ) + #endif + { + + // Start the tone uplink DSP task + #if ((DSP==33) || (DSP == 34) || (DSP==35) || (DSP==36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // Linked to E2 melody + // In case of WCP, there is a WCP variable at this address + l1s_dsp_com.dsp_ndb_ptr->d_melody_selection = NO_MELODY_SELECTED; + #endif + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init &= ~(B_MELO); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; + + *state = WAIT_TONE_UL_START; + } + } + } + break; + + case WAIT_TONE_UL_START: + { + // the tone uplink task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE) + { + *state = WAIT_TONE_UL_STOP; + } + } + break; + + case WAIT_TONE_UL_STOP: + { + // The voice memorization task is stopping: + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_VM_TONE_UL)) + { + // Stop the tone uplink task: + l1s_dsp_com.dsp_ndb_ptr->d_pe_rep = 0; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_TONE; +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + *state = IDLE; + } + else + // The tone uplink task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_TONE)) + { +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + *state = IDLE; + } + } + break; + } // switch + } + + #endif // VOICE_MEMO + + #if (L1_PCM_EXTRACTION) + /*-------------------------------------------------------*/ + /* l1s_pcm_download_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : PCM download L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_pcm_download_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_DSP_START = 2, + WAIT_DSP_REQUEST = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_PCM_DOWNLOAD_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { +#if (L1_AUDIO_MCU_ONOFF == 1) + // Triton Audio ON/OFF Changes + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.pcm.download.ptr_buf = NULL; + l1s.pcm.download.buffer_size = 0; + l1s.pcm.download.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.download.ptr_buf, + &l1s.pcm.download.buffer_size, + l1a_l1s_com.pcm_task.download.parameters.session_id); + + // Download the PCM samples + l1s.pcm.download.error_id = copy_data_from_buffer (l1a_l1s_com.pcm_task.download.parameters.session_id, + &l1s.pcm.download.buffer_size, + (UWORD16 **)&l1s.pcm.download.ptr_buf, + SC_PCM_DOWNLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_download); + + // Increase the downloaded size of PCM samples + l1s.pcm.download.downloaded_size = SC_PCM_DOWNLOAD_SAMPLE; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= (B_PCM_DOWNLOAD_READY); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the buffer parameters + l1s.pcm.download.ptr_buf = NULL; + l1s.pcm.download.buffer_size = 0; + l1s.pcm.download.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.download.ptr_buf, + &l1s.pcm.download.buffer_size, + l1a_l1s_com.pcm_task.download.parameters.session_id); + + // Download the PCM samples + l1s.pcm.download.error_id = copy_data_from_buffer (l1a_l1s_com.pcm_task.download.parameters.session_id, + &l1s.pcm.download.buffer_size, + (UWORD16 **)&l1s.pcm.download.ptr_buf, + SC_PCM_DOWNLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_download); + + // Increase the downloaded size of PCM samples + l1s.pcm.download.downloaded_size = SC_PCM_DOWNLOAD_SAMPLE; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= (B_PCM_DOWNLOAD_READY); + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_DOWNLOAD_ON_GOING) + { + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_DOWNLOAD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_REQUEST; + } + } + break; + + case WAIT_DSP_REQUEST: + { + if (l1a_l1s_com.pcm_task.download.command.stop) + { + // Stop the DSP PCM playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = 0; + *state = WAIT_DSP_STOP; + } + else + { + // B_PCM_DOWNLOAD_READY is reset if DSP is ready to get new sample + if (!(l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download & B_PCM_DOWNLOAD_READY)) + { + + if(l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_error & B_PCM_DOWNLOAD_ERROR) + { + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_PCM_DSP_error(); + #endif + } /* end if DSP error check - underflow */ + + if ((l1s.pcm.download.downloaded_size + SC_PCM_DOWNLOAD_SAMPLE) <= + l1a_l1s_com.pcm_task.download.parameters.maximum_size) + { + + // Download the data to the a_pcm_api_download buffer + l1s.pcm.download.error_id = copy_data_from_buffer (l1a_l1s_com.pcm_task.download.parameters.session_id, + &l1s.pcm.download.buffer_size, + (UWORD16 **)&l1s.pcm.download.ptr_buf, + SC_PCM_DOWNLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_download); + // Increase the downloaded size + l1s.pcm.download.downloaded_size += SC_PCM_DOWNLOAD_SAMPLE; + + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |= (B_PCM_DOWNLOAD_READY); + } /* end if download speech sample*/ + else + { + // Stop the DSP PCM playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_DOWNLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = 0; + *state = WAIT_DSP_STOP; + } /* end else - download buffer size reached */ + } /* end if DSP requested new block */ + } /* end else not download task stop command */ + } + break; + + case WAIT_DSP_STOP: + { + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_DOWNLOAD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_DOWNLOAD_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_pcm_upload_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : PCM uploading manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_pcm_upload_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif // L1_AUDIO_MCU_ONOFF + WAIT_DSP_START = 2, + WAIT_DSP_SAMPLE = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_PCM_UPLOAD_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.pcm.upload.ptr_buf = NULL; + l1s.pcm.upload.buffer_size = 0; + l1s.pcm.upload.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.upload.ptr_buf, + &l1s.pcm.upload.buffer_size, + l1a_l1s_com.pcm_task.upload.parameters.session_id); + + // Initialize the size of the PCM upload + l1s.pcm.upload.uploaded_size = 0; + + // Start the PCM recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + // Initialize the buffer parameters + l1s.pcm.upload.ptr_buf = NULL; + l1s.pcm.upload.buffer_size = 0; + l1s.pcm.upload.error_id = Cust_get_pointer((UWORD16 **)&l1s.pcm.upload.ptr_buf, + &l1s.pcm.upload.buffer_size, + l1a_l1s_com.pcm_task.upload.parameters.session_id); + + // Initialize the size of the PCM upload + l1s.pcm.upload.uploaded_size = 0; + + // Start the PCM recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_UPLOAD_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_UPLOAD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_SAMPLE; + } + } + break; + + case WAIT_DSP_SAMPLE: + { + // The MMI requests to stop the PCM recording task + if (l1a_l1s_com.pcm_task.upload.command.stop) + { + // Stop the DSP PCM recording task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = 0; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block + { + + // The DSP sends a new block? + if (l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload & B_PCM_UPLOAD_READY ) + { + + if(l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_error & B_PCM_UPLOAD_ERROR) + { + #if (TRACE_TYPE==1) || (TRACE_TYPE==4) + l1_trace_PCM_DSP_error(); + #endif + } /* end if DSP error check - overflow */ + + if ((l1s.pcm.upload.uploaded_size + SC_PCM_UPLOAD_SAMPLE) <= l1a_l1s_com.pcm_task.upload.parameters.maximum_size) + { + // Download the data to the a_pcm_api_upload buffer. + + l1s.pcm.upload.error_id = copy_data_to_buffer (l1a_l1s_com.pcm_task.upload.parameters.session_id, + &l1s.pcm.upload.buffer_size, + (UWORD16 **)&l1s.pcm.upload.ptr_buf, + SC_PCM_UPLOAD_SAMPLE, + l1s_dsp_com.dsp_ndb_ptr->a_pcm_api_upload); + + // Increase the recorded size + l1s.pcm.upload.uploaded_size += SC_PCM_UPLOAD_SAMPLE; + + // Clear the d_pcm_api_upload header + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload &= (~B_PCM_UPLOAD_READY); + } + else + { + // Stop the DSP PCM recording task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_PCM_UPLOAD_STOP; + l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = 0; + + *state = WAIT_DSP_STOP; + } /* end else maximum uplaod size reached */ + } /* end if DSP sends a new block */ + } /* end else */ + } + break; + + case WAIT_DSP_STOP: + { + // The DSP PCM upload task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_PCM_UPLOAD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_PCM_UPLOAD_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_PCM_UPLOAD_STOP_CON; + //Fill the message + ((T_L1_PCM_UPLOAD_STOP_CON *)(conf_msg->SigP))->uploaded_size = l1s.pcm.upload.uploaded_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + #endif /* L1_PCM_EXTRACTION */ + + #if (L1_VOICE_MEMO_AMR) + /*-------------------------------------------------------*/ + /* l1s_vm_amr_play_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo amr playing L1S manager task.*/ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_amr_play_manager(void) + { + BOOL l1_vm_amr_in_pause=FALSE; + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_DSP_START = 2, + WAIT_DSP_REQUEST = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_AMR_PLAY_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 sample_header; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo_amr.play.ptr_buf = NULL; + l1s.voicememo_amr.play.buffer_size = 0; + l1s.voicememo_amr.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.play.ptr_buf, + &l1s.voicememo_amr.play.buffer_size, + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.play.buffer_size <<= 1; + + // Initialize previous sample parameters in order to create ONSET on first SAMPLE + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NO_DATA; + l1s.voicememo_amr.play.transition_header = 0; + + // Initialize a_du_x + // Determine which a_du buffer is currently used + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.play.a_du_x) = 0; + + // Start the voice memo playing DSP task + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + +#if (L1_AUDIO_MCU_ONOFF == 1) + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo_amr.play.ptr_buf = NULL; + l1s.voicememo_amr.play.buffer_size = 0; + l1s.voicememo_amr.play.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.play.ptr_buf, + &l1s.voicememo_amr.play.buffer_size, + l1a_l1s_com.voicememo_amr_task.play.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.play.buffer_size <<= 1; + + // Initialize previous sample parameters in order to create ONSET on first SAMPLE + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NO_DATA; + l1s.voicememo_amr.play.transition_header = 0; + + // Initialize a_du_x + // Determine which a_du buffer is currently used + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.play.a_du_x) = 0; + + // Start the voice memo playing DSP task + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_START; + + *state = WAIT_DSP_START; + } + } + break; +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_PLAY_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_PLAY_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_REQUEST; + } + } + break; + + case WAIT_DSP_REQUEST: + { + // The MMI requests to stop the voice memorization playing task + if (l1a_l1s_com.voicememo_amr_task.play.command.stop) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP needs a new block ? + { + if (l1a_l1s_com.voicememo_amr_task.play.command.pause) + { + // Stop the DSP voice memorization playing task + *(l1s.voicememo_amr.play.a_du_x) =*(l1s.voicememo_amr.play.a_du_x) | B_BLOCK_READY; + l1_vm_amr_in_pause= TRUE; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_PAUSE_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + // *state =WAIT_DSP_REQUEST; + + } + if (l1a_l1s_com.voicememo_amr_task.play.command.resume) + { + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_RESUME_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + } + // Determine which a_du buffer is currently used + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.play.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // B_BLOCK_READY is not set if DSP is ready to get new sample + if (!(*(l1s.voicememo_amr.play.a_du_x) & B_BLOCK_READY)) + { + // Issue: transition from not speech sample to speech sample requires creation of transition ONSET sample + storing temporarily speech header + // We use it on next DSP request => when previous sample was ONSET, header must be taken from transition_header + if (l1s.voicememo_amr.play.previous_type == SC_VM_AMR_ONSET) + { + // we use speech header temprarily stored in transition_header + sample_header = l1s.voicememo_amr.play.transition_header; + } + else + { + // Download the header of the new sample + l1s.voicememo_amr.play.error_id = copy_byte_data_from_buffer (l1a_l1s_com.voicememo_amr_task.play.parameters.session_id, + &l1s.voicememo_amr.play.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.play.ptr_buf, + 1, + &sample_header); + } + + // Is it the end of the voice memo data buffer? + if ( sample_header == SC_VM_AMR_END_MASK ) + { + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_PLAY_STOP; + + *state = WAIT_DSP_STOP; + } + else + { + UWORD8 temp_header =0; //omaps00090550 + UWORD8 data_size =0; //omaps00090550 + + // Identify AMR sample RX_TX_TYPE + temp_header = sample_header & SC_RX_TX_TYPE_MASK; + switch(temp_header) + { + case SC_VM_AMR_RXTX_SPEECH_GOOD: + case SC_VM_AMR_RXTX_SPEECH_BAD: + { + // Check if previous sample is a non speech sample so we have to create ONSET sample + if ( (l1s.voicememo_amr.play.previous_type == SC_VM_AMR_NOISE)||(l1s.voicememo_amr.play.previous_type == SC_VM_AMR_NO_DATA) ) + { + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_ONSET; + l1s.voicememo_amr.play.transition_header = sample_header; + sample_header = SC_VM_AMR_RXTX_ONSET; + data_size = SC_VM_AMR_ONSET_DATA_SIZE; + } + else + { + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_SPEECH; + + // read channel type to know which vocoder is used (and size of data bits) + temp_header = sample_header & SC_CHAN_TYPE_MASK; + switch(temp_header) + { + case SC_VM_AMR_SPEECH_475: + data_size = SC_VM_AMR_SPEECH_475_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_515: + data_size = SC_VM_AMR_SPEECH_515_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_59: + data_size = SC_VM_AMR_SPEECH_59_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_67: + data_size = SC_VM_AMR_SPEECH_67_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_74: + data_size = SC_VM_AMR_SPEECH_74_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_795: + data_size = SC_VM_AMR_SPEECH_795_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_102: + data_size = SC_VM_AMR_SPEECH_102_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_122: + data_size = SC_VM_AMR_SPEECH_122_DATA_SIZE; + break; + } // switch(temp_header) + } + } + break; + case SC_VM_AMR_RXTX_SID_FIRST: + data_size = SC_VM_AMR_SID_FIRST_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NOISE; + break; + case SC_VM_AMR_RXTX_SID_UPDATE: + data_size = SC_VM_AMR_SID_UPDATE_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NOISE; + break; + case SC_VM_AMR_RXTX_SID_BAD: + data_size = SC_VM_AMR_SID_BAD_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NOISE; + break; + case SC_VM_AMR_RXTX_NO_DATA: + data_size = SC_VM_AMR_NO_DATA_DATA_SIZE; + l1s.voicememo_amr.play.previous_type = SC_VM_AMR_NO_DATA; + break; + default: + // trace error + break; + } + + // if data_size is 0 (SID_FIRST, NO_DATA and ONSET), nothing to copy + if (data_size > 0) + { + // go beyond the 2 DSP words after the header, which are not used in MMS (so a_du_x + 3 in words) + l1s.voicememo_amr.play.error_id = copy_byte_data_le_from_buffer (l1a_l1s_com.voicememo_amr_task.play.parameters.session_id, + &l1s.voicememo_amr.play.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.play.ptr_buf, + data_size, + l1s.voicememo_amr.play.a_du_x + 3); + } + // Send the header to the DSP + *l1s.voicememo_amr.play.a_du_x = (sample_header | B_BLOCK_READY); + } + } + if(l1_vm_amr_in_pause==TRUE) + { + (*(l1s.voicememo_amr.play.a_du_x) = *(l1s.voicememo_amr.play.a_du_x) & ~B_BLOCK_READY); + l1_vm_amr_in_pause=FALSE; + } + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_PLAY_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_PLAY_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_vm_amr_record_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Voice memo amr recoding L1S manager task*/ + /* */ + /*-------------------------------------------------------*/ + void l1s_vm_amr_record_manager(void) + { + enum states + { + IDLE = 0, +#if (L1_AUDIO_MCU_ONOFF == 1) + WAIT_AUDIO_ON = 1, +#endif + WAIT_DSP_START = 2, + WAIT_DSP_SAMPLE = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_VM_AMR_RECORD_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 sample_header; + + switch(*state) + { + case IDLE: + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + *state = WAIT_AUDIO_ON; +#else + // Initialize the buffer parameters + l1s.voicememo_amr.record.ptr_buf = NULL; + l1s.voicememo_amr.record.buffer_size = 0; + l1s.voicememo_amr.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.record.ptr_buf, + &l1s.voicememo_amr.record.buffer_size, + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.record.buffer_size <<= 1; + + // Initialize the size of the Voice memo to record + l1s.voicememo_amr.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_amr_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + // Select AMR vocoder and specified channel type + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; // AMR voice memo + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc &= ~(SC_CHAN_TYPE_MASK); + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc |= l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder; + + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.record.a_du_x) = 0; + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_START; + + *state = WAIT_DSP_START; +#endif // L1_AUDIO_MCU_ONOFF + } + break; + +#if (L1_AUDIO_MCU_ONOFF == 1) + + case WAIT_AUDIO_ON: + { + // Triton Audio ON/OFF Changes + if((l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + // Initialize the buffer parameters + l1s.voicememo_amr.record.ptr_buf = NULL; + l1s.voicememo_amr.record.buffer_size = 0; + l1s.voicememo_amr.record.error_id = Cust_get_pointer((UWORD16 **)&l1s.voicememo_amr.record.ptr_buf, + &l1s.voicememo_amr.record.buffer_size, + l1a_l1s_com.voicememo_amr_task.record.parameters.session_id); + + // Convert the buffer size in bytes unit because VM AMR is defined in byte unit + l1s.voicememo_amr.record.buffer_size <<= 1; + + // Initialize the size of the Voice memo to record + l1s.voicememo_amr.record.recorded_size = 0; + + // Initialize the DTX mode + if (l1a_l1s_com.voicememo_amr_task.record.parameters.dtx) + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VOICE_MEMO_DTX; + else + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + + // Select AMR vocoder and specified channel type + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode |= B_VM_VOCODER_SELECT; // AMR voice memo + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc &= ~(SC_CHAN_TYPE_MASK); + l1s_dsp_com.dsp_ndb_ptr->d_amms_ul_voc |= l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder; + + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + *(l1s.voicememo_amr.record.a_du_x) = 0; + + // Start the voice memo recording DSP task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_START; + + *state = WAIT_DSP_START; + } + } + break; + +#endif // L1_AUDIO_MCU_ONOFF + + case WAIT_DSP_START: + { + // The DSP task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_RECORD_ON_GOING) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_RECORD_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_SAMPLE; + } + } // case WAIT_DSP_START: + break; + + case WAIT_DSP_SAMPLE: + { + // The MMI requests to stop the voice memorization recording task + if (l1a_l1s_com.voicememo_amr_task.record.command.stop) + { + // Write the end mask at the end of the voice data RAM buffer + sample_header = SC_VM_AMR_END_MASK; + l1s.voicememo_amr.record.error_id = copy_byte_data_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + 1, + &sample_header); + + // Increase the recorded size + l1s.voicememo_amr.record.recorded_size++; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } // if (l1a_l1s_com.voicememo_amr_task.record.command.stop) + else + // The DSP sends a new block ? + { + // Determine which a_du buffer is currently used + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.voicememo_amr.record.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // The DSP sends a new block? + if ( (*(l1s.voicememo_amr.record.a_du_x)) & B_BLOCK_READY ) + { + UWORD8 sample_header, temp_header; + UWORD8 data_size=0 ;//omaps00090550; + + // get RX_TYPE to identify frame (SPEECH_GOOD, SID_FIRST, SID_UPDATE, NO_DATA) + sample_header = (*l1s.voicememo_amr.record.a_du_x & 0x00FF); + temp_header = sample_header & SC_RX_TX_TYPE_MASK; + + // Check if the block contains speech or SID or NO_DATA + switch(temp_header) + { + case SC_VM_AMR_RXTX_SPEECH_GOOD: + { + temp_header = sample_header & SC_CHAN_TYPE_MASK; + switch(temp_header) + { + case SC_VM_AMR_SPEECH_475: + data_size = SC_VM_AMR_SPEECH_475_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_515: + data_size = SC_VM_AMR_SPEECH_515_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_59: + data_size = SC_VM_AMR_SPEECH_59_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_67: + data_size = SC_VM_AMR_SPEECH_67_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_74: + data_size = SC_VM_AMR_SPEECH_74_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_795: + data_size = SC_VM_AMR_SPEECH_795_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_102: + data_size = SC_VM_AMR_SPEECH_102_DATA_SIZE; + break; + case SC_VM_AMR_SPEECH_122: + data_size = SC_VM_AMR_SPEECH_122_DATA_SIZE; + break; + } + } // case SC_VM_AMR_RXTX_SPEECH_GOOD: + break; + case SC_VM_AMR_RXTX_SID_FIRST: + data_size = SC_VM_AMR_SID_FIRST_DATA_SIZE; + break; + case SC_VM_AMR_RXTX_SID_UPDATE: + data_size = SC_VM_AMR_SID_UPDATE_DATA_SIZE; + break; + case SC_VM_AMR_RXTX_NO_DATA: + data_size = SC_VM_AMR_NO_DATA_DATA_SIZE; + break; + default: + // trace error + break; + } // switch(temp_header) + + // The maximum allocated size is reached? (need to be able to store header + data + end_mask) + if ( (l1s.voicememo_amr.record.recorded_size+data_size+SC_VM_AMR_HEADER_SIZE+SC_VM_AMR_END_MASK_SIZE) <= l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size) + { + // Download the header from the a_du_x buffer. + l1s.voicememo_amr.record.error_id = copy_byte_data_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + 1, + &sample_header); + + if (data_size > 0) + { + l1s.voicememo_amr.record.error_id = copy_byte_data_le_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + data_size, + l1s.voicememo_amr.record.a_du_x + 3); + } + + // Increase the recorded size (header + data_bits) + l1s.voicememo_amr.record.recorded_size += data_size + SC_VM_AMR_HEADER_SIZE; + + // Clear the a_du_x header: + *(l1s.voicememo_amr.record.a_du_x) = 0; + } + else + { + // Write the end mask at the end of the voice data RAM buffer + sample_header = SC_VM_AMR_END_MASK; + l1s.voicememo_amr.record.error_id = copy_byte_data_to_buffer (l1a_l1s_com.voicememo_amr_task.record.parameters.session_id, + &l1s.voicememo_amr.record.buffer_size, + (UWORD8 **)&l1s.voicememo_amr.record.ptr_buf, + 1, + &sample_header); + + // Increase the recorded size + l1s.voicememo_amr.record.recorded_size++; + + // Clear the a_du_x header: + *(l1s.voicememo_amr.record.a_du_x) = 0; + + // Stop the DSP voice memorization playing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_AMR_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } + } + } // else of if (l1a_l1s_com.voicememo_amr_task.record.command.stop) + } + break; + + case WAIT_DSP_STOP: + { + // The DSP voice memorization playing task is stopped + if (!(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_AMR_RECORD_ON_GOING)) + { + // Triton Audio ON/OFF Changes +#if (L1_AUDIO_MCU_ONOFF == 1) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; +#endif // L1_AUDIO_MCU_ONOFF + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_VM_AMR_RECORD_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_VM_AMR_RECORD_STOP_CON; + //Fill the message + ((T_L1_VM_AMR_RECORD_CON *)(conf_msg->SigP))->recorded_size = l1s.voicememo_amr.record.recorded_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch(*state) + } + + #endif // L1_VOICE_MEMO_AMR + + #if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* l1s_sr_enroll_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition enroll */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_enroll_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_ACQUISITION_STATUS = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_ENROLL_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the watchdog timer with the time to acquire a word + l1s.speechreco.time_out = SC_SR_AQUISITION_TIME_OUT; + + // Start the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_ENROLL; + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP enroll task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_ENROLL_TASK) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_ENROLL_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_ACQUISITION_STATUS; + } + } + break; + + case WAIT_ACQUISITION_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP enroll task ran bad or the MMI stop the enroll task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.enroll_stop) ) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_ACQUISITION; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP enroll task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // No error + l1s.speechreco.error = SC_NO_ERROR; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP enroll task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & (B_SR_ENROLL_TASK | B_VM_RECORD_ON_GOING)) ) + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_ENROLL_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_ENROLL_STOP_CON; + //Fill the message + ((T_L1_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_update_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition update */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_update_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_ACQUISITION_STATUS = 2, + WAIT_UPDATE_STATUS = 3, + WAIT_DSP_STOP = 4 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_UPDATE_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the watchdog timer with the time to acquire a word + l1s.speechreco.time_out = SC_SR_AQUISITION_TIME_OUT; + + // Start the DSP update task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_UPDATE; + + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_UPD) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable |= (1 << C_BGD_ALIGN); + } + #endif + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP update task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_UPDATE_TASK) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_UPDATE_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_ACQUISITION_STATUS; + } + } + break; + + case WAIT_ACQUISITION_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP acquisition task ran bad or the MMI stop the update task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.update_stop) ) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_ACQUISITION; + + // Stop the DSP acquisition task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP enroll task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // Initialize the watchdog timer with the time to update a word + l1s.speechreco.time_out = SC_SR_UPDATE_TIME_OUT; + + *state = WAIT_UPDATE_STATUS; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP acquisition task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + + case WAIT_UPDATE_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP update task ran bad or the MMI stop the update task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_UPDATE) || + (l1a_l1s_com.speechreco_task.command.update_stop) ) + { + // Error: bad update + l1s.speechreco.error = SC_BAD_UPDATE; + + // Stop the DSP update task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP update task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_UPDATE) + { + // No error: + l1s.speechreco.error = SC_NO_ERROR; + + // Stop the DSP update task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP enroll task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP enroll task is stopped + if ( !( l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & (B_SR_UPDATE_TASK | B_SR_ALIGNMENT_TASK | B_VM_RECORD_ON_GOING) ) ) + { + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_UPD) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_ALIGN); + } + #endif + + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_UPDATE_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_UPDATE_STOP_CON; + //Fill the message + ((T_L1_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_reco_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition reco acquisition */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_reco_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_ACQUISITION_STATUS = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_RECO_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the watchdog timer with the time to acquire a word + l1s.speechreco.time_out = SC_SR_AQUISITION_TIME_OUT; + + // Start the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_RECO; + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP reco task is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_RECO_TASK) + { + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_ACQUISITION_STATUS; + } + } + break; + + case WAIT_ACQUISITION_STATUS: + { + // the allowed time isn't out + if (l1s.speechreco.time_out--) + { + // The DSP acquisition reco task ran bad or the MMI stop the acquisition reco task + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.reco_stop) ) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_ACQUISITION; + + // Stop the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP enroll task ran good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // No error + l1s.speechreco.error = SC_NO_ERROR; + + // Stop the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + else + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP acquisition reco task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP enroll task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_RECO_TASK) ) + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_RECO_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_STOP_CON; + //Fill the message + ((T_L1_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_processing_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition reco processing */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_processing_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_PROCESSING_STOP = 1, + WAIT_DSP_RESULT = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_PROCESSING_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // Disable the DSP bit exact test + l1s_dsp_com.dsp_ndb_ptr->d_sr_bit_exact_test &= 0xff80; + + // Initialize the OOV algorithm + l1s_dsp_com.dsp_ndb_ptr->d_sr_param &= 0x20; + l1s_dsp_com.dsp_ndb_ptr->d_sr_param |= SC_SR_OOV_SFT_THR; + + // Transmit ot the DSP the number of word to compare + l1s_dsp_com.dsp_ndb_ptr->d_sr_nb_words = l1a_l1s_com.speechreco_task.parameters.vocabulary_size; + + // Initialize the watchdog timer with the time to process a word + l1s.speechreco.time_out = SC_SR_PROCESSING_TIME_OUT; + + // Start the DSP processing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_PROCESSING; + + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_RECO) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable |= (1 << C_BGD_RECOGN); + } + #endif + + // Reset the start command + l1a_l1s_com.speechreco_task.command.processing_start = FALSE; + + *state = WAIT_DSP_PROCESSING_STOP; + } + break; + + case WAIT_DSP_PROCESSING_STOP: + { + if (l1s.speechreco.time_out--) + { + // The MMI stops the processing task + if (l1a_l1s_com.speechreco_task.command.processing_stop) + { + // Error: bad acquisition + l1s.speechreco.error = SC_BAD_RECOGNITION; + + // Stop the DSP processing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP processing task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_PROCESSING_TASK) ) + { + // It was the last model + if (l1a_l1s_com.speechreco_task.parameters.index_counter == l1a_l1s_com.speechreco_task.parameters.vocabulary_size) + { + *state = WAIT_DSP_RESULT; + } + else + { + // Send the stop confirmation message with no error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_PROCESSING_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_PROCESSING_STOP_CON; + //Fill the message + ((T_L1_SR_PROCESSING_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + } + else + // the allowed time is out + { + // Error: time is out + l1s.speechreco.error = SC_TIME_OUT; + + // Stop the DSP processing task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_SR_STOP; + + *state = WAIT_DSP_STOP; + } + } + break; + + case WAIT_DSP_RESULT: + { + + #if (W_A_DSP_SR_BGD) + // Management of DSP tasks in background + if (l1s_dsp_com.dsp_param_ptr->d_gsm_bgd_mgt & B_DSPBGD_RECO) + { + l1s_dsp_com.dsp_ndb_ptr->d_background_enable &= ~(1 << C_BGD_RECOGN); + } + #endif + + // The DSP recognition task was bad + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) + { + // Send the stop indication message with an bad recognition error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_RECO_STOP_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_STOP_IND; + //Fill the message + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + else + // The DSP recognition task was good: + { + // Send the stop indication message without any error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_RECO_STOP_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_RECO_STOP_IND; + //Fill the message + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->error_id = SC_NO_ERROR; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[0]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[0] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[1] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->second_best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[1]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->second_best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[2] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[3] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->third_best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[2]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->third_best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[4] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[5] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->fourth_best_word_index = l1s_dsp_com.dsp_ndb_ptr->a_n_best_words[3]; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->fourth_best_word_score = l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[6] | (l1s_dsp_com.dsp_ndb_ptr->a_n_best_score[7] << 16); + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->d_sr_db_level = l1s_dsp_com.dsp_ndb_ptr->d_sr_db_level; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->d_sr_db_noise = l1s_dsp_com.dsp_ndb_ptr->d_sr_db_noise; + ((T_L1_SR_RECO_STOP_IND *)(conf_msg->SigP))->d_sr_model_size = l1s_dsp_com.dsp_ndb_ptr->d_sr_mod_size; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP processing task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_SR_PROCESSING_TASK) ) + { + // Send the stop confirmation message with an error + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_SR_PROCESSING_STOP_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_SR_PROCESSING_STOP_CON; + //Fill the message + ((T_L1_SR_PROCESSING_STOP_CON *)(conf_msg->SigP))->error_id = l1s.speechreco.error; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + + /*-------------------------------------------------------*/ + /* l1s_sr_speech_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : speech recognition speech recording */ + /* L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_sr_speech_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_START = 1, + WAIT_DSP_SAMPLE = 2, + WAIT_DSP_STOP = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_SR_SPEECH_STATE]; + API *a_du_x; + UWORD8 i; + + switch(*state) + { + case IDLE: + { + // Initialize the current pointer + l1s.speechreco.speech_pointer = l1a_l1s_com.speechreco_task.parameters.speech_address; + l1s.speechreco.end_pointer = (UWORD16 *)(l1s.speechreco.speech_pointer + SC_SR_MMI_2_L1_SPEECH_SIZE); + + // Initialize the flag to know if it's the first pass in the circular buffer + l1s.speechreco.first_pass = TRUE; + + // Initialize the status register + l1s_dsp_com.dsp_ndb_ptr->d_sr_status = 0; + + // No DTX mode + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VOICE_MEMO_DTX); + #if ((DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) + // use TCH/FS vocoder + l1s_dsp_com.dsp_ndb_ptr->d_tch_mode &= ~(B_VM_VOCODER_SELECT); + #endif + + + // Start the voice memo recodgin DSP task: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_START; + + *state = WAIT_DSP_START; + } + break; + + case WAIT_DSP_START: + { + // The DSP is started + if (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING) + { + *state = WAIT_DSP_SAMPLE; + } + } + break; + + case WAIT_DSP_SAMPLE: + { + // A beginning of word is detected + if ( ((l1s_dsp_com.dsp_ndb_ptr->d_sr_status & SC_SR_WORD_MASK) == SC_SR_WORD_BEGINNING) && + (l1s.speechreco.speech_old_status == SC_SR_WORD_SEARCHING) ) + { + // Calculate the address of the beginning of the word + l1a_l1s_com.speechreco_task.parameters.start_address = + l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_BEGIN_VAD_LATENCY + SC_SR_SPEECH_WORD_BEGIN_MARGIN) * SC_SR_SPEECH_FRAME_SIZE); + if (l1a_l1s_com.speechreco_task.parameters.start_address < l1a_l1s_com.speechreco_task.parameters.speech_address) + { + if (l1s.speechreco.first_pass == FALSE) + { + l1a_l1s_com.speechreco_task.parameters.start_address = l1s.speechreco.end_pointer - + ( l1a_l1s_com.speechreco_task.parameters.speech_address - (l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_BEGIN_VAD_LATENCY + SC_SR_SPEECH_WORD_BEGIN_MARGIN) * SC_SR_SPEECH_FRAME_SIZE)) ); + } + else + { + l1a_l1s_com.speechreco_task.parameters.start_address = l1a_l1s_com.speechreco_task.parameters.speech_address; + } + } + } + else + // A end of word is detected + if ( ((l1s_dsp_com.dsp_ndb_ptr->d_sr_status & SC_SR_WORD_MASK) == SC_SR_WORD_ENDING) && + (l1s.speechreco.speech_old_status == SC_SR_WORD_ON_GOING) ) + { + // Calculate the address of the end of the word + l1a_l1s_com.speechreco_task.parameters.stop_address = + l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_END_VAD_LATENCY - SC_SR_SPEECH_WORD_END_MARGIN)* SC_SR_SPEECH_FRAME_SIZE); + if (l1a_l1s_com.speechreco_task.parameters.stop_address < l1a_l1s_com.speechreco_task.parameters.speech_address) + { + l1a_l1s_com.speechreco_task.parameters.stop_address = l1s.speechreco.end_pointer - + ( l1a_l1s_com.speechreco_task.parameters.speech_address - (l1s.speechreco.speech_pointer - ((SC_SR_SPEECH_WORD_END_VAD_LATENCY - SC_SR_SPEECH_WORD_END_MARGIN) * SC_SR_SPEECH_FRAME_SIZE)) ); + } + } + + // Save the current status + l1s.speechreco.speech_old_status = l1s_dsp_com.dsp_ndb_ptr->d_sr_status & SC_SR_WORD_MASK; + + // Determine which a_du buffer is currently used + l1s.speechreco.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_1; + if (l1a_l1s_com.dedic_set.aset != NULL) + { + if ( (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->channel_type == TCH_H) && + (l1a_l1s_com.dedic_set.aset->achan_ptr->desc_ptr->subchannel == 1) ) + l1s.speechreco.a_du_x = l1s_dsp_com.dsp_ndb_ptr->a_du_0; + } + + // The acquisition was good + if (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_GOOD_ACQUISITION) + { + // Stop the voice memorization recording task + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The task must be stopped + if ( (l1s_dsp_com.dsp_ndb_ptr->d_sr_status & B_BAD_ACQUISITION) || + (l1a_l1s_com.speechreco_task.command.speech_stop) || + (l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init & B_SR_STOP) ) + { + // Stop the DSP voice memorization recording task: + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= B_VM_RECORD_STOP; + + *state = WAIT_DSP_STOP; + } + else + // The DSP sends a new block + if (l1s.speechreco.a_du_x[0] & B_BLOCK_READY) + { + // Is there enough place in the RAM buffer + if (l1s.speechreco.speech_pointer == l1s.speechreco.end_pointer) + { + // Rewind the current pointer + l1s.speechreco.speech_pointer = l1a_l1s_com.speechreco_task.parameters.speech_address; + + // It isn't the first pass + l1s.speechreco.first_pass = FALSE; + } + + // Download the speech sample from the a_du_x to the RAM buffer + a_du_x = l1s.speechreco.a_du_x; + for(i=0; i < SC_SR_SPEECH_FRAME_SIZE; i++) + { + *(l1s.speechreco.speech_pointer)++ = *a_du_x++; + } + + // Clear the a_du_x header + l1s.speechreco.a_du_x[0] = 0; + } + } + break; + + case WAIT_DSP_STOP: + { + // The DSP speech recoding task is stopped + if ( !(l1s_dsp_com.dsp_ndb_ptr->d_toneskb_status & B_VM_RECORD_ON_GOING) ) + { + *state = IDLE; + } + } + break; + } // switch + } + + #endif // SPEECH_RECO + #if (L1_AEC == 1) + /*-------------------------------------------------------*/ + /* l1s_aec_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AEC L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_aec_manager(void) + { + enum states + { + IDLE = 0, + #if (L1_NEW_AEC) + WAIT_DSP_AVAILABLE = 1, + AEC_VISIBILITY = 2 + #else + WAIT_DSP_AVAILABLE = 1 + #endif + }; + + UWORD8 *state = &l1s.audio_state[L1S_AEC_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Set the d_aec_ctrl register + l1s.aec.aec_control = (l1a_l1s_com.aec_task.parameters.aec_control | B_AEC_ACK); + #if (L1_NEW_AEC) + l1s.aec.aec_visibility = (l1s.aec.aec_control & B_AEC_VISIBILITY) >> SC_AEC_VISIBILITY_SHIFT; + l1s.aec.cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s.aec.granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s.aec.coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s.aec.es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s.aec.fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s.aec.thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s.aec.fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s.aec.fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + #endif + + // Reset the start command + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_AVAILABLE; + } + break; + + case WAIT_DSP_AVAILABLE: + { + // the new settings come from the MMI + if (l1a_l1s_com.aec_task.command.start) + { + // Set the d_aec_ctrl register + l1s.aec.aec_control = (l1a_l1s_com.aec_task.parameters.aec_control | B_AEC_ACK); + #if (L1_NEW_AEC) + l1s.aec.aec_visibility = (l1s.aec.aec_control & B_AEC_VISIBILITY) >> SC_AEC_VISIBILITY_SHIFT; + l1s.aec.cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s.aec.granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s.aec.coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s.aec.es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s.aec.fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s.aec.thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s.aec.fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s.aec.fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + #endif + + // Reset the start command + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + + // the new settings can be written to the DSP +#if(DSP == 38) || (DSP == 39) + if ( (l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl & B_AEC_ACK) == FALSE ) +#else + if ( (l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl & B_AEC_ACK) == FALSE ) +#endif + { + +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = l1s.aec.aec_control; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = l1s.aec.aec_control; +#endif + + #if (L1_NEW_AEC) + l1s_dsp_com.dsp_ndb_ptr->d_cont_filter = l1s.aec.cont_filter; + l1s_dsp_com.dsp_ndb_ptr->d_granularity_att = l1s.aec.granularity_att; + l1s_dsp_com.dsp_ndb_ptr->d_coef_smooth = l1s.aec.coef_smooth; + l1s_dsp_com.dsp_ndb_ptr->d_es_level_max = l1s.aec.es_level_max; + l1s_dsp_com.dsp_ndb_ptr->d_fact_vad = l1s.aec.fact_vad; + l1s_dsp_com.dsp_ndb_ptr->d_thrs_abs = l1s.aec.thrs_abs; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_fil = l1s.aec.fact_asd_fil; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_mut = l1s.aec.fact_asd_mut; + + // AEC visibility allows tracing some AEC internal output values + if (l1s.aec.aec_visibility) + *state = AEC_VISIBILITY; + else + *state = IDLE; + #else + *state = IDLE; + #endif + } + } + break; + + #if (L1_NEW_AEC) + case AEC_VISIBILITY: + { + // the new settings come from the MMI + if (l1a_l1s_com.aec_task.command.start) + { + // Set the d_aec_ctrl register + l1s.aec.aec_control = (l1a_l1s_com.aec_task.parameters.aec_control | B_AEC_ACK); + l1s.aec.aec_visibility = (l1s.aec.aec_control & B_AEC_VISIBILITY) >> SC_AEC_VISIBILITY_SHIFT; + l1s.aec.cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s.aec.granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s.aec.coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s.aec.es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s.aec.fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s.aec.thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s.aec.fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s.aec.fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + + // Reset the start command + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_DSP_AVAILABLE; + } + + if ( (l1a_l1s_com.dedic_set.aset != NULL) && + ((l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_FS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_HS_MODE) || + (l1a_l1s_com.dedic_set.aset->achan_ptr->mode == TCH_EFR_MODE)) ) + { + l1s.aec.visibility_interval--; + + if (l1s.aec.visibility_interval < 0) + { + conf_msg = os_alloc_sig(sizeof(T_L1_AEC_IND)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AEC_IND; + + ((T_L1_AEC_IND *)(conf_msg->SigP))->es_level = l1s_dsp_com.dsp_ndb_ptr->d_es_level_api; + ((T_L1_AEC_IND *)(conf_msg->SigP))->far_end_pow = ( (l1s_dsp_com.dsp_ndb_ptr->d_far_end_pow_h << 16) + | (l1s_dsp_com.dsp_ndb_ptr->d_far_end_pow_l)); + ((T_L1_AEC_IND *)(conf_msg->SigP))->far_end_noise = ( (l1s_dsp_com.dsp_ndb_ptr->d_far_end_noise_h << 16) + | (l1s_dsp_com.dsp_ndb_ptr->d_far_end_noise_l)); + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // reset delay between 2 traces + l1s.aec.visibility_interval = SC_AEC_VISIBILITY_INTERVAL; + } + } + else + // It forces aec traces when entering dedicated mode + l1s.aec.visibility_interval = 1; + } + break; + #endif + } // switch + } + #endif // AEC + + #if(L1_AEC == 2) + + /*-------------------------------------------------------*/ + /* l1s_aec_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AEC L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ +void l1s_aec_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AEC_STATE]; + xSignalHeaderRec *conf_msg; + UWORD16 current_state; + static T_AEC_ACTION l1s_aec_action = L1_AQI_AEC_STOPPED; + static UWORD16 l_aec_ctrl; + + + switch(*state) + { + case IDLE: + { + + current_state = l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & 0x0800; + + if((l1a_l1s_com.aec_task.aec_control == L1_AQI_AEC_START)||(l1a_l1s_com.aec_task.aec_control == L1_AQI_AEC_UPDATE)) + { + if(current_state ) + { + +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl | 0x0004; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl | 0x0004; +#endif + + l_aec_ctrl = 0x0004; + l1s_aec_action = L1_AQI_AEC_UPDATED; + } + else + { + + +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl | 0x0001; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl | 0x0001; +#endif + l_aec_ctrl = 0x0001; + l1s_aec_action = L1_AQI_AEC_STARTED; + } + + l1s_dsp_com.dsp_ndb_ptr->d_cont_filter = l1a_l1s_com.aec_task.parameters.cont_filter; + l1s_dsp_com.dsp_ndb_ptr->d_granularity_att = l1a_l1s_com.aec_task.parameters.granularity_att; + l1s_dsp_com.dsp_ndb_ptr->d_coef_smooth = l1a_l1s_com.aec_task.parameters.coef_smooth; + l1s_dsp_com.dsp_ndb_ptr->d_es_level_max = l1a_l1s_com.aec_task.parameters.es_level_max; + l1s_dsp_com.dsp_ndb_ptr->d_fact_vad = l1a_l1s_com.aec_task.parameters.fact_vad; + l1s_dsp_com.dsp_ndb_ptr->d_thrs_abs = l1a_l1s_com.aec_task.parameters.thrs_abs; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_fil = l1a_l1s_com.aec_task.parameters.fact_asd_fil; + l1s_dsp_com.dsp_ndb_ptr->d_fact_asd_mut = l1a_l1s_com.aec_task.parameters.fact_asd_mut; + l1s_dsp_com.dsp_ndb_ptr->d_aec_mode = l1a_l1s_com.aec_task.parameters.aec_mode; + l1s_dsp_com.dsp_ndb_ptr->d_mu = l1a_l1s_com.aec_task.parameters.mu; + l1s_dsp_com.dsp_ndb_ptr->d_scale_input_ul = l1a_l1s_com.aec_task.parameters.scale_input_ul; + l1s_dsp_com.dsp_ndb_ptr->d_scale_input_dl = l1a_l1s_com.aec_task.parameters.scale_input_dl; + l1s_dsp_com.dsp_ndb_ptr->d_div_dmax = l1a_l1s_com.aec_task.parameters.div_dmax; + l1s_dsp_com.dsp_ndb_ptr->d_div_swap_good = l1a_l1s_com.aec_task.parameters.div_swap_good; + l1s_dsp_com.dsp_ndb_ptr->d_div_swap_bad = l1a_l1s_com.aec_task.parameters.div_swap_bad; + l1s_dsp_com.dsp_ndb_ptr->d_block_init = l1a_l1s_com.aec_task.parameters.block_init; + + + } + else if(l1a_l1s_com.aec_task.aec_control == L1_AQI_AEC_STOP) + { + if(current_state ) + { +#if(DSP == 38) || (DSP == 39) + l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl = (l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl) | 0x0002; +#else + l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl = (l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl) | 0x0002; +#endif + + l_aec_ctrl = 0x0002; + l1s_aec_action = L1_AQI_AEC_STOPPED; + } + else + { + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_AQI_AEC_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AEC_CON; + ((T_L1_AQI_AEC_CON*)(conf_msg->SigP))->aec_action = L1_AQI_AEC_NO_ACTION; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + return; + } + } + + *state = WAIT_DSP_ACK; + + + break; + } + + case WAIT_DSP_ACK: + { + +#if(DSP == 38) || (DSP == 39) + if(((l1s_dsp_com.dsp_ndb_ptr->d_aec_ul_ctrl) & (l_aec_ctrl)) == 0) +#else + if(((l1s_dsp_com.dsp_ndb_ptr->d_aec_ctrl) & (l_aec_ctrl)) == 0) +#endif + + { + l1a_l1s_com.aec_task.command.start = FALSE; + + // Send the AEC confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_AQI_AEC_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AEC_CON; + ((T_L1_AQI_AEC_CON*)(conf_msg->SigP))->aec_action = l1s_aec_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + + break; + } + }/* End of switch statement */ +} + + #endif + + #if (FIR) + /*-------------------------------------------------------*/ + /* l1s_fir_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : FIR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_fir_manager(void) + { + + enum states + { + IDLE, + WAIT_AUDIO_ON, + FIR_LOOP_ON + }; + + UWORD8 *state = &l1s.audio_state[L1S_FIR_STATE]; + xSignalHeaderRec *conf_msg; + + + + switch (*state) + { + case IDLE: + { + if (l1a_l1s_com.fir_task.parameters.fir_loop == 0) + { + l1s_fir_set_params(); + // Send the FIR confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_FIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + // Reset the start command + l1a_l1s_com.fir_task.command.start = FALSE; + } + else { + //enable UL and DL + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + *state = WAIT_AUDIO_ON; + } + } + break; + + case WAIT_AUDIO_ON: + { + if((l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE] == L1_AUDIO_DL_ON) && + (l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE] == L1_AUDIO_UL_ON)) + { + l1s_fir_set_params(); + // Send the FIR confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_FIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + // Reset the start command + l1a_l1s_com.fir_task.command.start = FALSE; + //set the Loop on the DSP side + l1s_dsp_com.dsp_ndb_ptr->d_audio_init |= B_FIR_LOOP; + *state = FIR_LOOP_ON; + } + + } + break; + + case FIR_LOOP_ON: + { + if (l1a_l1s_com.fir_task.command.start == TRUE) + { + if (l1a_l1s_com.fir_task.parameters.fir_loop == 0) + { + //disable UL and DL + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; + + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_FIR_LOOP); + *state = IDLE; + } + + // Reset the start command + l1a_l1s_com.fir_task.command.start = FALSE; + //download parameters + l1s_fir_set_params(); + // Send the FIR confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_FIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + break; + } // end switch + + } + + void l1s_fir_set_params(void) + { + + UWORD8 i; + + // Update the DL FIR? + if (l1a_l1s_com.fir_task.parameters.update_fir & DL_FIR) + { + // Download the DL FIR coefficients to the melody a_fir31_downlink + for (i=0; i<MAX_FIR_COEF; i++) + { + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) // For this DSP code the FIR coefficients are in API param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_downlink[i] = *l1a_l1s_com.fir_task.parameters.fir_dl_coefficient; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_downlink[i] = *l1a_l1s_com.fir_task.parameters.fir_dl_coefficient; + #endif + l1a_l1s_com.fir_task.parameters.fir_dl_coefficient++; + } + } + + // Update the UL FIR? + if (l1a_l1s_com.fir_task.parameters.update_fir & UL_FIR) + { + if ((l1s_dsp_com.dsp_ndb_ptr->d_audio_status & B_FIR_LOOP) == 1) // loop mode --> do not invert coef + { + // Download the UL FIR coefficients to the melody a_fir31_uplink + for (i=0; i<MAX_FIR_COEF; i++) + { + #if (DSP == 33) || (DSP == 34) || (DSP == 35) // For this DSP code the FIR coefficients are in API param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[i] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient; + #elif ((DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) // CQ #28839 + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[i] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient; + #endif + l1a_l1s_com.fir_task.parameters.fir_ul_coefficient++; + } + } + else // normal mode --> invert coeff + { + // Download the UL FIR coefficients to the melody a_fir31_uplink + for (i=0; i<MAX_FIR_COEF; i++) + { + // In UL, coefs are inversed + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39))// For this DSP code the FIR coefficients are in API param memory + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient; + #else + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1] = *l1a_l1s_com.fir_task.parameters.fir_ul_coefficient; + #endif + l1a_l1s_com.fir_task.parameters.fir_ul_coefficient++; + } + } + } + else // no UL update + { + if (((l1s_dsp_com.dsp_ndb_ptr->d_audio_status & B_FIR_LOOP) && (l1a_l1s_com.fir_task.parameters.fir_loop == FALSE)) + || ((!(l1s_dsp_com.dsp_ndb_ptr->d_audio_status & B_FIR_LOOP)) && (l1a_l1s_com.fir_task.parameters.fir_loop == TRUE))) // changing mode + { + // we are changing mode, normal to loop or loop to normal + // so we have to invert the coefficients in the API + UWORD16 temp_coeff; + + for (i=0; i<(MAX_FIR_COEF/2); i++) + { + #if ((DSP == 33) || (DSP == 34) || (DSP == 35) || (DSP == 36) || (DSP == 37) || (DSP == 38) || (DSP == 39)) // For this DSP code the FIR coefficients are in API param memory + temp_coeff = l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[i]; + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[i] = l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1]; + l1s_dsp_com.dsp_param_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1] = temp_coeff; + #else + temp_coeff = l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[i]; + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[i] = l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1]; + l1s_dsp_com.dsp_ndb_ptr->a_fir31_uplink[MAX_FIR_COEF-i-1] = temp_coeff; + #endif + } + } + } + + + } + #endif // FIR + #if (AUDIO_MODE) + /*-------------------------------------------------------*/ + /* l1s_audio_mode_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio mode L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_mode_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_CONFIRM = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_MODE_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + + // Reset the d_audio_init + l1s_dsp_com.dsp_ndb_ptr->d_audio_init &= ~(B_GSM_ONLY | B_BT_HEADSET | B_BT_CORDLESS); + + // Set the new mode + l1s_dsp_com.dsp_ndb_ptr->d_audio_init + |= l1a_l1s_com.audio_mode_task.parameters.audio_mode; + + *state = WAIT_DSP_CONFIRM; + } + break; + + case WAIT_DSP_CONFIRM: + { + // the DSP acknowledges the new settings. + if ( l1s_dsp_com.dsp_ndb_ptr->d_audio_init == l1s_dsp_com.dsp_ndb_ptr->d_audio_status ) + { + // Send the Audio mode confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_MODE_CON; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Reset the start command + l1a_l1s_com.audio_mode_task.command.start = FALSE; + + *state = IDLE; + } + } + break; + } // switch + } + #endif // AUDIO_MODE + #if (MELODY_E2) + /*-------------------------------------------------------*/ + /* l1s_melody0_e2_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio melody 0 format E2 L1S manager */ + /* task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody0_e2_manager(void) + { + enum states + { + M0_INACTIVE = 0, + M0_ALIGN_40MS_BOUNDARY = 1, + M0_WAIT_COUNTER_EQUAL_0 = 2, + M0_WAIT_END_MELODY = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY0_E2_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 trash[SC_MELODY_E2_MAXIMUM_HEADER_SIZE+1], oscillator_number, extension_index; + UWORD16 oscillator_not_available; + + switch(*state) + { + case M0_INACTIVE: + { + // Reset the commands: + l1a_l1s_com.melody0_e2_task.command.start = FALSE; + + // Initialize the pointer and size to the new description + l1s.melody0_e2.ptr_buf = l1a_l1s_com.melody0_e2_task.parameters.ptr_buf; + l1s.melody0_e2.buffer_size = l1a_l1s_com.melody0_e2_task.parameters.buffer_size; + + *state = M0_ALIGN_40MS_BOUNDARY; + } + break; + + case M0_ALIGN_40MS_BOUNDARY: + { + // Initialize the counter to the first time + l1s.melody0_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody0_e2.counter)); + + // Save the extension flag + l1s.melody0_e2.extension_flag = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // Save delta-time in 20ms unit + l1s.melody0_e2.counter = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + l1s.melody0_e2.note_start_20ms = l1s.melody0_e2.counter; + + // Adjust note_start on 20ms boundary because global counter could be running for another melody or loopback + // Timebase can be computed as k*60ms + timebase_mod_60ms + l1s.melody0_e2.note_start_20ms += ((l1s.melody_e2.timebase - l1s.melody_e2.timebase_mod_60ms) / 13 * 3); + if (l1s.melody_e2.timebase_mod_60ms < 4) + { + l1s.melody0_e2.note_start_20ms += 1; + } + else if (l1s.melody_e2.timebase_mod_60ms < 8) + { + l1s.melody0_e2.note_start_20ms += 2; + } + else if (l1s.melody_e2.timebase_mod_60ms < 13) + { + l1s.melody0_e2.note_start_20ms += 3; + } + + // Align on 40ms boundary + if ( (l1s.melody0_e2.note_start_20ms & 1) == 1 ) + l1s.melody0_e2.note_start_20ms++; + + // Convert to TDMA + l1s.melody0_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody0_e2.note_start_20ms); + + // Compute TDMA to wait (-1 to take into account this TDMA) + l1s.melody0_e2.counter = l1s.melody0_e2.counter - l1s.melody_e2.timebase - 1; + + // Wait to download the first description + *state = M0_WAIT_COUNTER_EQUAL_0; + } // M0_INIT + break; + + case M0_WAIT_COUNTER_EQUAL_0: + { + // Stop command + if (l1a_l1s_com.melody0_e2_task.command.stop) + { + // wait until all the ocillator are stopped + *state = M0_WAIT_END_MELODY; + } + else if (l1s.melody0_e2.counter > 0) + { + // Decrease the counter + l1s.melody0_e2.counter--; + } + else + { + // Wait until the semaphore is set to 0 by the DSP + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Initialize oscillators available, oscillators can be used by the DSP (d_melody_e2_osc_active) + // or by the other melody E2 generator (melody_e2_osc_stop) + oscillator_not_available = + l1s.melody_e2.global_osc_active | l1s.melody_e2.global_osc_to_start; + + // find an available oscillator + oscillator_number = 0; + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Initialize end of file + l1s.melody0_e2.end_of_file = FALSE; + + // download the description until the delta time is different from 0 + // or end of the melody file + while ( (l1s.melody0_e2.counter == 0) && + (l1s.melody0_e2.end_of_file == FALSE) ) + { + // Download the byte of the note descriptor extension in trash + l1s.melody0_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 2, + &trash[0]); + + // Check end of melody + if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + { + // It is not the end of melody + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + // Reset the oscillator description + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][1] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][2] = 0x0000; + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = + trash[0] + (trash[1] << 8); + + // Update the oscillators to start bit field + l1s.melody_e2.global_osc_to_start |= (0x0001<<oscillator_number); + + // Save the oscillator as active for this melody + l1s.melody0_e2.oscillator_active |= (0x0001<<oscillator_number); + + // oscillator is no longer available + oscillator_not_available |= (0x0001<<oscillator_number); + } + + // Download the extensions + extension_index = 1; + while(l1s.melody0_e2.extension_flag) + { + // Download the byte of the note descriptor extension + l1s.melody0_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 2, + &trash[0]); + + // Read the extension flag + l1s.melody0_e2.extension_flag = Field(trash[0], + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][extension_index] = + trash[0] + (trash[1] << 8); + } + + extension_index++; + } // extension download + + // find next available oscillator + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Read next delta time + l1s.melody0_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody0_e2.counter)); + + // Save the extension flag + l1s.melody0_e2.extension_flag = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + l1s.melody0_e2.counter = Field(l1s.melody0_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + } // if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + else + { + // it's the end of the melody file + l1s.melody0_e2.end_of_file = TRUE; + } + } // while ( (l1s.melody0_e2.counter == 0) && (l1s.melody0_e2.end_of_file == FALSE) ) + + // Perform TDMA convertion or handle end of file + if (l1s.melody0_e2.end_of_file == FALSE) + { + // Update note start + l1s.melody0_e2.note_start_20ms += l1s.melody0_e2.counter; + + l1s.melody0_e2.delta_time = l1s.melody0_e2.counter; + + // Convert the delta time into TDMA time unit + l1s.melody0_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody0_e2.note_start_20ms) + - l1s.melody_e2.timebase; + + // decrease the counter + l1s.melody0_e2.counter--; + + *state = M0_WAIT_COUNTER_EQUAL_0; + } + else + { + l1s.melody0_e2.delta_time = 0xFFFF; + *state = M0_WAIT_END_MELODY; + } + } // semaphore check + } // if (l1a_l1s_com.melody0_e2_task.command.stop) (2nd else) + } // case M0_WAIT_COUNTER_EQUAL_0: + break; + + case M0_WAIT_END_MELODY: + { + if (l1a_l1s_com.melody0_e2_task.command.stop) + { + // Stop immediatly the current melody + // Wait until the semaphore is set to 0 by the DSP to stop the current description + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Stop the oscillator mentionned in the bits field melody0_e2.oscillator_active + for(oscillator_number=0; oscillator_number<SC_MELODY_E2_NUMBER_OF_OSCILLATOR; oscillator_number++) + { + if (l1s.melody0_e2.oscillator_active & (0x0001<<oscillator_number)) + { + // Stop the current oscillator + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_stop |= (0x0001<<oscillator_number); + } + } + // wait until all the oscillator are stopped + l1a_l1s_com.melody0_e2_task.parameters.loopback = FALSE; + l1a_l1s_com.melody0_e2_task.command.stop = FALSE; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0xFFFF;// another melody could be running + } // semaphore + } + else if (l1s.melody0_e2.oscillator_active == 0x0000) + { + // all oscillators are stopped + if (l1a_l1s_com.melody0_e2_task.parameters.loopback) + { + // It's the loopback mode + // Reset the pointer to the current melody + #if (OP_RIV_AUDIO == 0) + l1s.melody0_e2.ptr_buf = NULL; + #endif + l1s.melody0_e2.buffer_size = 0; + l1s.melody0_e2.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody0_e2.ptr_buf, + &l1s.melody0_e2.buffer_size, + l1a_l1s_com.melody0_e2_task.parameters.session_id); + + // Jump the header field + l1s.melody0_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id, + &l1s.melody0_e2.buffer_size, + (UWORD8 **)&l1s.melody0_e2.ptr_buf, + (UWORD16)(l1a_l1s_com.melody0_e2_task.parameters.header_size), + &trash[0]); + + // Wait until the description can be downloaded + *state = M0_ALIGN_40MS_BOUNDARY; + } + else + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY0_E2_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Go to inactive mode + *state = M0_INACTIVE; + } + } + break; + } // M0_WAIT_END_MELODY + } // switch + } // l1s_melody0_e2_manager + + /*-------------------------------------------------------*/ + /* l1s_melody1_e2_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio melody 0 format E2 L1S manager */ + /* task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_melody1_e2_manager(void) + { + enum states + { + M1_INACTIVE = 0, + M1_ALIGN_40MS_BOUNDARY = 1, + M1_WAIT_COUNTER_EQUAL_0 = 2, + M1_WAIT_END_MELODY = 3 + }; + + UWORD8 *state = &l1s.audio_state[L1S_MELODY1_E2_STATE]; + xSignalHeaderRec *conf_msg; + UWORD8 trash[SC_MELODY_E2_MAXIMUM_HEADER_SIZE+1], oscillator_number, extension_index; + UWORD16 oscillator_not_available; + + switch(*state) + { + case M1_INACTIVE: + { + // Reset the commands: + l1a_l1s_com.melody1_e2_task.command.start = FALSE; + + // Initialize the pointer and size to the new description + l1s.melody1_e2.ptr_buf = l1a_l1s_com.melody1_e2_task.parameters.ptr_buf; + l1s.melody1_e2.buffer_size = l1a_l1s_com.melody1_e2_task.parameters.buffer_size; + + *state = M1_ALIGN_40MS_BOUNDARY; + } + break; + + case M1_ALIGN_40MS_BOUNDARY: + { + // Initialize the counter to the first time + l1s.melody1_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody1_e2.counter)); + + // Save the extension flag + l1s.melody1_e2.extension_flag = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // Save delta-time in 20ms unit + l1s.melody1_e2.counter = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + l1s.melody1_e2.note_start_20ms = l1s.melody1_e2.counter; + + // Adjust note_start on 20ms boundary because global counter could be running for another melody or loopback + // Timebase can be computed as k*60ms + timebase_mod_60ms + l1s.melody1_e2.note_start_20ms += ((l1s.melody_e2.timebase - l1s.melody_e2.timebase_mod_60ms) / 13 * 3); + if (l1s.melody_e2.timebase_mod_60ms < 4) + { + l1s.melody1_e2.note_start_20ms += 1; + } + else if (l1s.melody_e2.timebase_mod_60ms < 8) + { + l1s.melody1_e2.note_start_20ms += 2; + } + else if (l1s.melody_e2.timebase_mod_60ms < 13) + { + l1s.melody1_e2.note_start_20ms += 3; + } + + // Align on 40ms boundary + if ( (l1s.melody1_e2.note_start_20ms & 1) == 1 ) + l1s.melody1_e2.note_start_20ms++; + + // Convert to TDMA + l1s.melody1_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody1_e2.note_start_20ms); + + // Compute TDMA to wait (-1 to take into account this TDMA) + l1s.melody1_e2.counter = l1s.melody1_e2.counter - l1s.melody_e2.timebase - 1; + + // Wait to download the first description + *state = M1_WAIT_COUNTER_EQUAL_0; + } // M1_INIT + break; + + case M1_WAIT_COUNTER_EQUAL_0: + { + // Stop command + if (l1a_l1s_com.melody1_e2_task.command.stop) + { + // wait until all the ocillator are stopped + *state = M1_WAIT_END_MELODY; + } + else if (l1s.melody1_e2.counter > 0) + { + // Decrease the counter + l1s.melody1_e2.counter--; + } + else + { + // Wait until the semaphore is set to 0 by the DSP + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Initialize oscillators available, oscillators can be used by the DSP (d_melody_e2_osc_active) + // or by the other melody E2 generator (melody_e2_osc_stop) + oscillator_not_available = + l1s.melody_e2.global_osc_active | l1s.melody_e2.global_osc_to_start; + + // find an available oscillator + oscillator_number = 0; + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Initialize end of file + l1s.melody1_e2.end_of_file = FALSE; + + // download the description until the delta time is different from 0 + // or end of the melody file + while ( (l1s.melody1_e2.counter == 0) && + (l1s.melody1_e2.end_of_file == FALSE) ) + { + // Download the byte of the note descriptor extension in trash + l1s.melody1_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 2, + &trash[0]); + + // Check end of melody + if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + { + // It is not the end of melody + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + // Reset the oscillator description + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][1] = 0x0000; + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][2] = 0x0000; + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][0] = + trash[0] + (trash[1] << 8); + + // Update the oscillators to start bit field + l1s.melody_e2.global_osc_to_start |= (0x0001<<oscillator_number); + + // Save the oscillator as active for this melody + l1s.melody1_e2.oscillator_active |= (0x0001<<oscillator_number); + + // oscillator is no longer available + oscillator_not_available |= (0x0001<<oscillator_number); + } + + // Download the extensions + extension_index = 1; + while(l1s.melody1_e2.extension_flag) + { + // Download the byte of the note descriptor extension + l1s.melody1_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 2, + &trash[0]); + + // Read the extension flag + l1s.melody1_e2.extension_flag = Field(trash[0], + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + // If an oscillator is available, use it + if (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) + { + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_osc[oscillator_number][extension_index] = + trash[0] + (trash[1] << 8); + } + + extension_index++; + } // extension download + + // find next available oscillator + while( (oscillator_number < SC_MELODY_E2_NUMBER_OF_OSCILLATOR) && + (oscillator_not_available & (0x0001<<oscillator_number)) ) + { + oscillator_number++; + } + + // Read next delta time + l1s.melody1_e2.error_id= copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + 1, + (UWORD8 *)(&l1s.melody1_e2.counter)); + + // Save the extension flag + l1s.melody1_e2.extension_flag = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_EXTENSION_FLAG_MASK, + SC_MELODY_E2_EXTENSION_FLAG_SHIFT); + + l1s.melody1_e2.counter = Field(l1s.melody1_e2.counter, + SC_MELODY_E2_DELTA_TIME_MASK, + SC_MELODY_E2_DELTA_TIME_SHIFT); + } // if ( (trash[0] != 0x00) || (trash[1] != 0x00) ) + else + { + // it's the end of the melody file + l1s.melody1_e2.end_of_file = TRUE; + } + } // while ( (l1s.melody1_e2.counter == 0) && (l1s.melody1_e2.end_of_file == FALSE) ) + + // Perform TDMA convertion or handle end of file + if (l1s.melody1_e2.end_of_file == FALSE) + { + // Update note start + l1s.melody1_e2.note_start_20ms += l1s.melody1_e2.counter; + + l1s.melody1_e2.delta_time = l1s.melody1_e2.counter; + + // Convert the delta time into TDMA time unit + l1s.melody1_e2.counter = audio_twentyms_to_TDMA_convertion(l1s.melody1_e2.note_start_20ms) + - l1s.melody_e2.timebase; + + // decrease the counter + l1s.melody1_e2.counter--; + + *state = M1_WAIT_COUNTER_EQUAL_0; + } + else + { + l1s.melody1_e2.delta_time = 0xFFFF; + *state = M1_WAIT_END_MELODY; + } + } // semaphore check + } // if (l1a_l1s_com.melody1_e2_task.command.stop) (2nd else) + } // case M1_WAIT_COUNTER_EQUAL_0: + break; + + case M1_WAIT_END_MELODY: + { + if (l1a_l1s_com.melody1_e2_task.command.stop) + { + // Stop immediatly the current melody + // Wait until the semaphore is set to 0 by the DSP to stop the current description + if (!(l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_semaphore & SC_MELODY_E2_SEMAPHORE_MASK)) + { + // Stop the oscillator mentionned in the bits field melody1_e2.oscillator_active + for(oscillator_number=0; oscillator_number<SC_MELODY_E2_NUMBER_OF_OSCILLATOR; oscillator_number++) + { + if (l1s.melody1_e2.oscillator_active & (0x0001<<oscillator_number)) + { + // Stop the current oscillator + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_osc_stop |= (0x0001<<oscillator_number); + } + } + // wait until all the oscillator are stopped + l1a_l1s_com.melody1_e2_task.parameters.loopback = FALSE; + l1a_l1s_com.melody1_e2_task.command.stop = FALSE; + l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_deltatime = 0xFFFF; // another melody could be running + } // semaphore + } + else if (l1s.melody1_e2.oscillator_active == 0x0000) + { + // all oscillators are stopped + if (l1a_l1s_com.melody1_e2_task.parameters.loopback) + { + // It's the loopback mode + // Reset the pointer to the current melody + #if (OP_RIV_AUDIO == 0) + l1s.melody1_e2.ptr_buf = NULL; + #endif + l1s.melody1_e2.buffer_size = 0; + l1s.melody1_e2.error_id = Cust_get_pointer((UWORD16 **)&l1s.melody1_e2.ptr_buf, + &l1s.melody1_e2.buffer_size, + l1a_l1s_com.melody1_e2_task.parameters.session_id); + + // Jump the header field + l1s.melody1_e2.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id, + &l1s.melody1_e2.buffer_size, + (UWORD8 **)&l1s.melody1_e2.ptr_buf, + (UWORD16)(l1a_l1s_com.melody1_e2_task.parameters.header_size), + &trash[0]); + + // Wait until the description can be downloaded + *state = M1_ALIGN_40MS_BOUNDARY; + } + else + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_MELODY1_E2_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + // Go to inactive mode + *state = M1_INACTIVE; + } + } + break; + } // M1_WAIT_END_MELODY + } // switch + } // l1s_melody1_e2_manager + + #endif // MELODY_E2 + + #if (L1_CPORT == 1) + /*-------------------------------------------------------*/ + /* l1s_cport_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Cport L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_cport_manager(void) + { + enum states + { + IDLE = 0, + WAIT_CPORT_CONF = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_CPORT_STATE]; + xSignalHeaderRec *conf_msg; + API temp_write_var; + + switch(*state) + { + case IDLE: + { + // Check if a cport configuration is not yet in progress in DSP + if (l1s_dsp_com.dsp_ndb_ptr->d_cport_status == (API) (CPORT_R_NONE | CPORT_W_NONE)) + { + // ok, we can start the DSP Cport configuration task + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CTRL) + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = l1a_l1s_com.cport_task.parameters.ctrl; + + if (l1a_l1s_com.cport_task.parameters.configuration & (CPORT_W_CPCFR1 | CPORT_W_CPCFR2)) + { + temp_write_var = 0; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR1) + temp_write_var = l1a_l1s_com.cport_task.parameters.cpcfr1 << 8; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR2) + temp_write_var |= l1a_l1s_com.cport_task.parameters.cpcfr2; + + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = temp_write_var; + } + + + if (l1a_l1s_com.cport_task.parameters.configuration & (CPORT_W_CPCFR3 | CPORT_W_CPCFR4)) + { + temp_write_var = 0; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR3) + temp_write_var = l1a_l1s_com.cport_task.parameters.cpcfr3 << 8; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPCFR4) + temp_write_var |= l1a_l1s_com.cport_task.parameters.cpcfr4; + + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = temp_write_var; + } + + + if (l1a_l1s_com.cport_task.parameters.configuration & (CPORT_W_CPTCTL | CPORT_W_CPTTADDR)) + { + temp_write_var = 0; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTCTL) + temp_write_var = l1a_l1s_com.cport_task.parameters.cptctl << 8; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTTADDR) + temp_write_var |= l1a_l1s_com.cport_task.parameters.cpttaddr; + + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = temp_write_var; + } + + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTDAT) + l1s_dsp_com.dsp_ndb_ptr->d_cport_tdat = l1a_l1s_com.cport_task.parameters.cptdat; + + if (l1a_l1s_com.cport_task.parameters.configuration & CPORT_W_CPTVS) + l1s_dsp_com.dsp_ndb_ptr->d_cport_tvs = l1a_l1s_com.cport_task.parameters.cptvs; + + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = l1a_l1s_com.cport_task.parameters.configuration; + + *state = WAIT_CPORT_CONF; + + // Reset the command + l1a_l1s_com.cport_task.command.start = FALSE; + + } + + // else, we do nothing -> check will be done again at next frame + } + break; + + case WAIT_CPORT_CONF: + { + // the DSP acknowledges the L1S start request. + if (l1s_dsp_com.dsp_ndb_ptr->d_cport_init + == l1s_dsp_com.dsp_ndb_ptr->d_cport_status) + { + // task is over + l1s_dsp_com.dsp_ndb_ptr->d_cport_init = (API) (CPORT_R_NONE | CPORT_W_NONE); + l1s_dsp_com.dsp_ndb_ptr->d_cport_ctrl = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[0] = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->a_cport_cfr[1] = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tcl_tadt = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tdat = (API) 0; + l1s_dsp_com.dsp_ndb_ptr->d_cport_tvs = (API) 0; + + // Send the configuration confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(sizeof(T_L1_CPORT_CONFIGURE_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_CPORT_CONFIGURE_CON; + + //Fill the message + ((T_L1_CPORT_CONFIGURE_CON *)(conf_msg->SigP))->register_id = (l1s_dsp_com.dsp_ndb_ptr->d_cport_status & CPORT_READ_MASK); + ((T_L1_CPORT_CONFIGURE_CON *)(conf_msg->SigP))->register_value = l1s_dsp_com.dsp_ndb_ptr->d_cport_reg_value; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + } // switch + } + #endif // L1_CPORT == 1 + + /*-------------------------------------------------------*/ + /* l1s_audio_it_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Audio it manager */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_it_manager(void) + { + // Reset the command : + l1a_l1s_com.audioIt_task.command.start = FALSE; + + // this is an empty state machin only used to generate an + // audio IT to DSP in case another sw entity has changed + // something in the API + } + + + #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1s_audio_onoff_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : audio on/off L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_onoff_manager(void) + { + enum states + { + IDLE = 0, + WAIT_AUDIO_ONOFF_CON = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_ONOFF_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Disable the start command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + // Update the audio on/off value except if the L1S is already forcing it + if ((l1a_l1s_com.audio_onoff_task.parameters.onoff_value == TRUE) && + (l1a_l1s_com.audio_forced_by_l1s == FALSE)) + // l1a_l1s_com.audio_onoff_task.parameters.onoff_value == AUDIO_ON + { + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (API) B_AUDIO_ON_START; + } + else if ((l1a_l1s_com.audio_onoff_task.parameters.onoff_value == FALSE) && + (l1a_l1s_com.audio_forced_by_l1s == FALSE)) + // l1a_l1s_com.audio_onoff_task.parameters.onoff_value == AUDIO_OFF + { + l1s_dsp_com.dsp_ndb_ptr->d_toneskb_init |= (API) B_AUDIO_OFF_STOP; + } + + *state = WAIT_AUDIO_ONOFF_CON; + } + break; + + case WAIT_AUDIO_ONOFF_CON: + { + // The L1 has to send the confirmation message even if the request was to disable the audio on/off + // and it is still forced. This confirmation message is only to acknowledge the reception of the message, + // it is not correlated to the state of the audio into the DSP. + + // Allocate memory for confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_ONOFF_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + break; + + } // switch + } + #endif + + #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1) + /*-------------------------------------------------------*/ + /* l1s_audio_onoff_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : audio on/off L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_audio_voice_onoff_manager(void) + { + enum states + { + IDLE = 0, + WAIT_AUDIO_ONOFF_CON = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AUDIO_ONOFF_STATE]; + UWORD8 *ul_state = &l1s.audio_state[L1S_AUDIO_UL_ONOFF_STATE]; + UWORD8 *dl_state = &l1s.audio_state[L1S_AUDIO_DL_ONOFF_STATE]; + UWORD8 *vul_state = &l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value; + UWORD8 *vdl_state = &l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + // Disable the start command + l1a_l1s_com.audio_onoff_task.command.start = FALSE; + + // Update the Voice Uplink count + if(l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value == L1_AUDIO_VOICE_UL_ON) + { + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request++; + } + else if(l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value == L1_AUDIO_VOICE_UL_OFF ) + { + if(l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request) + l1s.audio_on_off_ctl.l1_audio_switch_on_ul_request--; + } + + // Update the Voice Downlink count + if(l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value == L1_AUDIO_VOICE_DL_ON) + { + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request++; + } + else if(l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value == L1_AUDIO_VOICE_DL_OFF) + { + if(l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request) + l1s.audio_on_off_ctl.l1_audio_switch_on_dl_request--; + } + + *state = WAIT_AUDIO_ONOFF_CON; + } + break; + + case WAIT_AUDIO_ONOFF_CON: + { + // For Voice Uplink or Downlink switch on is done only after the VUL or VDL is actually switched ON + // For switch off there could be potentially other tasks that use the VUL or VDL and hence a blind + // confirmation is given + if( (((*vul_state == L1_AUDIO_VOICE_UL_ON) && (*ul_state == L1_AUDIO_UL_ON)) || + (*vul_state == L1_AUDIO_VOICE_UL_OFF) || (*vul_state == L1_AUDIO_VOICE_UL_NO_ACTION)) && + (((*vdl_state == L1_AUDIO_VOICE_DL_ON) && (*dl_state == L1_AUDIO_DL_ON)) || + (*vdl_state == L1_AUDIO_VOICE_DL_OFF) || (*vdl_state == L1_AUDIO_VOICE_DL_NO_ACTION))) + { + // The L1 has to send the confirmation message even if the request was to disable the audio on/off + // and it is still forced. This confirmation message is only to acknowledge the reception of the message, + // it is not correlated to the state of the audio into the DSP. + + // Allocate memory for confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AUDIO_ONOFF_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + } // switch + } + #endif + + #if (L1_STEREOPATH == 1) + /*-------------------------------------------------------*/ + /* l1s_stereopath_drv_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : Generic Stereopath L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ +#if (CODE_VERSION == SIMULATION) + void l1s_stereopath_drv_manager(void) + { + enum states + { + IDLE=0, + WAIT_STOP + }; + + xSignalHeaderRec *conf_msg; + + if(l1a_l1s_com.stereopath_drv_task.command.start==TRUE) + { + // reset the command + l1a_l1s_com.stereopath_drv_task.command.start=FALSE; + + // change state + l1s.audio_state[L1S_STEREOPATH_DRV_STATE]=WAIT_STOP; + + // send confirmation to the L1A + conf_msg=os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode=L1_STEREOPATH_DRV_START_CON; + os_send_sig(conf_msg,L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + + if(l1a_l1s_com.stereopath_drv_task.command.stop==TRUE) + { + // reset the command + l1a_l1s_com.stereopath_drv_task.command.stop=FALSE; + + // change state + l1s.audio_state[L1S_STEREOPATH_DRV_STATE]=IDLE; + + // send confirmation to the L1A + conf_msg=os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode=L1_STEREOPATH_DRV_STOP_CON; + os_send_sig(conf_msg,L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } +#else // CODE_VERSION + void l1s_stereopath_drv_manager(void) + { + //sundi: change in the enum values for the ABB states +#if (ANLG_FAM == 11) + enum states + { + IDLE = 0, + ABB_CONFIGURE_DONE = 1, + ABB_START = 2, + ABB_START_DONE = 3, + DMA_CONF = 4, + CPORT_CONF = 5, + CPORT_START = 6, + WAIT_STOP = 7, + CPORT_STOP = 8, + ABB_STOP_DONE = 9, + DMA_STOP = 10, + STOP_CON = 11 + }; +#else + enum states + { + IDLE = 0, + ABB_START = 1, + DMA_CONF = 2, + CPORT_CONF = 3, + CPORT_START = 4, + WAIT_STOP = 5, + CPORT_STOP = 6, + DMA_STOP = 7, + STOP_CON = 8 + }; +#endif + + UWORD8 *state = &l1s.audio_state[L1S_STEREOPATH_DRV_STATE]; + xSignalHeaderRec *conf_msg; + static UWORD16 wait_pll_on_counter = L1S_STEREOPATH_DRV_WAIT_PLL_COUNTER; + + // This is the default parameters structure for a DMA channel + static T_DMA_TYPE_CHANNEL_PARAMETER d_dma_channel_parameter= + { + f_dma_default_call_back_it, // call back function + C_DMA_CHANNEL_2, // channel number + C_DMA_CHANNEL_NOT_SECURED, // channel security + C_DMA_DATA_S16, // data type + C_DMA_IMIF_PORT, // source port + C_DMA_CHANNEL_NOT_PACKED, // source packing + C_DMA_CHANNEL_SINGLE, // source bursting + C_DMA_RHEA_PORT, // destination port + C_DMA_CHANNEL_NOT_PACKED, // destination packing + C_DMA_CHANNEL_SINGLE, // destination bursting + C_DMA_CHANNEL_CPORT_TX, // hw synchro + C_DMA_CHANNEL_PRIORITY_HIGH, // channel priority + C_DMA_CHANNEL_AUTO_INIT_ON, // autoinit option + C_DMA_CHANNEL_FIFO_FLUSH_OFF, // fifo flush option + C_DMA_CHANNEL_ADDR_MODE_POST_INC, // source addressing mode + C_DMA_CHANNEL_ADDR_MODE_CONSTANT, // destination addressing mode + C_DMA_CHANNEL_IT_TIME_OUT_ON, // IT time out control + C_DMA_CHANNEL_IT_DROP_ON, // IT drop control + C_DMA_CHANNEL_IT_FRAME_OFF, // IT frame control + C_DMA_CHANNEL_IT_BLOCK_ON, // IT block control + C_DMA_CHANNEL_IT_HALF_BLOCK_ON, // IT half_block control + 0, // source start address + 0xFFFFD800L, // destination start address + 2, // element number + 0 // frame number + }; + + switch(*state) + { + case IDLE: + { +#if (ANLG_FAM == 11) + //Sundi:Set the abb_write_done variable to 0. This variable gets set in I2C call back fn. + l1s.abb_write_done = 0; +#endif + // Configure the ABB audio part in order to get the correct clock for the Cport + l1s_stereopath_drv_config_ABB(l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo, + l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency); + +#if (ANLG_FAM == 11) + // Must wait for the PLL to be locked. The value of 1 is subtracted from the standard value + // in order to take care of the extra state added - ABB_CONFIGURE_DONE. + wait_pll_on_counter = L1S_STEREOPATH_DRV_WAIT_PLL_COUNTER - 1; +#else + // Must wait for the PLL to be locked. + wait_pll_on_counter = L1S_STEREOPATH_DRV_WAIT_PLL_COUNTER; + +#endif + + // Reset the command + l1a_l1s_com.stereopath_drv_task.command.start = FALSE; +#if (ANLG_FAM == 11) + //sundi: change the state to ABB_CONFIGURE_DONE to wait for I2C write ACK. + *state = ABB_CONFIGURE_DONE; + +#else + *state = ABB_START; +#endif + } + break; +#if (ANLG_FAM == 11) + //sundi: add the new state + case ABB_CONFIGURE_DONE: + { + //sundi: continue to be in this state till an I2C write ACK comes. + //abb_write_done is set to 1 by the call back function + //that is passed to the I2C write function. + if (l1s.abb_write_done == 1) + { + *state = ABB_START; + + } + } + break; +#endif + case ABB_START: + { + if (wait_pll_on_counter == 0) + { +#if (ANLG_FAM == 11) + //Sundi:Set the abb_write_done variable to 0. This variable gets set in I2C call back fn. + l1s.abb_write_done = 0; +#endif + // PLL is locked, the ABB can be started + l1s_stereopath_drv_start_ABB(); +#if (ANLG_FAM == 11) + //sundi: Change state to ABB_START_DONE + *state = ABB_START_DONE; +#else + *state = DMA_CONF; +#endif + } + else + wait_pll_on_counter--; + } + break; +#if (ANLG_FAM == 11) + //sundi: Add the new state ABB_START_DONE + case ABB_START_DONE: + { + //sundi: continue to be in this state till an I2C write ACK comes. + //abb_write_done is set to 1 by the call back function + //that is passed to the I2C write function. + if (l1s.abb_write_done == 1) + { + *state = DMA_CONF; + + } + } + break; +#endif + // After 1 TDMA frame, DSP has necessarily programmed ABB + case DMA_CONF: + { + // update the DMA defaut parameters structure with received parameters + d_dma_channel_parameter.pf_dma_call_back_address = (T_DMA_CALL_BACK) l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct; + d_dma_channel_parameter.d_dma_channel_number = (T_DMA_TYPE_CHANNEL_NUMBER) l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number; + d_dma_channel_parameter.d_dma_channel_data_type = (T_DMA_TYPE_CHANNEL_DATA_TYPE) l1a_l1s_com.stereopath_drv_task.parameters.data_type; + d_dma_channel_parameter.d_dma_channel_src_port = (T_DMA_TYPE_CHANNEL_PORT) l1a_l1s_com.stereopath_drv_task.parameters.source_port; + d_dma_channel_parameter.d_dma_channel_src_address = (SYS_UWORD32) l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address; + d_dma_channel_parameter.d_dma_channel_element_number = (SYS_UWORD16) l1a_l1s_com.stereopath_drv_task.parameters.element_number; + d_dma_channel_parameter.d_dma_channel_frame_number = (SYS_UWORD16) l1a_l1s_com.stereopath_drv_task.parameters.frame_number; + + // Configure and start the DMA channel + l1s_stereopath_drv_start_DMA(d_dma_channel_parameter,l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation); + + // Reset the Cport + l1s_stereopath_drv_reset_CPORT(); + + *state = CPORT_CONF; + + } + break; + + case CPORT_CONF: + { + // Configure the Cport + l1s_stereopath_drv_config_CPORT(); + + *state = CPORT_START; + + } + break; + + case CPORT_START: + { + // Start the Cport + l1s_stereopath_drv_start_CPORT(); + + // Send the start confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_STEREOPATH_DRV_START_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = WAIT_STOP; + } + break; + + case WAIT_STOP: + { + /* OUTEN registers have been updated */ + if(l1a_l1s_com.outen_cfg_task.command_requested != l1a_l1s_com.outen_cfg_task.command_commited) + { + l1s_stereopath_callback(L1S_TWL3029_STEROPATH_START); + } + if (l1a_l1s_com.stereopath_drv_task.command.stop) + { + // Stop command received + + // Reset the Cport + l1s_stereopath_drv_reset_CPORT(); + + *state = CPORT_STOP; + + // Disable the stop command + l1a_l1s_com.stereopath_drv_task.command.stop = FALSE; + } + } + break; + + case CPORT_STOP: + { + // Stop the Cport + l1s_stereopath_drv_stop_CPORT(); +#if (ANLG_FAM == 11) + //Set the abb_write_done variable to 0. This variable gets set in I2C call back fn. + l1s.abb_write_done = 0; +#endif + // Stop the ABB + l1s_stereopath_drv_stop_ABB(); +#if (ANLG_FAM == 11) + //sundi: change state to ABB_STOP_DONE + *state = ABB_STOP_DONE; +#else + *state = DMA_STOP; +#endif + } + break; +#if (ANLG_FAM == 11) + //sundi: Add a new state ABB_STOP_DONE + case ABB_STOP_DONE: + { + //sundi:continue to be in this state till an I2C write ACK comes. + //abb_write_done is set to 1 by the call back function + //that is passed to the I2C write function. + if (l1s.abb_write_done == 1) + { + *state = DMA_STOP; + } + } + break; +#endif + case DMA_STOP: + { + // Reset the DMA channel + l1s_stereopath_drv_reset_DMA(d_dma_channel_parameter); + + *state = STOP_CON; + } + break; + + case STOP_CON: + { + // Send the stop confirmation message + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_STEREOPATH_DRV_STOP_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR); + + *state = IDLE; + } + break; + + } // switch + } +#endif // CODE_VERSION + #endif // L1_STEREOPATH == 1 + + #if (L1_ANR == 1) + /*-------------------------------------------------------*/ + /* l1s_anr_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : ANR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_anr_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_ANR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.anr_task.parameters.anr_enable) + { + // ANR start requested + //-------------------- + + // Set ANR parameters + l1s_dsp_com.dsp_ndb_ptr->d_anr_min_gain = l1a_l1s_com.anr_task.parameters.min_gain; + l1s_dsp_com.dsp_ndb_ptr->d_anr_div_factor_shift = l1a_l1s_com.anr_task.parameters.div_factor_shift; + l1s_dsp_com.dsp_ndb_ptr->d_anr_ns_level = l1a_l1s_com.anr_task.parameters.ns_level; +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_STATE) +#endif + { + // ANR already started: update the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Set ANR constants + l1s_dsp_com.dsp_ndb_ptr->d_anr_vad_thr = C_ANR_VAD_THR; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_slow = C_ANR_GAMMA_SLOW; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_fast = C_ANR_GAMMA_FAST; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_gain_slow = C_ANR_GAMMA_GAIN_SLOW; + l1s_dsp_com.dsp_ndb_ptr->d_anr_gamma_gain_fast = C_ANR_GAMMA_GAIN_FAST; + l1s_dsp_com.dsp_ndb_ptr->d_anr_thr2 = C_ANR_THR2; + l1s_dsp_com.dsp_ndb_ptr->d_anr_thr4 = C_ANR_THR4; + l1s_dsp_com.dsp_ndb_ptr->d_anr_thr5 = C_ANR_THR5; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr1 = C_ANR_MEAN_RATIO_THR1; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr2 = C_ANR_MEAN_RATIO_THR2; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr3 = C_ANR_MEAN_RATIO_THR3; + l1s_dsp_com.dsp_ndb_ptr->d_anr_mean_ratio_thr4 = C_ANR_MEAN_RATIO_THR4; + + // Enable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // ANR start requested + { + // ANR stop requested + //------------------- +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_STATE) +#endif + { + // Disable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // ANR already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ANR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.anr_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ANR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_ANR == 1 + + #if (L1_ANR == 2) + /*-------------------------------------------------------*/ + /* l1s_anr_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : ANR 2.13 L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_anr_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_ANR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.anr_task.parameters.anr_ul_control == ANR_START || + l1a_l1s_com.anr_task.parameters.anr_ul_control == ANR_UPDATE ) + { + // ANR start or update requested + //------------------------------ + + // Set ANR parameters + l1s_dsp_com.dsp_ndb_ptr->d_anr_control = l1a_l1s_com.anr_task.parameters.control; + l1s_dsp_com.dsp_ndb_ptr->d_anr_ns_level = l1a_l1s_com.anr_task.parameters.ns_level; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_ene_th = l1a_l1s_com.anr_task.parameters.tone_ene_th; + l1s_dsp_com.dsp_ndb_ptr->d_anr_tone_cnt_th = l1a_l1s_com.anr_task.parameters.tone_cnt_th; + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) + { + // ANR already started: update the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_FULL_UPDATE; + l1s.anr_ul_action = ANR_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_ENABLE; + l1s.anr_ul_action = ANR_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + + if (l1a_l1s_com.anr_task.parameters.anr_ul_control == ANR_STOP) + { + // ANR stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ANR_UL_STATE) + { + // Disable the DSP ANR module + l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl = B_ANR_DISABLE; + l1s.anr_ul_action = ANR_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // ANR already disabled: confirm + // Allocate confirmation message... + l1s.anr_ul_action = ANR_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_ANR_CON; + ((T_L1_AQI_ANR_CON *)(conf_msg->SigP))->anr_ul_action = l1s.anr_ul_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.anr_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_anr_ul_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_ANR_CON; + ((T_L1_AQI_ANR_CON *)(conf_msg->SigP))->anr_ul_action = l1s.anr_ul_action; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_ANR == 2 + + #if (L1_IIR == 1) + /*-------------------------------------------------------*/ + /* l1s_iir_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : IIR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_iir_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_IIR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.iir_task.parameters.iir_enable) + { + UWORD8 i; + + // IIR start requested + //-------------------- + + // Set IIR parameters + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_iir_blocks = l1a_l1s_com.iir_task.parameters.nb_iir_blocks; + + for (i=0; i < (l1a_l1s_com.iir_task.parameters.nb_iir_blocks * 8); i++) + l1s_dsp_com.dsp_ndb_ptr->a_iir_iir_coefs[i] = l1a_l1s_com.iir_task.parameters.iir_coefs[i]; + + l1s_dsp_com.dsp_ndb_ptr->d_iir_nb_fir_coefs = l1a_l1s_com.iir_task.parameters.nb_fir_coefs; + + for (i=0; i < l1a_l1s_com.iir_task.parameters.nb_fir_coefs; i++) + l1s_dsp_com.dsp_ndb_ptr->a_iir_fir_coefs[i] = l1a_l1s_com.iir_task.parameters.fir_coefs[i]; + + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_scaling = l1a_l1s_com.iir_task.parameters.input_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_fir_scaling = l1a_l1s_com.iir_task.parameters.fir_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_input_gain_scaling = l1a_l1s_com.iir_task.parameters.input_gain_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain_scaling = l1a_l1s_com.iir_task.parameters.output_gain_scaling; + l1s_dsp_com.dsp_ndb_ptr->d_iir_output_gain = l1a_l1s_com.iir_task.parameters.output_gain; + l1s_dsp_com.dsp_ndb_ptr->d_iir_feedback = l1a_l1s_com.iir_task.parameters.feedback; + +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_STATE) +#endif + { + // IIR already started: update the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // IIR start requested + { + // IIR stop requested + //------------------- +#if (DSP == 38) || (DSP == 39) + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) +#else + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_STATE) +#endif + { + // Disable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // IIR already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_IIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.iir_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_IIR_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_IIR == 1 + + #if (L1_AGC_UL == 1) + /*-------------------------------------------------------*/ + /* l1s_agc_ul_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AGC_UL L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_agc_ul_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AGC_UL_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.agc_ul_task.parameters.agc_ul_control == AGC_START || + l1a_l1s_com.agc_ul_task.parameters.agc_ul_control == AGC_UPDATE) + { + // AGC_UL start or update requested + //--------------------------------- + + // Set AGC UL parameters + + l1_audio_agc_ul_copy_params(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_UL_STATE) + { + // AGC UL already started: update the DSP AGC UL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = B_AGC_FULL_UPDATE; + l1s.agc_ul_action = AGC_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + + // Enable the DSP AGC UL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = B_AGC_ENABLE; + l1s.agc_ul_action = AGC_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.agc_ul_task.parameters.agc_ul_control == AGC_STOP) + { + // AGC UL stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_UL_STATE) + { + // Disable the DSP AGC UL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl = B_AGC_DISABLE; + l1s.agc_ul_action = AGC_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // AGC UL already disabled: confirm + // Allocate confirmation message... + l1s.agc_ul_action = AGC_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_UL_CON; + ((T_L1_AQI_AGC_UL_CON *)(conf_msg->SigP))->agc_ul_action = l1s.agc_ul_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.agc_ul_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_agc_ul_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_UL_CON; + ((T_L1_AQI_AGC_UL_CON *)(conf_msg->SigP))->agc_ul_action = l1s.agc_ul_action; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_AGC_UL == 1 + + + #if (L1_AGC_DL == 1) + /*-------------------------------------------------------*/ + /* l1s_agc_dl_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : AGC DL L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_agc_dl_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_AGC_DL_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.agc_dl_task.parameters.agc_dl_control == AGC_START || + l1a_l1s_com.agc_dl_task.parameters.agc_dl_control == AGC_UPDATE) + { + // AGC DL start or update requested + //--------------------------------- + + // Set AGC DL parameters + + l1_audio_agc_dl_copy_params(); + + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_DL_STATE) + { + // AGC DL already started: update the DSP AGC DL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = B_AGC_FULL_UPDATE; + l1s.agc_dl_action = AGC_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + + // Enable the DSP AGC DL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = B_AGC_ENABLE; + l1s.agc_dl_action = AGC_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.agc_dl_task.parameters.agc_dl_control == AGC_STOP) + { + // AGC DL stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_AGC_DL_STATE) + { + // Disable the DSP AGC DL module + l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl = B_AGC_DISABLE; + l1s.agc_dl_action = AGC_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // AGC DL already disabled: confirm + // Allocate confirmation message... + l1s.agc_dl_action = AGC_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_DL_CON; + ((T_L1_AQI_AGC_DL_CON *)(conf_msg->SigP))->agc_dl_action = l1s.agc_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.agc_dl_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_agc_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_AGC_DL_CON; + ((T_L1_AQI_AGC_DL_CON *)(conf_msg->SigP))->agc_dl_action = l1s.agc_dl_action; + + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_AGC_DL == 1 + +#if (L1_IIR == 2) + /*-------------------------------------------------------*/ + /* l1s_iir_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : IIR L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_iir_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_IIR_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.iir_task.parameters->iir_dl_control == IIR_START || + l1a_l1s_com.iir_task.parameters->iir_dl_control == IIR_UPDATE ) + { + // IIR start or update requested + //------------------------------ + + l1_audio_iir4x_copy_params(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) + { + // IIR already started: update the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_FULL_UPDATE; + l1s.iir_dl_action = IIR_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_ENABLE; + l1s.iir_dl_action = IIR_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.iir_task.parameters->iir_dl_control == IIR_STOP) + { + // IIR stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_IIR_DL_STATE) + { + // Disable the DSP IIR module + l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl = B_IIR_DISABLE; + l1s.iir_dl_action = IIR_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // IIR already disabled: confirm + // Allocate confirmation message... + l1s.iir_dl_action = IIR_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_IIR_DL_CON; + ((T_L1_AQI_IIR_DL_CON *)(conf_msg->SigP))->iir_dl_action = l1s.iir_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.iir_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_iir_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_IIR_DL_CON; + ((T_L1_AQI_IIR_DL_CON *)(conf_msg->SigP))->iir_dl_action = l1s.iir_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_IIR == 2 + + #if (L1_WCM == 1) + /*-------------------------------------------------------*/ + /* l1s_wcm_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : WCM L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_wcm_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_WCM_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.wcm_task.parameters->wcm_control == WCM_START || + l1a_l1s_com.wcm_task.parameters->wcm_control == WCM_UPDATE ) + { + UWORD8 i; + + // WCM start or update requested + //------------------------------ + + l1s_dsp_com.dsp_ndb_ptr->d_wcm_mode = l1a_l1s_com.wcm_task.parameters->parameters.mode; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_frame_size = l1a_l1s_com.wcm_task.parameters->parameters.frame_size; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_num_sub_frames = l1a_l1s_com.wcm_task.parameters->parameters.num_sub_frames; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_ratio = l1a_l1s_com.wcm_task.parameters->parameters.ratio; + l1s_dsp_com.dsp_ndb_ptr->d_wcm_threshold = l1a_l1s_com.wcm_task.parameters->parameters.threshold; + + for (i=0; i < (WCM_1X_GAIN_TABLE_LENGTH); i++) + { + l1s_dsp_com.dsp_ndb_ptr->a_wcm_gain[i] = l1a_l1s_com.wcm_task.parameters->parameters.gain[i]; + } + + if (l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_status & B_WCM_STATE) + { + // WCM already started: update the DSP WCM module + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = B_WCM_FULL_UPDATE; + l1s.wcm_action = WCM_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP WCM module + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = B_WCM_ENABLE; + l1s.wcm_action = WCM_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.wcm_task.parameters->wcm_control == WCM_STOP) + { + // WCM stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_status & B_WCM_STATE) + { + // Disable the DSP WCM module + l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl = B_WCM_DISABLE; + l1s.wcm_action = WCM_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // WCM already disabled: confirm + // Allocate confirmation message... + l1s.wcm_action = WCM_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_WCM_CON; + ((T_L1_AQI_WCM_CON *)(conf_msg->SigP))->wcm_action = l1s.wcm_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.wcm_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_audio_apps_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_WCM_CON; + ((T_L1_AQI_WCM_CON *)(conf_msg->SigP))->wcm_action = l1s.wcm_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_WCM == 2 + +#if (L1_DRC == 1) + /*-------------------------------------------------------*/ + /* l1s_drc_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : DRC L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_drc_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_DRC_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.drc_task.parameters->drc_dl_control == DRC_START || + l1a_l1s_com.drc_task.parameters->drc_dl_control == DRC_UPDATE) + { + // DRC start or update requested + //------------------------------ + + l1_audio_drc1x_copy_params(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_DRC_DL_STATE) + { + // DRC already started: update the DSP DRC module + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = B_DRC_FULL_UPDATE; + l1s.drc_dl_action = DRC_UPDATED; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP DRC module + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = B_DRC_ENABLE; + l1s.drc_dl_action = DRC_STARTED; + + *state = WAIT_DSP_ACK; + } + } + + if (l1a_l1s_com.drc_task.parameters->drc_dl_control == DRC_STOP) + { + // DRC stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_DRC_DL_STATE) + { + // Disable the DSP DRC module + l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl = B_DRC_DISABLE; + l1s.drc_dl_action = DRC_STOPPED; + + *state = WAIT_DSP_ACK; + } + else + { + // DRC already disabled: confirm + // Allocate confirmation message... + l1s.drc_dl_action = DRC_NO_ACTION; + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_DRC_CON; + ((T_L1_AQI_DRC_CON *)(conf_msg->SigP))->drc_dl_action = l1s.drc_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.drc_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_drc_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_AQI_DRC_CON; + ((T_L1_AQI_DRC_CON *)(conf_msg->SigP))->drc_dl_action = l1s.drc_dl_action; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_DRC == 1 + + #if (L1_LIMITER == 1) + /*-------------------------------------------------------*/ + /* l1s_limiter_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : LIMITER L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_limiter_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1, + WAIT_PARTIAL_UPDATE = 2 + }; + + UWORD8 *state = &l1s.audio_state[L1S_LIMITER_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + /* LIMITER update command */ + /*------------------------*/ + + if (l1a_l1s_com.limiter_task.command.update) + { + if (l1a_l1s_com.limiter_task.parameters.limiter_enable) + { + UWORD8 i; + + // LIMITER start requested + //------------------------ + + // Set LIMITER parameters + l1s_dsp_com.dsp_ndb_ptr->d_lim_block_size = l1a_l1s_com.limiter_task.parameters.block_size; + l1s_dsp_com.dsp_ndb_ptr->d_lim_slope_update_period = l1a_l1s_com.limiter_task.parameters.slope_update_period; + l1s_dsp_com.dsp_ndb_ptr->d_lim_nb_fir_coefs = l1a_l1s_com.limiter_task.parameters.nb_fir_coefs; + + for (i=0; i < ((l1a_l1s_com.limiter_task.parameters.nb_fir_coefs - 1)>>1) + 1; i++) + l1s_dsp_com.dsp_ndb_ptr->a_lim_filter_coefs[i] = l1a_l1s_com.limiter_task.parameters.filter_coefs[i]; + + l1s_dsp_com.dsp_ndb_ptr->d_lim_gain_fall_q15 = l1a_l1s_com.limiter_task.parameters.gain_fall; + l1s_dsp_com.dsp_ndb_ptr->d_lim_gain_rise_q15 = l1a_l1s_com.limiter_task.parameters.gain_rise; + + // a_lim_mul_low/high computation and update + l1_audio_lim_update_mul_low_high(); + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_STATE) + { + // LIMITER already started: update the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // LIMITER start requested + { + // LIMITER stop requested + //----------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_STATE) + { + // Disable the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // LIMITER already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_LIMITER_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.limiter_task.command.update = FALSE; + } // LIMITER update + + /* LIMITER partial update command */ + /*--------------------------------*/ + + else if (l1a_l1s_com.limiter_task.command.partial_update) + { + // Only update if the module is enabled + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_LIM_STATE) + { + // a_lim_mul_low/high computation and update + l1_audio_lim_update_mul_low_high(); + + // Partial update of the DSP LIMITER module + l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl = B_LIM_UPDATE; + + *state = WAIT_PARTIAL_UPDATE; + } + + // Disable the partial update command + l1a_l1s_com.limiter_task.command.partial_update = FALSE; + } + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_LIMITER_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + + case WAIT_PARTIAL_UPDATE: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_lim_dl_ctrl == 0) + { + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_LIMITER == 1 + + #if (L1_ES == 1) + + /*******************************************/ + /* ES configuration tables */ + /*******************************************/ +#pragma DATA_SECTION(default_es_configs,".flashcnst"); +const T_ES_CONFIG default_es_configs[7] = + { + // Behavior 1 + { + (B_ES_UL | B_ES_DL | B_ES_NSF), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_12DB, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_1, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_3DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_15DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 1a + { + (B_ES_UL | B_ES_DL), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_12DB, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_1A, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_3DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_6DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2a + { + (B_ES_UL | B_ES_DL | B_ES_NSF), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_12DB, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2A, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_5DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_5DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_6DB, C_ES_ATT_LIN_24DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2b + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_6DB, + C_ES_TCL_0DB, + C_ES_TCL_10DB, + C_ES_TCL_4DB, + C_ES_TCL_0DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2B, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_8DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_8DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_9DB, C_ES_ATT_LIN_36DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2c + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_M6DB, + C_ES_TCL_M23DB, + C_ES_TCL_0DB, + C_ES_TCL_M6DB, + C_ES_TCL_M3DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2C, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_10DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_10DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_12DB, C_ES_ATT_LIN_48DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 2c_idle + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_M6DB, + C_ES_TCL_M23DB, + C_ES_TCL_0DB, + C_ES_TCL_M6DB, + C_ES_TCL_M3DB, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_2C_IDLE, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_10DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_10DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_12DB, C_ES_ATT_LIN_12DB, C_ES_ATT_LIN_48DB, C_ES_ATT_LIN_0DB} + } , + + // Behavior 3 + { + (B_ES_UL | B_ES_DL | B_ES_CNG), + C_ES_GAIN_DL_OFF, + C_ES_GAIN_UL_1_OFF, + C_ES_GAIN_UL_2_OFF, + C_ES_TCL_B3_FE_LS, + C_ES_TCL_B3_DT_LS, + C_ES_TCL_B3_FE_NS, + C_ES_TCL_B3_DT_NS, + C_ES_TCL_B3_NE, + C_ES_TCL_LOUD, + C_ES_SW_CNT, + C_ES_DT_CNT, + C_ES_HG_CNT_3, + /* DL attenuation */ + {C_ES_ATT_LIN_3DB, C_ES_ATT_LIN_16DB, C_ES_ATT_LIN_0DB, C_ES_ATT_LIN_21DB}, + /* UL attenuation */ + {C_ES_ATT_LIN_19DB, C_ES_ATT_LIN_19DB, C_ES_ATT_LIN_66DB, C_ES_ATT_LIN_0DB} + } + }; + + /*-------------------------------------------------------*/ + /* l1s_es_manager() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : */ + /* */ + /* Return : */ + /* */ + /* Description : ES L1S manager task. */ + /* */ + /*-------------------------------------------------------*/ + void l1s_es_manager(void) + { + enum states + { + IDLE = 0, + WAIT_DSP_ACK = 1 + }; + + UWORD8 *state = &l1s.audio_state[L1S_ES_STATE]; + xSignalHeaderRec *conf_msg; + + switch(*state) + { + case IDLE: + { + if (l1a_l1s_com.es_task.parameters.es_enable) + { + const T_ES_CONFIG *es_cfg; + + // ES start requested + //-------------------- + + // Set ES parameters + if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM) + { + es_cfg = &(l1a_l1s_com.es_task.parameters.es_config); + } + else + { + es_cfg = &(default_es_configs[l1a_l1s_com.es_task.parameters.es_behavior]); + } + + // Set parameters in the API + l1s_dsp_com.dsp_ndb_ptr->d_es_mode = es_cfg->es_mode; + l1s_dsp_com.dsp_ndb_ptr->d_es_gain_dl = es_cfg->es_gain_dl; + l1s_dsp_com.dsp_ndb_ptr->d_es_gain_ul_1 = es_cfg->es_gain_ul_1; + l1s_dsp_com.dsp_ndb_ptr->d_es_gain_ul_2 = es_cfg->es_gain_ul_2; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_fe_ls_thr = es_cfg->tcl_fe_ls_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_dt_ls_thr = es_cfg->tcl_dt_ls_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_fe_ns_thr = es_cfg->tcl_fe_ns_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_dt_ns_thr = es_cfg->tcl_dt_ns_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_tcl_ne_thr = es_cfg->tcl_ne_thr; + l1s_dsp_com.dsp_ndb_ptr->d_es_ref_ls_pwr = es_cfg->ref_ls_pwr; + l1s_dsp_com.dsp_ndb_ptr->d_es_switching_time = es_cfg->switching_time; + l1s_dsp_com.dsp_ndb_ptr->d_es_switching_time_dt = es_cfg->switching_time_dt; + l1s_dsp_com.dsp_ndb_ptr->d_es_hang_time = es_cfg->hang_time; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[0] = es_cfg->gain_lin_dl_vect[0]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[1] = es_cfg->gain_lin_dl_vect[1]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[2] = es_cfg->gain_lin_dl_vect[2]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_dl_vect[3] = es_cfg->gain_lin_dl_vect[3]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[0] = es_cfg->gain_lin_ul_vect[0]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[1] = es_cfg->gain_lin_ul_vect[1]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[2] = es_cfg->gain_lin_ul_vect[2]; + l1s_dsp_com.dsp_ndb_ptr->a_es_gain_lin_ul_vect[3] = es_cfg->gain_lin_ul_vect[3]; + + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ES_STATE) + { + // ES already started: update the DSP ES module + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = B_ES_FULL_UPDATE; + + *state = WAIT_DSP_ACK; + } + else + { + // Enable the DSP ES module + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = B_ES_ENABLE; + + *state = WAIT_DSP_ACK; + } + } + else // ES start requested + { + // ES stop requested + //------------------- + if (l1s_dsp_com.dsp_ndb_ptr->d_aqi_status & B_ES_STATE) + { + // Disable the DSP ES module + l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl = B_ES_DISABLE; + + *state = WAIT_DSP_ACK; + } + else + { + // ES already disabled: confirm + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ES_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Disable the update command + l1a_l1s_com.es_task.command.update = FALSE; + } + break; + + case WAIT_DSP_ACK: + { + // The DSP acknowledged the L1S command + if (l1s_dsp_com.dsp_ndb_ptr->d_es_ctrl == 0) + { + // Allocate confirmation message... + conf_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + conf_msg->SignalCode = L1_ES_CON; + // Send confirmation message... + os_send_sig(conf_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + + *state = IDLE; + } + } + break; + } // switch + } + #endif // L1_ES == 1 + +#endif // AUDIO_TASK