FreeCalypso > hg > fc-tourmaline
diff src/cs/layer1/audio_cfile/l1audio_async.c @ 0:4e78acac3d88
src/{condat,cs,gpf,nucleus}: import from Selenite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Fri, 16 Oct 2020 06:23:26 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cs/layer1/audio_cfile/l1audio_async.c Fri Oct 16 06:23:26 2020 +0000 @@ -0,0 +1,10707 @@ +/************* 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 (AEC == 1) + void l1a_mmi_aec_process (xSignalHeaderRec *msg); + #endif + #if (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 + #if 0 /* FreeCalypso TCS211 reconstruction */ + VM_AMR_PLAY = 5, + VM_AMR_PAUSE = 6, + VM_AMR_PAUSE_CON = 7, + WAIT_RESUME_CON = 8 + #endif + }; + + 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; + #if 0 /* FreeCalypso TCS211 reconstruction */ + l1a_l1s_com.voicememo_amr_task.play.command.pause = FALSE; + l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE; + #endif + *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[VOICE_PLAY_AMR_SM]==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[VOICE_PLAY_AMR_SM] == 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 = WAIT_STOP; + } + + // End process + return; + } + // omaps00090550 break; + + case WAIT_STOP: + { + if (SignalCode == MMI_VM_AMR_PLAY_STOP_REQ) + { + // Stop the L1S voice memo playing task + l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE; + + // End process + return; + } + 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; + } + else + { + // End process + return; + } + } + break; + + #if 0 /* FreeCalypso TCS211 reconstruction */ + 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 + #endif + } // 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[VOICE_MEMO_AMR_SM]==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[VOICE_MEMO_AMR_SM] == 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[SPEECH_RECO_SM]==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[SPEECH_RECO_SM] == 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_internal, + 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_internal, + 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_internal, + 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[SPEECH_RECO_SM] == 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[SPEECH_RECO_SM] == 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_internal, + 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_internal, + 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_internal, + 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[SPEECH_RECO_SM] == 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[SPEECH_RECO_SM] == 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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[SPEECH_RECO_SM] == 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[SPEECH_RECO_SM] == 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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_internal, + 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 (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 0 //(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 (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 0 //(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 // 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 0 //((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 0 //((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 0 //((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 0 //((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 0 //((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 0 //((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 0 //((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 0 //((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 0 //((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 + +#if 0 /* FreeCalypso: LoCosto-ism removed */ + 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 */ +#endif + +#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 +