diff gsm-fw/L1/audio_cfile/l1audio_async.c @ 606:c5286d24539e

gsm-fw/L1/audio_cfile: initial import from LoCosto source
author Michael Spacefalcon <msokolov@ivan.Harhan.ORG>
date Fri, 29 Aug 2014 03:25:51 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gsm-fw/L1/audio_cfile/l1audio_async.c	Fri Aug 29 03:25:51 2014 +0000
@@ -0,0 +1,10690 @@
+/************* Revision Controle System Header *************
+ *                  GSM Layer 1 software
+ * L1AUDIO_ASYNC.C
+ *
+ *        Filename l1audio_async.c
+ *  Copyright 2003 (C) Texas Instruments
+ *
+ ************* Revision Controle System Header *************/
+
+/************************************/
+/* Include files...                 */
+/************************************/
+
+#include "l1_macro.h"
+#include "l1_confg.h"
+
+#if (AUDIO_TASK == 1)
+
+  #include "l1_types.h"
+  #include "sys_types.h"
+
+  #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION)
+
+    #include <stdlib.h>
+    #include <string.h>
+
+    #include "iq.h"             // Debug / Init hardware  ("eva3.lib")
+    #include "l1_ver.h"
+    #include "l1_const.h"
+    #include "l1_signa.h"
+    #include "cust_os.h"
+
+    #if TESTMODE
+      #include "l1tm_defty.h"
+    #endif
+
+    #include "l1audio_const.h"
+    #include "l1audio_cust.h"
+    #include "l1audio_signa.h"
+    #include "l1audio_defty.h"
+    #include "l1audio_msgty.h"
+    #include "l1audio_varex.h"
+    #include "l1audio_proto.h"
+
+    #if (L1_GTT == 1)
+      #include "l1gtt_const.h"
+      #include "l1gtt_defty.h"
+    #endif
+
+    #if (L1_MIDI == 1)
+      #include "l1midi_defty.h"
+    #endif
+
+
+    #if (L1_MP3 == 1)
+      #include "l1mp3_defty.h"
+    #endif
+
+    #if (L1_AAC == 1)
+      #include "l1aac_defty.h"
+    #endif
+    #if (L1_DYN_DSP_DWNLD==1)
+     #include "l1_dyn_dwl_defty.h"
+     #include "l1_dyn_dwl_const.h"
+     #include "l1_dyn_dwl_signa.h"
+    #endif
+
+    #include "l1_defty.h"
+    #include "l1_msgty.h"
+    #include "l1_varex.h"
+
+    #include "l1_mftab.h"
+    #include "l1_tabs.h"
+    #include "l1_ctl.h"
+
+
+    #include "l1_time.h"
+    #include "l1_scen.h"
+
+  #else
+
+    // Layer1 and debug include files.
+    #include <ctype.h>
+    #include <math.h>
+    #include "l1_ver.h"
+    #include "l1_const.h"
+    #include "l1_signa.h"
+    #include "cust_os.h"
+
+    #if TESTMODE
+      #include "l1tm_defty.h"
+    #endif
+
+    #include "l1audio_const.h"
+    #include "l1audio_cust.h"
+    #include "l1audio_signa.h"
+    #include "l1audio_defty.h"
+    #include "l1audio_msgty.h"
+    #include "l1audio_varex.h"
+    #include "l1audio_proto.h"
+
+    #if (L1_GTT == 1)
+      #include "l1gtt_const.h"
+      #include "l1gtt_defty.h"
+    #endif
+
+    #if (L1_MP3 == 1)
+      #include "l1mp3_defty.h"
+    #endif
+
+    #if (L1_MIDI == 1)
+      #include "l1midi_defty.h"
+    #endif
+
+    #if (L1_AAC == 1)
+      #include "l1aac_defty.h"
+    #endif
+
+    #if (L1_DYN_DSP_DWNLD==1)
+     #include "l1_dyn_dwl_defty.h"
+     #include "l1_dyn_dwl_const.h"
+     #include "l1_dyn_dwl_signa.h"
+    #endif
+
+#if (RF_FAM == 61)
+#include "l1_rf61.h"
+#endif 
+
+    #include "l1_defty.h"
+    #include "l1_msgty.h"
+    #include "tpudrv.h"       // TPU drivers.           ("eva3.lib")
+    #include "l1_varex.h"
+
+    #include "l1_proto.h"
+    #include "l1_mftab.h"
+    #include "l1_tabs.h"
+    #include "mem.h"
+    #include "armio.h"
+    #include "timer.h"
+    #include "timer1.h"
+    #include "dma.h"
+    #include "inth.h"
+    #include "ulpd.h"
+    #include "rhea_arm.h"
+    #include "clkm.h"         // Clockm  ("eva3.lib")
+    #include "l1_ctl.h"
+
+    #include "l1_time.h"
+
+    #if L2_L3_SIMUL
+      #include "l1_scen.h"
+    #endif
+
+    #if (OP_RIV_AUDIO == 1)
+      #include "rv_general.h"
+      #include "audio_api.h"
+      #include "audio_structs_i.h"
+      #include "audio_var_i.h"
+      #include "audio_macro_i.h"
+      #include "audio_const_i.h"
+    #endif
+  #endif
+
+  #include "l1audio_macro.h"
+
+  #if(L1_DYN_DSP_DWNLD == 1)
+    #if (TRACE_TYPE == 1) ||(TRACE_TYPE == 4) || (TRACE_TYPE == 5) || (TRACE_TYPE == 7) || (TESTMODE)
+      #include "l1_trace.h"
+    #endif
+    #if(CODE_VERSION == SIMULATION)
+      extern void trace_fct_simu_dyn_dwnld(CHAR *fct_name);
+    #endif
+  #endif
+
+#if 0
+  #if (L1_MP3)
+     extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR
+  #endif
+//#pragma DUPLICATE_FOR_INTERNAL_RAM_END
+
+#endif
+#if ( L1_AAC)
+extern UWORD16  a_aac_dma_input_buffer[2][C_AAC_OUTPUT_BUFFER_SIZE];
+extern UWORD8   d_aac_dma_current_buffer_id;
+
+#endif
+
+#if (L1_MP3)
+extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR
+#endif
+  /**************************************/
+  /* Prototypes for L1 ASYNCH task      */
+  /**************************************/
+  #if (OP_RIV_AUDIO == 1)
+    #if (L1_AUDIO_DRIVER == 1)
+      void l1a_audio_driver_process     (xSignalHeaderRec *msg);
+    #endif
+  #endif
+  #if (KEYBEEP)
+    void l1a_mmi_keybeep_process        (xSignalHeaderRec *msg);
+  #endif
+  #if (TONE)
+    void l1a_mmi_tone_process           (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_CPORT == 1)
+    void l1a_mmi_cport_process          (xSignalHeaderRec *msg);
+  #endif
+  #if (MELODY_E1)
+    void l1a_mmi_melody0_process        (xSignalHeaderRec *msg);
+    void l1a_mmi_melody1_process        (xSignalHeaderRec *msg);
+  #endif
+  #if (VOICE_MEMO)
+    void l1a_mmi_vm_playing_proccess    (xSignalHeaderRec *msg);
+    void l1a_mmi_vm_recording_process   (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_PCM_EXTRACTION)
+    void l1a_mmi_pcm_download_process   (xSignalHeaderRec *msg);
+    void l1a_mmi_pcm_upload_process     (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_VOICE_MEMO_AMR)
+    void l1a_mmi_vm_amr_playing_proccess (xSignalHeaderRec *msg);
+    void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg);
+  #endif
+  #if (SPEECH_RECO)
+    void l1a_mmi_sr_enroll_process      (xSignalHeaderRec *msg);
+    void l1a_mmi_sr_update_process      (xSignalHeaderRec *msg);
+    void l1a_mmi_sr_reco_process        (xSignalHeaderRec *msg);
+    void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg);
+  #endif
+  #if (L1_AEC == 1)
+    void l1a_mmi_aec_process            (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_AEC == 2)
+    void l1a_mmi_aec_process            (xSignalHeaderRec *msg);
+  #endif
+  #if (FIR)
+    void l1a_mmi_fir_process            (xSignalHeaderRec *msg);
+  #endif
+  #if (AUDIO_MODE)
+    void l1a_mmi_audio_mode_process     (xSignalHeaderRec *msg);
+  #endif
+  #if (MELODY_E2)
+    void l1a_mmi_melody0_e2_process     (xSignalHeaderRec *msg);
+    void l1a_mmi_melody1_e2_process     (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1)
+    void l1a_mmi_audio_onoff_process     (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_EXT_AUDIO_MGT == 1)
+    void l1a_mmi_ext_audio_mgt_process   (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_ANR == 1 || L1_ANR == 2)
+    void l1a_mmi_anr_process             (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_AGC_UL == 1)
+    void l1a_mmi_agc_ul_process           (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_AGC_DL == 1)
+    void l1a_mmi_agc_dl_process           (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_IIR == 1 || L1_IIR == 2)
+    void l1a_mmi_iir_process             (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_WCM == 1)
+    void l1a_mmi_wcm_process           (xSignalHeaderRec *msg);
+  #endif
+#if (L1_DRC == 1)
+    void l1a_mmi_drc_process             (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_LIMITER == 1)
+    void l1a_mmi_limiter_process         (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_ES == 1)
+    void l1a_mmi_es_process              (xSignalHeaderRec *msg);
+  #endif
+  #if (L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_vocoder_cfg_process(xSignalHeaderRec *msg);
+  #endif
+#if(L1_BT_AUDIO==1)
+   void l1a_mmi_bt_process(xSignalHeaderRec *msg);
+#endif
+  /**************************************/
+  /* External prototypes                */
+  /**************************************/
+  extern UWORD8  copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst);
+  extern UWORD8  copy_data_to_buffer   (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src);
+  extern UWORD8  Cust_get_pointer      (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id);
+  #if (MELODY_E2)
+    extern UWORD8  copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst);
+    extern UWORD8  copy_byte_data_to_buffer   (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src);
+  #endif
+  #if (L1_EXT_AUDIO_MGT == 1)
+   T_MIDI_DMA_PARAM midi_buf;
+  #if (CODE_VERSION == NOT_SIMULATION)
+#pragma DATA_SECTION(midi_buf,".l1s_global")
+#endif
+    extern void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status);
+  #endif
+  #if(L1_BT_AUDIO ==1)
+   BOOL midi_task_running;
+   extern T_L1_BT_AUDIO bt_audio;
+   extern void l1_audio_bt_init(UINT16 media_buf_size);
+  #endif
+
+  #if (OP_RIV_AUDIO == 1)
+    #if (L1_AUDIO_DRIVER == 1)
+      void l1a_audio_driver_process(xSignalHeaderRec *msg)
+      {
+        UWORD32 SignalCode = msg->SignalCode;
+
+        if (SignalCode == L1_AUDIO_DRIVER_IND)
+          l1a_audio_send_result(AUDIO_DRIVER_NOTIFICATION_MSG, msg, MMI_QUEUE);
+      }
+    #endif
+  #endif
+
+  #if (KEYBEEP)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_keybeep_process()                             */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* keybeep feature.                                      */
+    /*                                                       */
+    /* Starting messages:        MMI_KEYBEEP_START_REQ       */
+    /*                                                       */
+    /* Result messages (input):  L1_KEYBEEP_START_CON        */
+    /*                                                       */
+    /* Result messages (output): MMI_KEYBEEP_START_CON       */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_KEYBEEP_STOP_REQ        */
+    /*                           L1_KEYBEEP_STOP_CON         */
+    /*                                                       */
+    /* Stop message (output):    MMI_KEYBEEP_STOP_CON        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_keybeep_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_KEYBEEP_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.keybeep_task.command.start = FALSE;
+            l1a_l1s_com.keybeep_task.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_KEYBEEP_START_REQ)
+            {
+              // Download the keybeep description in the NDB.
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt0= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt0;
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt1= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt1;
+              l1s_dsp_com.dsp_ndb_ptr->d_dur_kb  = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_dur_kb;
+
+              // Start the L1S keybeep task
+              l1a_l1s_com.keybeep_task.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+ // OMPAS00090550           break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_KEYBEEP_START_CON)
+            {
+              // Disable the start command
+              l1a_l1s_com.keybeep_task.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_KEYBEEP_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // ompas00090550           break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_KEYBEEP_STOP_REQ)
+            {
+              // Stop the L1S keybeep task
+              l1a_l1s_com.keybeep_task.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_KEYBEEP_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_KEYBEEP_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+     // omaps00090550       break;
+        } // switch
+      } // while(1)
+    }
+  #endif // KEYBEEP
+
+  #if (TONE)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_tone_process()                                */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* tone feature.                                         */
+    /*                                                       */
+    /* Starting messages:        MMI_TONE_START_REQ          */
+    /*                                                       */
+    /* Result messages (input):  L1_TONE_START_CON           */
+    /*                                                       */
+    /* Result messages (output): MMI_TONE_START_CON          */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_TONE_STOP_REQ           */
+    /*                           L1_TONE_STOP_CON            */
+    /*                                                       */
+    /* Stop message (output):    MMI_TONE_STOP_CON           */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_tone_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_TONE_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.tone_task.command.start = FALSE;
+            l1a_l1s_com.tone_task.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_TONE_START_REQ)
+            {
+              // Download the tone description in the NDB.
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t0;
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t1;
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t2;
+              l1s_dsp_com.dsp_ndb_ptr->d_pe_rep  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_rep;
+              l1s_dsp_com.dsp_ndb_ptr->d_pe_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_se_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_se_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_bu_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_bu_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_t0_on   = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_on;
+              l1s_dsp_com.dsp_ndb_ptr->d_t0_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_t1_on   = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_on;
+              l1s_dsp_com.dsp_ndb_ptr->d_t1_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_t2_on   = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_on;
+              l1s_dsp_com.dsp_ndb_ptr->d_t2_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_off;
+
+
+              // Start the L1S tone task
+              l1a_l1s_com.tone_task.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+   //omaps00090550          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_TONE_START_CON)
+            {
+              // Disable the start command
+              l1a_l1s_com.tone_task.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_TONE_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_TONE_STOP_REQ)
+            {
+              // Stop the L1S tone task
+              l1a_l1s_com.tone_task.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_TONE_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_TONE_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // TONE
+
+
+
+
+
+  #if (MELODY_E1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_melody0_process()                             */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* melody 0 feature.                                     */
+    /*                                                       */
+    /* Starting messages:        MMI_MELODY0_START_REQ       */
+    /*                                                       */
+    /* Result messages (input):  L1_MELODY0_START_CON        */
+    /*                                                       */
+    /* Result messages (output): MMI_MELODY0_START_CON       */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_MELDOY0_STOP_REQ        */
+    /*                           L1_MELODY0_STOP_CON         */
+    /*                                                       */
+    /* Stop message (output):    MMI_MELODY0_STOP_CON        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_melody0_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        M0_RESET            = 0,
+        M0_WAIT_START_REQ   = 1,
+        M0_WAIT_START_CON   = 2,
+        M0_WAIT_STOP        = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_MELODY0_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+      UWORD8    melody_osc, used_osc;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case M0_RESET:
+          {
+            // Reset the commands:
+            l1a_l1s_com.melody0_task.command.start = FALSE;
+            l1a_l1s_com.melody0_task.command.stop  = FALSE;
+
+            // Initialize the translation table
+            for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++)
+              l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR;
+
+            *state = M0_WAIT_START_REQ;
+          }
+          break;
+
+          case M0_WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_MELODY0_START_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.melody0_task.parameters.session_id                = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.melody0_task.parameters.loopback                  = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback;
+              l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap    = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap;
+
+              // Initialize the buffer parameters
+              l1a_l1s_com.melody0_task.parameters.ptr_buf        = NULL;
+              l1a_l1s_com.melody0_task.parameters.buffer_size    = 0;
+              l1a_l1s_com.melody0_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf,
+                                                                              &l1a_l1s_com.melody0_task.parameters.buffer_size,
+                                                                              l1a_l1s_com.melody0_task.parameters.session_id);
+
+              // Read the Header of the melody description to have the melody bitmap
+              l1a_l1s_com.melody0_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_task.parameters.buffer_size,
+                                                                                   (UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap);
+
+              l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT);
+
+              // Build the array of translation between the melody mapping and the oscillators used
+              used_osc = 0;
+              melody_osc = 0;
+              while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
+              {
+                // find the next oscillator available in the melody
+                while( ((l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
+                  melody_osc++;
+
+                // find the next oscillator available in the oscillator used
+                while( ((l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
+                  used_osc++;
+
+                // Fill the translation table
+                if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
+                  l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = used_osc;
+                melody_osc++;
+                used_osc++;
+              }
+
+              // Start the melody 0 L1S task:
+              l1a_l1s_com.melody0_task.command.start = TRUE;
+
+              *state = M0_WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+
+          case M0_WAIT_START_CON:
+          {
+            if (SignalCode == L1_MELODY0_START_CON)
+            {
+              // Disable the start command
+              l1a_l1s_com.melody0_task.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY0_START_CON);
+
+              *state = M0_WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+
+          case M0_WAIT_STOP:
+          {
+            if (SignalCode == L1_MELODY0_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY0_STOP_CON);
+
+              *state = M0_RESET;
+            }
+            else
+            if (SignalCode == MMI_MELODY0_STOP_REQ)
+            {
+              // Stop the melody 0 L1S task:
+              l1a_l1s_com.melody0_task.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_melody1_process()                             */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* melody 1 feature.                                     */
+    /*                                                       */
+    /* Starting messages:        MMI_MELODY1_START_REQ       */
+    /*                                                       */
+    /* Result messages (input):  L1_MELODY1_START_CON        */
+    /*                                                       */
+    /* Result messages (output): MMI_MELODY1_START_CON       */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_MELDOY1_STOP_REQ        */
+    /*                           L1_MELODY1_STOP_CON         */
+    /*                                                       */
+    /* Stop message (output):    MMI_MELODY1_STOP_CON        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_melody1_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        M1_RESET            = 0,
+        M1_WAIT_START_REQ   = 1,
+        M1_WAIT_START_CON   = 2,
+        M1_WAIT_STOP        = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_MELODY1_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+      UWORD8    melody_osc, used_osc;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case M1_RESET:
+          {
+            // Reset the commands:
+            l1a_l1s_com.melody1_task.command.start = FALSE;
+            l1a_l1s_com.melody1_task.command.stop  = FALSE;
+
+            // Initialize the translation table
+            for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++)
+              l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR;
+
+
+            *state = M1_WAIT_START_REQ;
+          }
+          break;
+
+          case M1_WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_MELODY1_START_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.melody1_task.parameters.session_id                = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.melody1_task.parameters.loopback                  = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback;
+              l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap    = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap;
+
+              // Initialize the buffer parameters
+              l1a_l1s_com.melody1_task.parameters.ptr_buf        = NULL;
+              l1a_l1s_com.melody1_task.parameters.buffer_size    = 0;
+              l1a_l1s_com.melody1_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf,
+                                                                              &l1a_l1s_com.melody1_task.parameters.buffer_size,
+                                                                              l1a_l1s_com.melody1_task.parameters.session_id);
+
+              // Read the Header of the melody description to have the melody bitmap
+              l1a_l1s_com.melody1_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_task.parameters.buffer_size,
+                                                                                   (UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap);
+
+              l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT);
+              // Build the array of translation between the melody maaping and the oscillators used
+              used_osc = 0;
+              melody_osc = 0;
+              while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
+              {
+                // find the next oscillator available in the melody
+                while( ((l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
+                  melody_osc++;
+
+                // find the next oscillator available in the oscillator used
+                while( ((l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
+                  used_osc++;
+
+                // Fill the translation table
+                if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
+                  l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = used_osc;
+                melody_osc++;
+                used_osc++;
+              }
+
+              // Start the melody 1 L1S task:
+              l1a_l1s_com.melody1_task.command.start = TRUE;
+
+              *state = M1_WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+
+          case M1_WAIT_START_CON:
+          {
+            if (SignalCode == L1_MELODY1_START_CON)
+            {
+              // Disable the start command
+              l1a_l1s_com.melody1_task.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY1_START_CON);
+
+              *state = M1_WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+          case M1_WAIT_STOP:
+          {
+            if (SignalCode == L1_MELODY1_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY1_STOP_CON);
+
+              *state = M1_RESET;
+            }
+            else
+            if (SignalCode == MMI_MELODY1_STOP_REQ)
+            {
+              // Stop the melody 0 L1S task:
+              l1a_l1s_com.melody1_task.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // MELODY_E1
+
+#if (VOICE_MEMO)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_vm_playing_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* voice memorization playing feature.                   */
+    /*                                                       */
+    /* Starting messages:        MMI_VM_PLAY_START_REQ       */
+    /*                                                       */
+    /* Result messages (input):  L1_VM_PLAY_START_CON        */
+    /*                                                       */
+    /* Result messages (output): MMI_VM_PLAY_START_CON       */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_VM_PLAY_STOP_REQ        */
+    /*                           L1_VM_PLAY_STOP_CON         */
+    /*                                                       */
+    /* Stop message (output):    MMI_VM_PLAY_STOP_CON        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_vm_playing_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_VM_PLAY_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.voicememo_task.play.command.start = FALSE;
+            l1a_l1s_com.voicememo_task.play.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_VM_PLAY_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.voicememo_task.play.parameters.session_id =  ((T_MMI_VM_PLAY_REQ *)(msg->SigP))->session_id;
+
+              // Start the L1S voice memo playing task
+              l1a_l1s_com.voicememo_task.play.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550        break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_VM_PLAY_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.voicememo_task.play.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_VM_PLAY_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550         break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_VM_PLAY_STOP_REQ)
+            {
+              // Stop the L1S voice memo playing task
+              l1a_l1s_com.voicememo_task.play.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_VM_PLAY_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_VM_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_vm_recording_process()                        */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* voice memorization recording feature.                 */
+    /*                                                       */
+    /* Starting messages:        MMI_VM_RECORD_START_REQ     */
+    /*                                                       */
+    /* Result messages (input):  L1_VM_RECORD_START_CON      */
+    /*                                                       */
+    /* Result messages (output): MMI_VM_RECORD_START_CON     */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_VM_RECORD_STOP_REQ      */
+    /*                           L1_VM_RECORD_STOP_CON       */
+    /*                                                       */
+    /* Stop message (output):    MMI_VM_RECORD_STOP_CON      */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_vm_recording_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_VM_RECORD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.voicememo_task.record.command.start = FALSE;
+            l1a_l1s_com.voicememo_task.record.command.stop  = FALSE;
+            l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_VM_RECORD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.voicememo_task.record.parameters.session_id   =  ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.voicememo_task.record.parameters.maximum_size =  ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->maximum_size;
+              l1a_l1s_com.voicememo_task.record.parameters.dtx          =  ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->dtx_used;
+
+              // Download UL/DL audio gain to the NDB
+              l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_ul;
+              l1s_dsp_com.dsp_ndb_ptr->d_shiftdl = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_dl;
+
+              // Download the tone description in the NDB.
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t0;
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t1;
+              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t2;
+              l1s_dsp_com.dsp_ndb_ptr->d_pe_rep  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_rep;
+              l1s_dsp_com.dsp_ndb_ptr->d_pe_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_se_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_se_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_bu_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_bu_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_t0_on   = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_on;
+              l1s_dsp_com.dsp_ndb_ptr->d_t0_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_t1_on   = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_on;
+              l1s_dsp_com.dsp_ndb_ptr->d_t1_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_off;
+              l1s_dsp_com.dsp_ndb_ptr->d_t2_on   = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_on;
+              l1s_dsp_com.dsp_ndb_ptr->d_t2_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_off;
+
+              // Start the L1S voice memo recording task
+              l1a_l1s_com.voicememo_task.record.command.start = TRUE;
+
+              // Start the L1S voice memo tone uplink task
+              l1a_l1s_com.voicememo_task.record.tone_ul.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550      break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_VM_RECORD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE;
+
+              // Reset the start command
+              l1a_l1s_com.voicememo_task.record.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_VM_RECORD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550         break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_VM_RECORD_STOP_REQ)
+            {
+              // Stop the L1S voice memo recording task
+              l1a_l1s_com.voicememo_task.record.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_VM_RECORD_STOP_CON)
+            {
+              // Forward the stop confirmation message
+              l1a_audio_send_result(MMI_VM_RECORD_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // VOICE_MEMO
+
+  #if (L1_PCM_EXTRACTION)
+  #if (L1_DYN_DSP_DWNLD == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_pcm_download_process()                        */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* PCM download feature.                                 */
+    /*                                                       */
+    /* Starting messages:        MMI_PCM_DOWNLOAD_START_REQ  */
+    /*                                                       */
+    /* Result messages (input):  L1_PCM_DOWNLOAD_START_CON   */
+    /*                                                       */
+    /* Result messages (output): MMI_PCM_DOWNLOAD_START_CON  */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_PCM_DOWNLOAD_STOP_REQ   */
+    /*                           L1_PCM_DOWNLOAD_STOP_CON    */
+    /*                                                       */
+    /* Stop message (output):    MMI_PCM_DOWNLOAD_STOP_CON   */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_START_CON    = 3,
+        WAIT_STOP         = 4
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_PCM_DOWNLOAD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      BOOL end_process = 0;
+
+      while(!end_process)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.pcm_task.download.command.start = FALSE;
+            l1a_l1s_com.pcm_task.download.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.pcm_task.download.parameters.session_id =  ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size;
+
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1);
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |=
+                                                        ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8);
+
+            if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN)
+            {
+              // Start the L1S PCM download task
+              l1a_l1s_com.pcm_task.download.command.start = TRUE;
+              *state = WAIT_START_CON;
+		    }
+		    else
+		    {
+			  *state = WAIT_DYN_DWNLD;
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[30];
+                   sprintf(str,"PCM Extraction SM blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                 }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+		}
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN))
+             {
+                 // Start the L1S PCM download task
+                l1a_l1s_com.pcm_task.download.command.start = TRUE;
+                *state = WAIT_START_CON;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[32];
+                   sprintf(str,"PCM Extraction SM un-blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                 }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+             }
+            // End process
+            end_process = 1;
+		  }
+		  break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_PCM_DOWNLOAD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.pcm_task.download.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+
+            UWORD32 maximum_size;
+
+            if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ)
+            {
+              maximum_size =  ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size;
+              if(maximum_size == 0)
+              {
+              // Stop the L1S PCM download task
+              l1a_l1s_com.pcm_task.download.command.stop = TRUE;
+              }
+              else
+              {
+                l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size;
+
+              }
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(!end_process)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_pcm_upload_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* PCM upload feature.                                   */
+    /*                                                       */
+    /* Starting messages:        MMI_PCM_UPLOAD_START_REQ    */
+    /*                                                       */
+    /* Result messages (input):  L1_PCM_UPLOAD_START_CON     */
+    /*                                                       */
+    /* Result messages (output): MMI_PCM_UPLOAD_START_CON    */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_PCM_UPLOAD_STOP_REQ     */
+    /*                           L1_PCM_UPLOAD_STOP_CON      */
+    /*                                                       */
+    /* Stop message (output):    MMI_PCM_UPLOAD_STOP_CON     */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_START_CON    = 3,
+        WAIT_STOP         = 4
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_PCM_UPLOAD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      BOOL end_process = 0;
+
+      while(!end_process)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.pcm_task.upload.command.start = FALSE;
+            l1a_l1s_com.pcm_task.upload.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_PCM_UPLOAD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.pcm_task.upload.parameters.session_id   =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.pcm_task.upload.parameters.maximum_size =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size;
+
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1);
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8);
+
+            if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN)
+            {
+              // Start the L1S PCM upload task
+              l1a_l1s_com.pcm_task.upload.command.start = TRUE;
+              *state = WAIT_START_CON;
+		    }
+		    else
+		    {
+			  *state = WAIT_DYN_DWNLD;
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[30];
+                   sprintf(str,"PCM Extraction SM blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                 }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+
+
+          }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN))
+             {
+                 // Start the L1S PCM upload task
+                l1a_l1s_com.pcm_task.upload.command.start = TRUE;
+                *state = WAIT_START_CON;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[32];
+                   sprintf(str,"PCM Extraction SM un-blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                 }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+             }
+            // End process
+            end_process = 1;
+		  }
+		  break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_PCM_UPLOAD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.pcm_task.upload.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ)
+            {
+              // Stop the L1S PCM recording task
+              l1a_l1s_com.pcm_task.upload.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_PCM_UPLOAD_STOP_CON)
+            {
+              // Forward the stop confirmation message
+              l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(!end_process)
+    }
+
+#else /*L1_DYN_DSP_DWNLD == 0
+
+// l1a_mmi_pcm_download_process()
+// Description:
+// This function is a state machine which handles the    */
+//     PCM download feature.
+    // Starting messages:        MMI_PCM_DOWNLOAD_START_REQ
+//     Result messages (input):  L1_PCM_DOWNLOAD_START_CON
+    // Result messages (output): MMI_PCM_DOWNLOAD_START_CON
+//    Reset messages (input):   none
+    // Stop message (input):     MMI_PCM_DOWNLOAD_STOP_REQ
+    //L1_PCM_DOWNLOAD_STOP_CON
+//    Stop message (output):    MMI_PCM_DOWNLOAD_STOP_CON   */
+    //Rem:                                                  */
+
+    void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_PCM_DOWNLOAD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      BOOL end_process = 0;
+
+      while(!end_process)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.pcm_task.download.command.start = FALSE;
+            l1a_l1s_com.pcm_task.download.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.pcm_task.download.parameters.session_id =  ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size;
+
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1);
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |=
+                                                        ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8);
+              // Start the L1S PCM download task
+              l1a_l1s_com.pcm_task.download.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_PCM_DOWNLOAD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.pcm_task.download.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+
+            UWORD32 maximum_size;
+
+            if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ)
+            {
+              maximum_size =  ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size;
+              if(maximum_size == 0)
+              {
+              // Stop the L1S PCM download task
+              l1a_l1s_com.pcm_task.download.command.stop = TRUE;
+              }
+              else
+              {
+                l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size;
+
+              }
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(!end_process)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_pcm_upload_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* PCM upload feature.                                   */
+    /*                                                       */
+    /* Starting messages:        MMI_PCM_UPLOAD_START_REQ    */
+    /*                                                       */
+    /* Result messages (input):  L1_PCM_UPLOAD_START_CON     */
+    /*                                                       */
+    /* Result messages (output): MMI_PCM_UPLOAD_START_CON    */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_PCM_UPLOAD_STOP_REQ     */
+    /*                           L1_PCM_UPLOAD_STOP_CON      */
+    /*                                                       */
+    /* Stop message (output):    MMI_PCM_UPLOAD_STOP_CON     */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_PCM_UPLOAD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      BOOL end_process = 0;
+
+      while(!end_process)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.pcm_task.upload.command.start = FALSE;
+            l1a_l1s_com.pcm_task.upload.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_PCM_UPLOAD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.pcm_task.upload.parameters.session_id   =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.pcm_task.upload.parameters.maximum_size =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size;
+
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1);
+              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8);
+
+              // Start the L1S voice memo recording task
+              l1a_l1s_com.pcm_task.upload.command.start = TRUE;
+
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_PCM_UPLOAD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.pcm_task.upload.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            end_process = 1;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ)
+            {
+              // Stop the L1S PCM recording task
+              l1a_l1s_com.pcm_task.upload.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_PCM_UPLOAD_STOP_CON)
+            {
+              // Forward the stop confirmation message
+              l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(!end_process)
+    }
+  #endif /* L1_DYN_DSP_DWNLD */
+
+  #endif /* L1_PCM_EXTRACTION */
+
+  #if (L1_VOICE_MEMO_AMR)
+
+  #if (L1_DYN_DSP_DWNLD==1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_vm_amr_playing_process()                      */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* voice memorization playing feature.                   */
+    /*                                                       */
+    /* Starting messages:        MMI_VM_AMR_PLAY_START_REQ   */
+    /*                                                       */
+    /* Result messages (input):  L1_VM_AMR_PLAY_START_CON    */
+    /*                                                       */
+    /* Result messages (output): MMI_VM_AMR_PLAY_START_CON   */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_VM_AMR_PLAY_STOP_REQ    */
+    /*                           L1_VM_AMR_PLAY_STOP_CON     */
+    /*                                                       */
+    /* Stop message (output):    MMI_VM_AMR_PLAY_STOP_CON    */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+  void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_START_CON    = 3,
+        WAIT_STOP         = 4,
+        VM_AMR_PLAY       = 5,
+        VM_AMR_PAUSE      = 6,
+        VM_AMR_PAUSE_CON  = 7,
+        WAIT_RESUME_CON   = 8
+
+
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_VM_AMR_PLAY_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;
+            l1a_l1s_com.voicememo_amr_task.play.command.stop  = FALSE;
+            l1a_l1s_com.voicememo_amr_task.play.command.pause  = FALSE;
+            l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE;
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if(SignalCode == MMI_VM_AMR_PLAY_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+               l1a_l1s_com.voicememo_amr_task.play.parameters.session_id =  ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id;
+
+              if (l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE]==GREEN)
+              {
+                 // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+                 // Start the L1S voice memo playing task
+                 l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE;
+                *state = WAIT_START_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[30];
+                   sprintf(str,"VOICE PLAY AMR SM blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                 }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+            // End process
+            return;
+          }
+// omaps00090550          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE] == GREEN))
+             {
+                 // Start the L1S voice memo playing task
+                 l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE;
+                *state = WAIT_START_CON;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[32];
+                   sprintf(str,"VOICE PLAY AMR SM un-blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                 }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+             }
+             return;
+          }
+ // omaps00090550          break;
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_VM_AMR_PLAY_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON);
+
+              *state = VM_AMR_PLAY ;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550        break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == L1_VM_AMR_PLAY_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        case VM_AMR_PLAY:
+          {
+            switch (SignalCode)
+            {
+              case MMI_VM_AMR_PAUSE_REQ:
+              {
+              // Stop the L1S voice memo playing task
+              l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE;
+              *state = VM_AMR_PAUSE_CON;
+
+              }
+	            break;
+              case MMI_VM_AMR_PLAY_STOP_REQ:
+            {
+              // Stop the L1S voice memo playing task
+              l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE;
+              *state=WAIT_STOP;
+
+              }
+              break;
+              case L1_VM_AMR_PLAY_STOP_CON:
+            {
+             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            break;
+           }
+              return;
+            }
+
+          case VM_AMR_PAUSE_CON:
+          {
+            if(SignalCode==L1_VM_AMR_PAUSE_CON)
+            {
+                // Send confirmation to upper layers
+                l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON);
+
+              // Change state
+              *state=VM_AMR_PAUSE;
+            }
+            else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+          return;
+          }   // case WAIT_PAUSE_CON
+      // *************
+      // * VM_AMR_PAUSE *
+      // *************
+      case VM_AMR_PAUSE:
+      {
+        switch(SignalCode)
+        {
+          // * MMI requests VM_AMR resume *
+          case MMI_VM_AMR_RESUME_REQ:
+          {
+            l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE;
+           l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE;
+
+            // Change state
+            *state=WAIT_RESUME_CON;
+
+          }
+          break;
+          // *-----------------------*
+          // * MMI requests VM_AMR stop *
+          // *-----------------------*
+          case MMI_VM_AMR_PLAY_STOP_REQ:
+          {
+            // Store stop request in L1A/HISR interface
+            l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE;
+
+            // Change state
+            *state=WAIT_STOP;
+
+          }
+          break;
+          case L1_VM_AMR_PLAY_STOP_CON:
+            {
+             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            break;
+         }
+              return;
+            }
+      // case VM_AMR_PAUSE
+      // *******************
+      // * WAIT_RESUME_CON *
+      // *******************
+      case WAIT_RESUME_CON:
+      {
+        if(SignalCode==L1_VM_AMR_RESUME_CON)
+        {
+           l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE;
+          // Send confirmation to upper layers
+                l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON);
+
+            // Change state
+            *state=VM_AMR_PLAY;
+          }
+         return;
+      }   // case WAIT_RESUME_CON
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_vm_amr_recording_process()                    */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* voice memorization recording feature.                 */
+    /*                                                       */
+    /* Starting messages:        MMI_VM_AMR_RECORD_START_REQ */
+    /*                                                       */
+    /* Result messages (input):  L1_VM_AMR_RECORD_START_CON  */
+    /*                                                       */
+    /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_VM_AMR_RECORD_STOP_REQ  */
+    /*                           L1_VM_AMR_RECORD_STOP_CON   */
+    /*                                                       */
+    /* Stop message (output):    MMI_VM_AMR_RECORD_STOP_CON  */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_START_CON    = 3,
+        WAIT_STOP         = 4
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_VM_AMR_RECORD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;
+            l1a_l1s_com.voicememo_amr_task.record.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_VM_AMR_RECORD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.voicememo_amr_task.record.parameters.session_id   =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size;
+              l1a_l1s_com.voicememo_amr_task.record.parameters.dtx          =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used;
+              l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder  =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder;
+
+               // Download UL/DL audio gain to the NDB
+              l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul;
+
+              if(l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE]==GREEN)
+              {
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+                // Start the L1S voice memo recording task
+                l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE;
+
+                *state = WAIT_START_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"VOICE MEMO AMR SM blocked \r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            	}
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VM_STATE_MACHINE] == GREEN))
+              {
+               // Start the L1S voice memo recording task
+               l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE;
+               *state = WAIT_START_CON;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                 {
+                   char str[32];
+                   sprintf(str,"VOICE MEMO AMR SM un-blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                     trace_fct_simu_dyn_dwnld(str);
+                   #else
+                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                   #endif
+                 }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+           return;
+          }
+ // omaps00090550       break;
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_VM_AMR_RECORD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ)
+            {
+              // Stop the L1S voice memo recording task
+              l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_VM_AMR_RECORD_STOP_CON)
+            {
+              // Forward the stop confirmation message
+              l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+#else // L1_DYN_DSP_DWNLD = 0
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_vm_amr_playing_process()                      */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* voice memorization playing feature.                   */
+    /*                                                       */
+    /* Starting messages:        MMI_VM_AMR_PLAY_START_REQ   */
+    /*                                                       */
+    /* Result messages (input):  L1_VM_AMR_PLAY_START_CON    */
+    /*                                                       */
+    /* Result messages (output): MMI_VM_AMR_PLAY_START_CON   */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_VM_AMR_PLAY_STOP_REQ    */
+    /*                           L1_VM_AMR_PLAY_STOP_CON     */
+    /*                                                       */
+    /* Stop message (output):    MMI_VM_AMR_PLAY_STOP_CON    */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+
+    void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3,
+        VM_AMR_PLAY       = 4,
+        VM_AMR_PAUSE      = 5,
+        VM_AMR_PAUSE_CON  = 6,
+        WAIT_RESUME_CON   = 7
+
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_VM_AMR_PLAY_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;
+            l1a_l1s_com.voicememo_amr_task.play.command.stop  = FALSE;
+            l1a_l1s_com.voicememo_amr_task.play.command.pause  = FALSE;
+            l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE;
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_VM_AMR_PLAY_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.voicememo_amr_task.play.parameters.session_id =  ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id;
+
+              // Start the L1S voice memo playing task
+              l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_VM_AMR_PLAY_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON);
+
+              *state = VM_AMR_PLAY ;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == L1_VM_AMR_PLAY_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        case VM_AMR_PLAY:
+          {
+            switch (SignalCode)
+            {
+              case MMI_VM_AMR_PAUSE_REQ:
+              {
+              // Stop the L1S voice memo playing task
+              l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE;
+              *state = VM_AMR_PAUSE_CON;
+
+              }
+	            break;
+              case MMI_VM_AMR_PLAY_STOP_REQ:
+            {
+              // Stop the L1S voice memo playing task
+              l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE;
+              *state=WAIT_STOP;
+
+              }
+              break;
+              case L1_VM_AMR_PLAY_STOP_CON:
+            {
+             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            break;
+           }
+              return;
+            }
+
+          case VM_AMR_PAUSE_CON:
+          {
+            if(SignalCode==L1_VM_AMR_PAUSE_CON)
+            {
+                // Send confirmation to upper layers
+                l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON);
+
+              // Change state
+              *state=VM_AMR_PAUSE;
+            }
+            else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON)
+            {
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+          return;
+          }   // case WAIT_PAUSE_CON
+      // *************
+      // * VM_AMR_PAUSE *
+      // *************
+      case VM_AMR_PAUSE:
+      {
+        switch(SignalCode)
+        {
+          // * MMI requests VM_AMR resume *
+          case MMI_VM_AMR_RESUME_REQ:
+          {
+            l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE;
+           l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE;
+
+            // Change state
+            *state=WAIT_RESUME_CON;
+
+          }
+          break;
+          // *-----------------------*
+          // * MMI requests VM_AMR stop *
+          // *-----------------------*
+          case MMI_VM_AMR_PLAY_STOP_REQ:
+          {
+            // Store stop request in L1A/HISR interface
+            l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE;
+
+            // Change state
+            *state=WAIT_STOP;
+
+          }
+          break;
+          case L1_VM_AMR_PLAY_STOP_CON:
+            {
+             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
+
+              *state = RESET;
+            }
+            break;
+         }
+              return;
+            }
+      // case VM_AMR_PAUSE
+      // *******************
+      // * WAIT_RESUME_CON *
+      // *******************
+      case WAIT_RESUME_CON:
+      {
+        if(SignalCode==L1_VM_AMR_RESUME_CON)
+        {
+           l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE;
+          // Send confirmation to upper layers
+                l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON);
+
+            // Change state
+            *state=VM_AMR_PLAY;
+          }
+         return;
+      }   // case WAIT_RESUME_CON
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_vm_amr_recording_process()                    */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* voice memorization recording feature.                 */
+    /*                                                       */
+    /* Starting messages:        MMI_VM_AMR_RECORD_START_REQ */
+    /*                                                       */
+    /* Result messages (input):  L1_VM_AMR_RECORD_START_CON  */
+    /*                                                       */
+    /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_VM_AMR_RECORD_STOP_REQ  */
+    /*                           L1_VM_AMR_RECORD_STOP_CON   */
+    /*                                                       */
+    /* Stop message (output):    MMI_VM_AMR_RECORD_STOP_CON  */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+
+    void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_VM_AMR_RECORD_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;
+            l1a_l1s_com.voicememo_amr_task.record.command.stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_VM_AMR_RECORD_START_REQ)
+            {
+              // Download the parameters of the message to the l1a_l1s_com structure.
+              l1a_l1s_com.voicememo_amr_task.record.parameters.session_id   =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size;
+              l1a_l1s_com.voicememo_amr_task.record.parameters.dtx          =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used;
+              l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder  =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder;
+
+              // Download UL/DL audio gain to the NDB
+              l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul;
+
+              // Start the L1S voice memo recording task
+              l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_VM_AMR_RECORD_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ)
+            {
+              // Stop the L1S voice memo recording task
+              l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_VM_AMR_RECORD_STOP_CON)
+            {
+              // Forward the stop confirmation message
+              l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+   #endif // L1_DYN_DSP_DWNLD
+  #endif // L1_VOICE_MEMO_AMR
+
+  #if (SPEECH_RECO)
+  #if(L1_DYN_DSP_DWNLD == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_sr_enroll_process()                           */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* speech recognition enrollment feature.                */
+    /*                                                       */
+    /* Starting messages:        MMI_SR_ENROLL_START_REQ     */
+    /*                                                       */
+    /* Result messages (input):  L1_SR_ENROLL_START_CON      */
+    /*                                                       */
+    /* Result messages (output): MMI_SR_ENROLL_START_CON     */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_SR_ENROLL_STOP_REQ      */
+    /*                           L1_SR_ENROLL_STOP_CON       */
+    /*                                                       */
+    /* Stop message (output):    MMI_SR_ENROLL_STOP_CON      */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET               = 0,
+        WAIT_START_REQ      = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_START_CON      = 3,
+        WAIT_STOP           = 4,
+        WAIT_BACK_TASK_DONE = 5,
+        WAIT_L1S_STOP       = 6,
+        WAIT_BACK_STOP      = 7
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_ENROLL_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+      #else
+        xSignalHeaderRec  *conf_msg;
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.enroll_stop  = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_ENROLL_START_REQ)
+            {
+              // Download the message parameters to the parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
+              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech;
+              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address;
+
+              if(l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE]==GREEN)
+              {
+
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+                // Set the start command of the speech recording task
+                l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+                // Start the speech recognition enrollment task
+                l1a_l1s_com.speechreco_task.command.enroll_start = TRUE;
+
+              *state = WAIT_START_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"SPEECH RECO SM blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                     trace_fct_simu_dyn_dwnld(str);
+                   #else
+                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                   #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN))
+            {
+              // Set the start command of the speech recording task
+              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              // Start the speech recognition enrollment task
+              l1a_l1s_com.speechreco_task.command.enroll_start = TRUE;
+              *state = WAIT_START_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                {
+                  char str[30];
+                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                     trace_fct_simu_dyn_dwnld(str);
+                   #else
+                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                   #endif
+                }
+              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+          break;
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_SR_ENROLL_START_CON)
+            {
+              // Reset the commands
+              l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
+              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
+            {
+              // Stop the speech recognition enroll task
+              l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SR_ENROLL_STOP_CON)
+            {
+              // There is an error during the acquisition task?
+              if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // Reset the background task emergency stop
+                l1_srback_com.emergency_stop = FALSE;
+
+                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
+                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);
+
+                *state = WAIT_BACK_TASK_DONE;
+
+                // End process
+                return;
+              }
+              else
+              // There is an error
+              {
+                // Forward the stop confirmation message
+                l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+              }
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_TASK_DONE:
+          {
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the stop confirmation message with no error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) );
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+
+            }
+            else
+            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+
+              // End process
+              return;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if (SignalCode == L1_SR_ENROLL_STOP_CON)
+            {
+              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_sr_update_process()                           */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* speech recognition update feature.                    */
+    /*                                                       */
+    /* Starting messages:        MMI_SR_UPDATE_START_REQ     */
+    /*                                                       */
+    /* Result messages (input):  L1_SR_UPDATE_START_CON      */
+    /*                                                       */
+    /* Result messages (output): MMI_SR_UPDATE_START_CON     */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_SR_UPDATE_STOP_REQ      */
+    /*                           L1_SR_UPDATE_STOP_CON       */
+    /*                                                       */
+    /* Stop message (output):    MMI_SR_UPDATE_STOP_CON      */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_sr_update_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET               = 0,
+        WAIT_START_REQ      = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_MODEL_LOADED   = 3,
+        WAIT_START_CON      = 4,
+        WAIT_STOP           = 5,
+        WAIT_BACK_TASK_DONE = 6,
+        WAIT_L1S_STOP       = 7,
+        WAIT_BACK_STOP      = 8
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+      #else
+        xSignalHeaderRec  *conf_msg;
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_UPDATE_START_REQ)
+            {
+              // Download the message parameters to the parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
+              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech;
+              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address;
+
+              // Reset the background task emergency stop
+              l1_srback_com.emergency_stop = FALSE;
+
+              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+
+              if(l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)
+              {
+
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+                // Start to download the model to the API
+                l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+                // Send the start confirmation message
+                l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON);
+
+                *state = WAIT_MODEL_LOADED;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"SPEECH RECO SM blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                     trace_fct_simu_dyn_dwnld(str);
+                   #else
+                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                   #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN))
+            {
+               // Start to download the model to the API
+              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON);
+
+              *state = WAIT_MODEL_LOADED;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                {
+                  char str[30];
+                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
+                  #if(CODE_VERSION == SIMULATION)
+                    trace_fct_simu_dyn_dwnld(str);
+                  #else
+                    rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                  #endif
+                }
+              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+
+            }
+            return;
+          }
+          break;
+          case WAIT_MODEL_LOADED:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+            else
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Set the start command of the speech recording task
+              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              // Start the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_START_CON)
+            {
+              // Reset the commands
+              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_STOP_CON)
+            {
+              // There is an error during the update task?
+              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // Reset the background task emergency stop
+                l1_srback_com.emergency_stop = FALSE;
+
+                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
+                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);
+
+                *state = WAIT_BACK_TASK_DONE;
+
+                // End process
+                return;
+              }
+              else
+              {
+                // Forward the stop confirmation message
+                l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+              }
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_TASK_DONE:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+            else
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) ||
+                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) )
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if (SignalCode == L1_SR_UPDATE_STOP_CON)
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_sr_reco_process()                             */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* speech recognition reco feature.                      */
+    /*                                                       */
+    /* Starting messages:        MMI_SR_RECO_START_REQ       */
+    /*                                                       */
+    /* Result messages (input):  L1_SR_RECO_START_CON        */
+    /*                                                       */
+    /* Result messages (output): MMI_SR_RECO_START_CON       */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_SR_RECO_STOP_REQ        */
+    /*                           L1_SR_RECO_STOP_IND         */
+    /*                                                       */
+    /* Stop message (output):    MMI_SR_RECO_STOP_CON        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET                 = 0,
+        WAIT_START_REQ        = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_RECO_START       = 3,
+        WAIT_RECO_STOP        = 4,
+        LOAD_MODEL            = 5,
+        WAIT_MODEL_LOADED     = 6,
+        WAIT_PROCESSING_STOP  = 7,
+        WAIT_L1S_STOP         = 8,
+        WAIT_BACK_STOP        = 9
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_RECO_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+      #else
+        xSignalHeaderRec  *conf_msg;
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.reco_start        = FALSE;
+            l1a_l1s_com.speechreco_task.command.reco_stop         = FALSE;
+            l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
+            l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_RECO_START_REQ)
+            {
+              // Reset the index counter
+              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;
+
+              // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id     = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size;
+              l1a_l1s_com.speechreco_task.parameters.model_address   = l1s_dsp_com.dsp_ndb_ptr->a_model;
+
+              // The CTO algorithm must be used?
+              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
+              {
+                // Enable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;
+
+                // Double the vocabulary size
+                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
+              }
+              else
+              {
+                // Disable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+              }
+
+              if (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)
+              {
+
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+                // Start the speech recognition reco task
+                l1a_l1s_com.speechreco_task.command.reco_start = TRUE;
+
+                *state = WAIT_RECO_START;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"SPEECH RECO SM blocked\r\n");
+                   #if(CODE_VERSION == SIMULATION)
+                     trace_fct_simu_dyn_dwnld(str);
+                   #else
+                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                   #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN))
+            {
+              // Start the speech recognition reco task
+              l1a_l1s_com.speechreco_task.command.reco_start = TRUE;
+              *state = WAIT_RECO_START;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                {
+                  char str[30];
+                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
+                  #if(CODE_VERSION == SIMULATION)
+                    trace_fct_simu_dyn_dwnld(str);
+                  #else
+                    rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                  #endif
+                }
+              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+
+            }
+            return;
+          }
+          break;
+          case WAIT_RECO_START:
+          {
+            if (SignalCode == L1_SR_RECO_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.speechreco_task.command.reco_start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_RECO_START_CON);
+
+              *state = WAIT_RECO_STOP;
+            }
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_RECO_STOP:
+          {
+            if (SignalCode == L1_SR_RECO_STOP_CON)
+            {
+              // The acqusition is good or not?
+              if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                *state = LOAD_MODEL;
+              }
+              else
+              {
+                // Send the message MMI_SR_RECO_STOP_CON with an error
+              #if (OP_RIV_AUDIO == 1)
+                // Allocate the Riviera buffer
+                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                        sizeof (T_MMI_SR_RECO_STOP_CON),
+                                        (T_RVF_BUFFER **) (&p_message));
+
+                // If insufficient resources, then report a memory error and abort.
+                if (mb_status == RVF_RED)
+                {
+                  // the memory is insufficient to continue the non regression test
+                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                  return;
+                }
+
+                // Fill the message ID
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+                // Fill the message parameter
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
+                  ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;
+
+                // send the messsage to the audio entity
+                rvf_send_msg (p_audio_gbl_var->addrId,
+                              p_message);
+              #else // OP_RIV_AUDIO
+                // Allocate confirmation message...
+                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+                DEBUGMSG(status,NU_ALLOC_ERR)
+                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+                // File the message
+                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;
+
+                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                    l1_trace_message(conf_msg);
+                #endif
+
+                // Send the confirmation message...
+                os_send_sig(conf_msg, MMI_QUEUE);
+                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+              #endif // OP_RIV_AUDIO
+
+                *state = RESET;
+              }
+            }
+            else
+            if(SignalCode == MMI_SR_RECO_STOP_REQ)
+            {
+              // Stop the speech recognition task
+              l1a_l1s_com.speechreco_task.command.reco_stop = TRUE;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case LOAD_MODEL:
+          {
+            // Initialize the background task stop command
+            l1_srback_com.emergency_stop = FALSE;
+
+            // Start to load the model to the API
+            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
+            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+            // Increase the index counter
+            l1a_l1s_com.speechreco_task.parameters.index_counter++;
+
+            *state = WAIT_MODEL_LOADED;
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_MODEL_LOADED:
+          {
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Start the DSP processing task
+              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;
+
+              *state = WAIT_PROCESSING_STOP;
+            }
+            else
+            if (SignalCode == MMI_SR_RECO_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_PROCESSING_STOP:
+          {
+            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
+            {
+              // The processing phase is good or not?
+              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                *state = LOAD_MODEL;
+              }
+              else
+              {
+                // Send the MMI_SR_RECO_STOP_CON message with an error
+              #if (OP_RIV_AUDIO == 1)
+                // Allocate the Riviera buffer
+                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                        sizeof (T_MMI_SR_RECO_STOP_CON),
+                                        (T_RVF_BUFFER **) (&p_message));
+
+                // If insufficient resources, then report a memory error and abort.
+                if (mb_status == RVF_RED)
+                {
+                  // the memory is insufficient to continue the non regression test
+                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                  return;
+                }
+
+                // Fill the message ID
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+                // Fill the message parameter
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
+                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+              #else // OP_RIV_AUDIO
+                // Allocate confirmation message...
+                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+                DEBUGMSG(status,NU_ALLOC_ERR)
+                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+                // File the message
+                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+
+                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                    l1_trace_message(conf_msg);
+                #endif
+
+                // Send the confirmation message...
+                os_send_sig(conf_msg, MMI_QUEUE);
+                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+              #endif // OP_RIV_AUDIO
+
+                *state = RESET;
+              }
+            }
+            else
+            if (SignalCode == L1_SR_RECO_STOP_IND)
+            {
+              // The CTO algorithm is used?
+              if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
+              {
+                // There is an error during the recognition?
+                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
+                {
+                  // The best word is odd?
+                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
+                  {
+                    // Change the error to tSC_CTO_WORD
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;
+                  }
+                  else
+                  {
+                    // Devided by 2 the 4 indexes of the best words in the message
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
+                  }
+                }
+              }
+                // Forward the message in the MMI_SR_RECO_STOP_CON
+                l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+            }
+            else
+            if (SignalCode == MMI_SR_RECO_STOP_REQ)
+            {
+              // Stop the L1S processing task
+              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;
+
+              *state = WAIT_L1S_STOP;
+
+              // end process
+              return;
+            }
+            else
+            {
+              // end process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
+                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
+                 (SignalCode == L1_SR_RECO_STOP_IND) )
+            {
+              // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_RECO_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+              // File the message
+              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Send the MMI_SR_RECO_STOP_CON with an bad recognition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_RECO_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+              // Fill the message
+              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*---------------------------------------------------------*/
+    /* l1a_mmi_sr_update_check_process()                       */
+    /*---------------------------------------------------------*/
+    /*                                                         */
+    /* Description:                                            */
+    /* ------------                                            */
+    /* This function is a state machine which handles the      */
+    /* speech recognition update check feature.                */
+    /*                                                         */
+    /* Starting messages:        MMI_SR_UPDATE_CHECK_START_REQ */
+    /*                                                         */
+    /* Result messages (input):  L1_SR_UPDATE_START_CON        */
+    /*                                                         */
+    /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */
+    /*                                                         */
+    /* Reset messages (input):   none                          */
+    /*                                                         */
+    /* Stop message (input):     MMI_SR_UPDATE_CHECK_STOP_REQ  */
+    /*                           L1_SR_RECO_STOP_IND           */
+    /*                                                         */
+    /* Stop message (output):    MMI_SR_UPDATE_CHECK_STOP_CON  */
+    /*                                                         */
+    /* Rem:                                                    */
+    /* ----                                                    */
+    /*                                                         */
+    /*---------------------------------------------------------*/
+    void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET                 = 0,
+        WAIT_START_REQ        = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_MODEL            = 3,
+        WAIT_UPDATE_START     = 4,
+        WAIT_UPDATE_STOP      = 5,
+        WAIT_TEMP_SAVE_DONE   = 6,
+        LOAD_MODEL            = 7,
+        WAIT_MODEL_LOADED     = 8,
+        WAIT_PROCESSING_STOP  = 9,
+        WAIT_SAVE_DONE        = 10,
+        WAIT_L1S_STOP         = 11,
+        WAIT_BACK_STOP        = 12
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_CHECK_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+        #define AUDIO_MSG (p_message)
+      #else
+        xSignalHeaderRec  *conf_msg;
+        #define AUDIO_MSG (conf_msg->SigP)
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if(SignalCode == MMI_SR_UPDATE_CHECK_START_REQ)
+            {
+              // Download the message parameters to the parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id        = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.word_index         = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.word_to_check      = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.model_address      = l1s_dsp_com.dsp_ndb_ptr->a_model;
+              l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address;
+              l1a_l1s_com.speechreco_task.parameters.speech             = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech;
+              l1a_l1s_com.speechreco_task.parameters.speech_address     = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address;
+              l1a_l1s_com.speechreco_task.parameters.vocabulary_size    = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size;
+
+              // Reset the background task emergency stop
+              l1_srback_com.emergency_stop = FALSE;
+
+              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+
+              if (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN)
+              {
+
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+                // Start to download the model to the API
+                l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+                // Send the start confirmation message
+                l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON);
+
+                *state = WAIT_MODEL;
+              }
+              else
+              {
+               *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"SPEECH RECO SM blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SR_STATE_MACHINE] == GREEN))
+            {
+
+              // Start to download the model to the API
+              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON);
+
+              *state = WAIT_MODEL;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                {
+                  char str[30];
+                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
+                  #if(CODE_VERSION == SIMULATION)
+                    trace_fct_simu_dyn_dwnld(str);
+                  #else
+                    rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                  #endif
+                }
+              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+
+            }
+            return;
+          }
+          break;
+          case WAIT_MODEL:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+            else
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Set the start command of the speech recording task
+              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              // Start the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_start = TRUE;
+
+              *state = WAIT_UPDATE_START;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_UPDATE_START:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_START_CON)
+            {
+              // Reset the commands
+              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+
+              *state = WAIT_UPDATE_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_UPDATE_STOP:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_STOP_CON)
+            {
+              // There is an error during the update task?
+              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // Reset the background task emergency stop
+                l1_srback_com.emergency_stop = FALSE;
+
+                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
+                l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ);
+
+                *state = WAIT_TEMP_SAVE_DONE;
+
+                // End process
+                return;
+              }
+              else
+              {
+                // Forward the stop confirmation message
+                l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+              }
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_TEMP_SAVE_DONE:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON)
+            {
+              // Reset the command
+              l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
+              l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;
+
+              // Reset the index counter
+              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;
+
+              // The CTO algorithm must be used?
+              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
+              {
+                // Enable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;
+
+                // Double the vocabulary size
+                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
+              }
+              else
+              {
+                // Disable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+              }
+
+              *state = LOAD_MODEL;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case LOAD_MODEL:
+          {
+            // Initialize the background task stop command
+            l1_srback_com.emergency_stop = FALSE;
+
+            // Start to load the model to the API
+            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
+            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+            // Increase the index counter
+            l1a_l1s_com.speechreco_task.parameters.index_counter++;
+
+            *state = WAIT_MODEL_LOADED;
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_MODEL_LOADED:
+          {
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Start the DSP processing task
+              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;
+
+              *state = WAIT_PROCESSING_STOP;
+            }
+            else
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_PROCESSING_STOP:
+          {
+            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
+            {
+              // The processing phase is good or not?
+              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                *state = LOAD_MODEL;
+              }
+              else
+              {
+                // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
+              #if (OP_RIV_AUDIO == 1)
+                // Allocate the Riviera buffer
+                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                        sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                        (T_RVF_BUFFER **) (&p_message));
+
+                // If insufficient resources, then report a memory error and abort.
+                if (mb_status == RVF_RED)
+                {
+                  // the memory is insufficient to continue the non regression test
+                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                  return;
+                }
+
+                // Fill the message ID
+                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+                // Fill the message parameter
+                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id =
+                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+
+                // send the messsage to the audio entity
+                rvf_send_msg (p_audio_gbl_var->addrId,
+                              p_message);
+              #else // OP_RIV_AUDIO
+                // Allocate confirmation message...
+                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+                DEBUGMSG(status,NU_ALLOC_ERR)
+                conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+                // File the message
+                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+
+                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                    l1_trace_message(conf_msg);
+                #endif
+
+                // Send the confirmation message...
+                os_send_sig(conf_msg, MMI_QUEUE);
+                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+              #endif // OP_RIV_AUDIO
+
+                *state = RESET;
+              }
+            }
+            else
+            if (SignalCode == L1_SR_RECO_STOP_IND)
+            {
+              // There is an error during the recognition?
+              if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // The CTO algorithm is used?
+                if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
+                {
+                  // The best word is odd?
+                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
+                  {
+                    // Change the error to SC_CTO_WORD
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;
+
+                    // Forward the message in the MMI_SR_RECO_STOP_CON
+                    l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);
+
+                    *state = RESET;
+
+                    // End process
+                    return;
+                  }
+                  else
+                  {
+                    // Devided by 2 the 4 indexes of the best words in the message
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
+                  }
+                }
+                // Is it the good word?
+                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index ==
+                     l1a_l1s_com.speechreco_task.parameters.word_to_check )
+                {
+                  // Save the message informations in the l1a_l1s_com memory
+                  l1a_l1s_com.speechreco_task.parameters.best_word_index        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.best_word_score        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.third_best_word_index  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.third_best_word_score  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_level          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level;
+                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise;
+                  l1a_l1s_com.speechreco_task.parameters.d_sr_model_size        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size;
+
+                  // Reset the stop background task
+                  l1_srback_com.emergency_stop = FALSE;
+
+                  // Start the background task to save the model in the database
+                  l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check;
+                  l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address;
+                  l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);
+
+                  *state = WAIT_SAVE_DONE;
+
+                  // End process
+                  return;
+                }
+                else
+                {
+                  // Change the error to SC_CHECK_ERROR
+                  ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR;
+                }
+              }
+              // Forward the message in the MMI_SR_RECO_STOP_CON
+              l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop the L1S processing task
+              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;
+
+              *state = WAIT_L1S_STOP;
+
+              // end process
+              return;
+            }
+            else
+            {
+              // end process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_SAVE_DONE:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+            #endif // OP_RIV_AUDIO
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id                = SC_NO_ERROR;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index         = l1a_l1s_com.speechreco_task.parameters.best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score         = l1a_l1s_com.speechreco_task.parameters.best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index  = l1a_l1s_com.speechreco_task.parameters.second_best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score  = l1a_l1s_com.speechreco_task.parameters.second_best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index   = l1a_l1s_com.speechreco_task.parameters.third_best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score   = l1a_l1s_com.speechreco_task.parameters.third_best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size         = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size;
+
+            #if (OP_RIV_AUDIO == 1)
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON)  ||
+                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ||
+                 (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) )
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if ( (SignalCode == L1_SR_UPDATE_STOP_CON)     ||
+                 (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
+                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
+                 (SignalCode == L1_SR_RECO_STOP_IND) )
+            {
+              // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+
+      // Undefine message pointer macro.
+      #undef MSG_AUDIO
+
+    }
+    #else // L1_DYN_DSP_DWNLD = 0
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_sr_enroll_process()                           */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* speech recognition enrollment feature.                */
+    /*                                                       */
+    /* Starting messages:        MMI_SR_ENROLL_START_REQ     */
+    /*                                                       */
+    /* Result messages (input):  L1_SR_ENROLL_START_CON      */
+    /*                                                       */
+    /* Result messages (output): MMI_SR_ENROLL_START_CON     */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_SR_ENROLL_STOP_REQ      */
+    /*                           L1_SR_ENROLL_STOP_CON       */
+    /*                                                       */
+    /* Stop message (output):    MMI_SR_ENROLL_STOP_CON      */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET               = 0,
+        WAIT_START_REQ      = 1,
+        WAIT_START_CON      = 2,
+        WAIT_STOP           = 3,
+        WAIT_BACK_TASK_DONE = 4,
+        WAIT_L1S_STOP       = 5,
+        WAIT_BACK_STOP      = 6
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_ENROLL_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+      #else
+        xSignalHeaderRec  *conf_msg;
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.enroll_stop  = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_ENROLL_START_REQ)
+            {
+              // Download the message parameters to the parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
+              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech;
+              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address;
+
+              // Set the start command of the speech recording task
+              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              // Start the speech recognition enrollment task
+              l1a_l1s_com.speechreco_task.command.enroll_start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_SR_ENROLL_START_CON)
+            {
+              // Reset the commands
+              l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
+              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
+            {
+              // Stop the speech recognition enroll task
+              l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SR_ENROLL_STOP_CON)
+            {
+              // There is an error during the acquisition task?
+              if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // Reset the background task emergency stop
+                l1_srback_com.emergency_stop = FALSE;
+
+                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
+                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);
+
+                *state = WAIT_BACK_TASK_DONE;
+
+                // End process
+                return;
+              }
+              else
+              // There is an error
+              {
+                // Forward the stop confirmation message
+                l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+              }
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_TASK_DONE:
+          {
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the stop confirmation message with no error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) );
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+
+            }
+            else
+            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+
+              // End process
+              return;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if (SignalCode == L1_SR_ENROLL_STOP_CON)
+            {
+              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_sr_update_process()                           */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* speech recognition update feature.                    */
+    /*                                                       */
+    /* Starting messages:        MMI_SR_UPDATE_START_REQ     */
+    /*                                                       */
+    /* Result messages (input):  L1_SR_UPDATE_START_CON      */
+    /*                                                       */
+    /* Result messages (output): MMI_SR_UPDATE_START_CON     */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_SR_UPDATE_STOP_REQ      */
+    /*                           L1_SR_UPDATE_STOP_CON       */
+    /*                                                       */
+    /* Stop message (output):    MMI_SR_UPDATE_STOP_CON      */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_sr_update_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET               = 0,
+        WAIT_START_REQ      = 1,
+        WAIT_MODEL_LOADED   = 2,
+        WAIT_START_CON      = 3,
+        WAIT_STOP           = 4,
+        WAIT_BACK_TASK_DONE = 5,
+        WAIT_L1S_STOP       = 6,
+        WAIT_BACK_STOP      = 7
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+      #else
+        xSignalHeaderRec  *conf_msg;
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_UPDATE_START_REQ)
+            {
+              // Download the message parameters to the parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
+              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech;
+              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address;
+
+              // Reset the background task emergency stop
+              l1_srback_com.emergency_stop = FALSE;
+
+              // Start to download the model to the API
+              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON);
+
+              *state = WAIT_MODEL_LOADED;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_MODEL_LOADED:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+            else
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Set the start command of the speech recording task
+              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              // Start the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_START_CON)
+            {
+              // Reset the commands
+              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_STOP_CON)
+            {
+              // There is an error during the update task?
+              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // Reset the background task emergency stop
+                l1_srback_com.emergency_stop = FALSE;
+
+                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
+                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);
+
+                *state = WAIT_BACK_TASK_DONE;
+
+                // End process
+                return;
+              }
+              else
+              {
+                // Forward the stop confirmation message
+                l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+              }
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_TASK_DONE:
+          {
+            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+            else
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) ||
+                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) )
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if (SignalCode == L1_SR_UPDATE_STOP_CON)
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_sr_reco_process()                             */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* speech recognition reco feature.                      */
+    /*                                                       */
+    /* Starting messages:        MMI_SR_RECO_START_REQ       */
+    /*                                                       */
+    /* Result messages (input):  L1_SR_RECO_START_CON        */
+    /*                                                       */
+    /* Result messages (output): MMI_SR_RECO_START_CON       */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_SR_RECO_STOP_REQ        */
+    /*                           L1_SR_RECO_STOP_IND         */
+    /*                                                       */
+    /* Stop message (output):    MMI_SR_RECO_STOP_CON        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET                 = 0,
+        WAIT_START_REQ        = 1,
+        WAIT_RECO_START       = 2,
+        WAIT_RECO_STOP        = 3,
+        LOAD_MODEL            = 4,
+        WAIT_MODEL_LOADED     = 5,
+        WAIT_PROCESSING_STOP  = 6,
+        WAIT_L1S_STOP         = 7,
+        WAIT_BACK_STOP        = 8
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_RECO_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+      #else
+        xSignalHeaderRec  *conf_msg;
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.reco_start        = FALSE;
+            l1a_l1s_com.speechreco_task.command.reco_stop         = FALSE;
+            l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
+            l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_RECO_START_REQ)
+            {
+
+              // Reset the index counter
+              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;
+
+              // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id     = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size;
+              l1a_l1s_com.speechreco_task.parameters.model_address   = l1s_dsp_com.dsp_ndb_ptr->a_model;
+
+              // The CTO algorithm must be used?
+              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
+              {
+                // Enable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;
+
+                // Double the vocabulary size
+                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
+              }
+              else
+              {
+                // Disable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+              }
+
+              // Start the speech recognition reco task
+              l1a_l1s_com.speechreco_task.command.reco_start = TRUE;
+
+              *state = WAIT_RECO_START;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+
+          case WAIT_RECO_START:
+          {
+            if (SignalCode == L1_SR_RECO_START_CON)
+            {
+              // Reset the start command
+              l1a_l1s_com.speechreco_task.command.reco_start = FALSE;
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_RECO_START_CON);
+
+              *state = WAIT_RECO_STOP;
+            }
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_RECO_STOP:
+          {
+            if (SignalCode == L1_SR_RECO_STOP_CON)
+            {
+              // The acqusition is good or not?
+              if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                *state = LOAD_MODEL;
+              }
+              else
+              {
+                // Send the message MMI_SR_RECO_STOP_CON with an error
+              #if (OP_RIV_AUDIO == 1)
+                // Allocate the Riviera buffer
+                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                        sizeof (T_MMI_SR_RECO_STOP_CON),
+                                        (T_RVF_BUFFER **) (&p_message));
+
+                // If insufficient resources, then report a memory error and abort.
+                if (mb_status == RVF_RED)
+                {
+                  // the memory is insufficient to continue the non regression test
+                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                  return;
+                }
+
+                // Fill the message ID
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+                // Fill the message parameter
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
+                  ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;
+
+                // send the messsage to the audio entity
+                rvf_send_msg (p_audio_gbl_var->addrId,
+                              p_message);
+              #else // OP_RIV_AUDIO
+                // Allocate confirmation message...
+                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+                DEBUGMSG(status,NU_ALLOC_ERR)
+                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+                // File the message
+                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;
+
+                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                    l1_trace_message(conf_msg);
+                #endif
+
+                // Send the confirmation message...
+                os_send_sig(conf_msg, MMI_QUEUE);
+                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+              #endif // OP_RIV_AUDIO
+
+                *state = RESET;
+              }
+            }
+            else
+            if(SignalCode == MMI_SR_RECO_STOP_REQ)
+            {
+              // Stop the speech recognition task
+              l1a_l1s_com.speechreco_task.command.reco_stop = TRUE;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case LOAD_MODEL:
+          {
+            // Initialize the background task stop command
+            l1_srback_com.emergency_stop = FALSE;
+
+            // Start to load the model to the API
+            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
+            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+            // Increase the index counter
+            l1a_l1s_com.speechreco_task.parameters.index_counter++;
+
+            *state = WAIT_MODEL_LOADED;
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_MODEL_LOADED:
+          {
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Start the DSP processing task
+              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;
+
+              *state = WAIT_PROCESSING_STOP;
+            }
+            else
+            if (SignalCode == MMI_SR_RECO_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_PROCESSING_STOP:
+          {
+            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
+            {
+              // The processing phase is good or not?
+              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                *state = LOAD_MODEL;
+              }
+              else
+              {
+                // Send the MMI_SR_RECO_STOP_CON message with an error
+              #if (OP_RIV_AUDIO == 1)
+                // Allocate the Riviera buffer
+                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                        sizeof (T_MMI_SR_RECO_STOP_CON),
+                                        (T_RVF_BUFFER **) (&p_message));
+
+                // If insufficient resources, then report a memory error and abort.
+                if (mb_status == RVF_RED)
+                {
+                  // the memory is insufficient to continue the non regression test
+                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                  return;
+                }
+
+                // Fill the message ID
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+                // Fill the message parameter
+                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
+                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+              #else // OP_RIV_AUDIO
+                // Allocate confirmation message...
+                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+                DEBUGMSG(status,NU_ALLOC_ERR)
+                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+                // File the message
+                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+
+                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                    l1_trace_message(conf_msg);
+                #endif
+
+                // Send the confirmation message...
+                os_send_sig(conf_msg, MMI_QUEUE);
+                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+              #endif // OP_RIV_AUDIO
+
+                *state = RESET;
+              }
+            }
+            else
+            if (SignalCode == L1_SR_RECO_STOP_IND)
+            {
+              // The CTO algorithm is used?
+              if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
+              {
+                // There is an error during the recognition?
+                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
+                {
+                  // The best word is odd?
+                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
+                  {
+                    // Change the error to tSC_CTO_WORD
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;
+                  }
+                  else
+                  {
+                    // Devided by 2 the 4 indexes of the best words in the message
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
+                  }
+                }
+              }
+                // Forward the message in the MMI_SR_RECO_STOP_CON
+                l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+            }
+            else
+            if (SignalCode == MMI_SR_RECO_STOP_REQ)
+            {
+              // Stop the L1S processing task
+              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;
+
+              *state = WAIT_L1S_STOP;
+
+              // end process
+              return;
+            }
+            else
+            {
+              // end process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
+                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
+                 (SignalCode == L1_SR_RECO_STOP_IND) )
+            {
+              // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_RECO_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+              // File the message
+              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Send the MMI_SR_RECO_STOP_CON with an bad recognition error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_RECO_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
+              // Fill the message
+              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*---------------------------------------------------------*/
+    /* l1a_mmi_sr_update_check_process()                       */
+    /*---------------------------------------------------------*/
+    /*                                                         */
+    /* Description:                                            */
+    /* ------------                                            */
+    /* This function is a state machine which handles the      */
+    /* speech recognition update check feature.                */
+    /*                                                         */
+    /* Starting messages:        MMI_SR_UPDATE_CHECK_START_REQ */
+    /*                                                         */
+    /* Result messages (input):  L1_SR_UPDATE_START_CON        */
+    /*                                                         */
+    /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */
+    /*                                                         */
+    /* Reset messages (input):   none                          */
+    /*                                                         */
+    /* Stop message (input):     MMI_SR_UPDATE_CHECK_STOP_REQ  */
+    /*                           L1_SR_RECO_STOP_IND           */
+    /*                                                         */
+    /* Stop message (output):    MMI_SR_UPDATE_CHECK_STOP_CON  */
+    /*                                                         */
+    /* Rem:                                                    */
+    /* ----                                                    */
+    /*                                                         */
+    /*---------------------------------------------------------*/
+    void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET                 = 0,
+        WAIT_START_REQ        = 1,
+        WAIT_MODEL            = 2,
+        WAIT_UPDATE_START     = 3,
+        WAIT_UPDATE_STOP      = 4,
+        WAIT_TEMP_SAVE_DONE   = 5,
+        LOAD_MODEL            = 6,
+        WAIT_MODEL_LOADED     = 7,
+        WAIT_PROCESSING_STOP  = 8,
+        WAIT_SAVE_DONE        = 9,
+        WAIT_L1S_STOP         = 10,
+        WAIT_BACK_STOP        = 11
+      };
+
+      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_CHECK_STATE];
+      UWORD32           SignalCode  = msg->SignalCode;
+      #if (OP_RIV_AUDIO == 1)
+        void              *p_message;
+        T_RVF_MB_STATUS   mb_status;
+        #define AUDIO_MSG (p_message)
+      #else
+        xSignalHeaderRec  *conf_msg;
+        #define AUDIO_MSG (conf_msg->SigP)
+      #endif
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_START_REQ)
+            {
+              // Download the message parameters to the parameters memory
+              l1a_l1s_com.speechreco_task.parameters.database_id        = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id;
+              l1a_l1s_com.speechreco_task.parameters.word_index         = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.word_to_check      = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
+              l1a_l1s_com.speechreco_task.parameters.model_address      = l1s_dsp_com.dsp_ndb_ptr->a_model;
+              l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address;
+              l1a_l1s_com.speechreco_task.parameters.speech             = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech;
+              l1a_l1s_com.speechreco_task.parameters.speech_address     = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address;
+              l1a_l1s_com.speechreco_task.parameters.vocabulary_size    = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size;
+
+              // Reset the background task emergency stop
+              l1_srback_com.emergency_stop = FALSE;
+
+              // Start to download the model to the API
+              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON);
+
+              *state = WAIT_MODEL;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_MODEL:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+            else
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Set the start command of the speech recording task
+              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              // Start the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_start = TRUE;
+
+              *state = WAIT_UPDATE_START;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_UPDATE_START:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_START_CON)
+            {
+              // Reset the commands
+              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
+              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
+
+              *state = WAIT_UPDATE_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_UPDATE_STOP:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop the speech recognition update task
+              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;
+
+              // Stop the speech recording task (if present)
+              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;
+
+              *state = WAIT_L1S_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SR_UPDATE_STOP_CON)
+            {
+              // There is an error during the update task?
+              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // Reset the background task emergency stop
+                l1_srback_com.emergency_stop = FALSE;
+
+                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
+                l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ);
+
+                *state = WAIT_TEMP_SAVE_DONE;
+
+                // End process
+                return;
+              }
+              else
+              {
+                // Forward the stop confirmation message
+                l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);
+
+                *state = RESET;
+              }
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_TEMP_SAVE_DONE:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON)
+            {
+              // Reset the command
+              l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
+              l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;
+
+              // Reset the index counter
+              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;
+
+              // The CTO algorithm must be used?
+              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
+              {
+                // Enable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;
+
+                // Double the vocabulary size
+                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
+              }
+              else
+              {
+                // Disable the CTO algorithm
+                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
+              }
+
+              *state = LOAD_MODEL;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case LOAD_MODEL:
+          {
+            // Initialize the background task stop command
+            l1_srback_com.emergency_stop = FALSE;
+
+            // Start to load the model to the API
+            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
+            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);
+
+            // Increase the index counter
+            l1a_l1s_com.speechreco_task.parameters.index_counter++;
+
+            *state = WAIT_MODEL_LOADED;
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_MODEL_LOADED:
+          {
+            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
+            {
+              // Start the DSP processing task
+              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;
+
+              *state = WAIT_PROCESSING_STOP;
+            }
+            else
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_PROCESSING_STOP:
+          {
+            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
+            {
+              // The processing phase is good or not?
+              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                *state = LOAD_MODEL;
+              }
+              else
+              {
+                // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
+              #if (OP_RIV_AUDIO == 1)
+                // Allocate the Riviera buffer
+                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                        sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                        (T_RVF_BUFFER **) (&p_message));
+
+                // If insufficient resources, then report a memory error and abort.
+                if (mb_status == RVF_RED)
+                {
+                  // the memory is insufficient to continue the non regression test
+                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                  return;
+                }
+
+                // Fill the message ID
+                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+                // Fill the message parameter
+                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id =
+                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+
+                // send the messsage to the audio entity
+                rvf_send_msg (p_audio_gbl_var->addrId,
+                              p_message);
+              #else // OP_RIV_AUDIO
+                // Allocate confirmation message...
+                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+                DEBUGMSG(status,NU_ALLOC_ERR)
+                conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+                // File the message
+                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
+
+                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                    l1_trace_message(conf_msg);
+                #endif
+
+                // Send the confirmation message...
+                os_send_sig(conf_msg, MMI_QUEUE);
+                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+              #endif // OP_RIV_AUDIO
+
+                *state = RESET;
+              }
+            }
+            else
+            if (SignalCode == L1_SR_RECO_STOP_IND)
+            {
+              // There is an error during the recognition?
+              if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
+              {
+                // The CTO algorithm is used?
+                if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
+                {
+                  // The best word is odd?
+                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
+                  {
+                    // Change the error to SC_CTO_WORD
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;
+
+                    // Forward the message in the MMI_SR_RECO_STOP_CON
+                    l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);
+
+                    *state = RESET;
+
+                    // End process
+                    return;
+                  }
+                  else
+                  {
+                    // Devided by 2 the 4 indexes of the best words in the message
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
+                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
+                  }
+                }
+                // Is it the good word?
+                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index ==
+                     l1a_l1s_com.speechreco_task.parameters.word_to_check )
+                {
+                  // Save the message informations in the l1a_l1s_com memory
+                  l1a_l1s_com.speechreco_task.parameters.best_word_index        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.best_word_score        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.third_best_word_index  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.third_best_word_score  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index;
+                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score;
+                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_level          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level;
+                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise;
+                  l1a_l1s_com.speechreco_task.parameters.d_sr_model_size        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size;
+
+                  // Reset the stop background task
+                  l1_srback_com.emergency_stop = FALSE;
+
+                  // Start the background task to save the model in the database
+                  l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check;
+                  l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address;
+                  l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);
+
+                  *state = WAIT_SAVE_DONE;
+
+                  // End process
+                  return;
+                }
+                else
+                {
+                  // Change the error to SC_CHECK_ERROR
+                  ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR;
+                }
+              }
+              // Forward the message in the MMI_SR_RECO_STOP_CON
+              l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+            else
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop the L1S processing task
+              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;
+
+              *state = WAIT_L1S_STOP;
+
+              // end process
+              return;
+            }
+            else
+            {
+              // end process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_SAVE_DONE:
+          {
+            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
+            {
+              // Stop immediatly the background task
+              l1_srback_com.emergency_stop = TRUE;
+
+              *state = WAIT_BACK_STOP;
+
+              // End process
+              return;
+            }
+            else
+            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
+            {
+              // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+            #endif // OP_RIV_AUDIO
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id                = SC_NO_ERROR;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index         = l1a_l1s_com.speechreco_task.parameters.best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score         = l1a_l1s_com.speechreco_task.parameters.best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index  = l1a_l1s_com.speechreco_task.parameters.second_best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score  = l1a_l1s_com.speechreco_task.parameters.second_best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index   = l1a_l1s_com.speechreco_task.parameters.third_best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score   = l1a_l1s_com.speechreco_task.parameters.third_best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise;
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size         = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size;
+
+            #if (OP_RIV_AUDIO == 1)
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_BACK_STOP:
+          {
+            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON)  ||
+                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ||
+                 (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) )
+            {
+              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+
+          case WAIT_L1S_STOP:
+          {
+            if ( (SignalCode == L1_SR_UPDATE_STOP_CON)     ||
+                 (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
+                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
+                 (SignalCode == L1_SR_RECO_STOP_IND) )
+            {
+              // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error
+            #if (OP_RIV_AUDIO == 1)
+              // Allocate the Riviera buffer
+              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
+                                      (T_RVF_BUFFER **) (&p_message));
+
+              // If insufficient resources, then report a memory error and abort.
+              if (mb_status == RVF_RED)
+              {
+                // the memory is insufficient to continue the non regression test
+                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+                return;
+              }
+
+              // Fill the message ID
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              // Fill the message parameter
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;
+
+              // send the messsage to the audio entity
+              rvf_send_msg (p_audio_gbl_var->addrId,
+                            p_message);
+            #else // OP_RIV_AUDIO
+              // Allocate confirmation message...
+              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
+              DEBUGMSG(status,NU_ALLOC_ERR)
+              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
+
+              //Fill the message
+              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;
+
+              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
+                  l1_trace_message(conf_msg);
+              #endif
+
+              // Send the confirmation message...
+              os_send_sig(conf_msg, MMI_QUEUE);
+              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
+            #endif // OP_RIV_AUDIO
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+
+      // Undefine message pointer macro.
+      #undef MSG_AUDIO
+
+    }
+
+  #endif // L1_DYN_DSP_DWNLD
+  #endif // SPEECH_RECO
+  #if (L1_AEC == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_aec_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* AEC feature.                                          */
+    /*                                                       */
+    /* Starting messages:        MMI_AEC_REQ                 */
+    /*                                                       */
+    /* Result messages (input):  none                        */
+    /*                                                       */
+    /* Result messages (output): MMI_AEC_CON                 */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if (L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_aec_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET         = 0,
+        WAIT_AEC_REQ  = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_AEC_CON  = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.aec_task.command.start = FALSE;
+
+            *state = WAIT_AEC_REQ;
+          }
+          break;
+
+          case WAIT_AEC_REQ:
+          {
+            if (SignalCode == MMI_AEC_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control;
+            #if (L1_NEW_AEC)
+              l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter;
+              l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att;
+              l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth;
+              l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max;
+              l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad;
+              l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs;
+              l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil;
+              l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut;
+            #endif
+
+            #if (L1_ANR == 1)
+              if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004)
+              {
+                // Noise suppression enabled: enable new ANR module for backward compatibility
+                l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control
+
+                // Enable L1S ANR task (default settings are used)
+                l1a_l1s_com.anr_task.parameters.anr_enable       = 1;
+                l1a_l1s_com.anr_task.parameters.min_gain         = 0x3313;
+                l1a_l1s_com.anr_task.parameters.div_factor_shift = -2;
+                l1a_l1s_com.anr_task.parameters.ns_level         = 1;
+                l1a_l1s_com.anr_task.command.update              = TRUE;
+
+                // Here we do not wait for L1S confirmation to have simple implementation
+                // because the state machine already wait for AEC confirmation and
+                // ANR confirmation would occur on the same frame
+              }
+              else
+              {
+                // Noise suppression disabled: disable ANR
+                l1a_l1s_com.anr_task.parameters.anr_enable       = 0;
+                l1a_l1s_com.anr_task.command.update              = TRUE;
+
+                // Here we do not wait for L1S confirmation to have simple implementation
+                // because the state machine already wait for AEC confirmation and
+                // ANR confirmation would occur on the same frame
+              }
+            #endif
+              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when
+                // activating the command at L1s level
+
+                // Start the L1S AEC task
+                l1a_l1s_com.aec_task.command.start = TRUE;
+
+              *state = WAIT_AEC_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"AEC SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+            {
+              // Start the L1S AEC task
+              l1a_l1s_com.aec_task.command.start = TRUE;
+
+              *state = WAIT_AEC_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"AEC SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+          return;
+          }
+          break;
+          case WAIT_AEC_CON:
+          {
+            if (SignalCode == L1_AEC_CON)
+            {
+              // Send the AEC confirmation message
+              l1a_audio_send_confirmation(MMI_AEC_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_aec_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET         = 0,
+        WAIT_AEC_REQ  = 1,
+        WAIT_AEC_CON  = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.aec_task.command.start = FALSE;
+
+            *state = WAIT_AEC_REQ;
+          }
+          break;
+
+          case WAIT_AEC_REQ:
+          {
+            if (SignalCode == MMI_AEC_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control;
+            #if (L1_NEW_AEC)
+              l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter;
+              l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att;
+              l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth;
+              l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max;
+              l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad;
+              l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs;
+              l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil;
+              l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut;
+            #endif
+
+            #if (L1_ANR == 1)
+              if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004)
+              {
+                // Noise suppression enabled: enable new ANR module for backward compatibility
+                l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control
+
+                // Enable L1S ANR task (default settings are used)
+                l1a_l1s_com.anr_task.parameters.anr_enable       = 1;
+                l1a_l1s_com.anr_task.parameters.min_gain         = 0x3313;
+                l1a_l1s_com.anr_task.parameters.div_factor_shift = -2;
+                l1a_l1s_com.anr_task.parameters.ns_level         = 1;
+                l1a_l1s_com.anr_task.command.update              = TRUE;
+
+                // Here we do not wait for L1S confirmation to have simple implementation
+                // because the state machine already wait for AEC confirmation and
+                // ANR confirmation would occur on the same frame
+              }
+              else
+              {
+                // Noise suppression disabled: disable ANR
+                l1a_l1s_com.anr_task.parameters.anr_enable       = 0;
+                l1a_l1s_com.anr_task.command.update              = TRUE;
+
+                // Here we do not wait for L1S confirmation to have simple implementation
+                // because the state machine already wait for AEC confirmation and
+                // ANR confirmation would occur on the same frame
+              }
+            #endif
+
+              // Start the L1S AEC task
+              l1a_l1s_com.aec_task.command.start = TRUE;
+
+              *state = WAIT_AEC_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_AEC_CON:
+          {
+            if (SignalCode == L1_AEC_CON)
+            {
+              // Send the AEC confirmation message
+              l1a_audio_send_confirmation(MMI_AEC_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // L1_DYN_DSP_DWNLD == 1
+  #endif // AEC
+
+  #if (L1_AEC == 2)
+      /*-------------------------------------------------------*/
+      /* l1a_mmi_aec_process()                                 */
+      /*-------------------------------------------------------*/
+      /*                                                       */
+      /* Description:                                          */
+      /* ------------                                          */
+      /* This function is a state machine which handles the    */
+      /* AEC feature.                                          */
+      /*                                                       */
+      /* Starting messages:        MMI_AEC_REQ                 */
+      /*                                                       */
+      /* Result messages (input):  none                        */
+      /*                                                       */
+      /* Result messages (output): MMI_AEC_CON                 */
+      /*                                                       */
+      /* Reset messages (input):   none                        */
+      /*                                                       */
+      /* Stop message (input):     none                        */
+      /*                                                       */
+      /* Stop message (output):    none                        */
+      /*                                                       */
+      /* Rem:                                                  */
+      /* ----                                                  */
+      /*                                                       */
+      /*-------------------------------------------------------*/
+  #if (L1_DYN_DSP_DWNLD == 1)
+      void l1a_mmi_aec_process(xSignalHeaderRec *msg)
+      {
+        enum states
+        {
+          RESET         = 0,
+          WAIT_AEC_REQ  = 1,
+          WAIT_DYN_DWNLD = 2,
+          WAIT_AEC_CON  = 3
+        };
+
+        UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
+        UWORD32   SignalCode  = msg->SignalCode;
+
+        while(1)
+        {
+          switch(*state)
+          {
+            case RESET:
+            {
+              // Reset the command
+              l1a_l1s_com.aec_task.command.start = FALSE;
+
+              *state = WAIT_AEC_REQ;
+            }
+            break;
+
+            case WAIT_AEC_REQ:
+            {
+              if (SignalCode == MMI_AQI_AEC_REQ)
+              {
+
+                // Load the message into the l1a_l1s_com memory.
+                l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control;
+
+                if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP)
+                {
+
+                	l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter;
+                	l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att;
+                	l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth;
+                	l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max;
+                	l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad;
+                	l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs;
+                	l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil;
+                	l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut;
+                	l1a_l1s_com.aec_task.parameters.aec_mode        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode;
+                	l1a_l1s_com.aec_task.parameters.mu			    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu;
+                	l1a_l1s_com.aec_task.parameters.scale_input_ul  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul;
+                	l1a_l1s_com.aec_task.parameters.scale_input_dl  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl;
+                	l1a_l1s_com.aec_task.parameters.div_dmax		= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax;
+                	l1a_l1s_com.aec_task.parameters.div_swap_good	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good;
+                	l1a_l1s_com.aec_task.parameters.div_swap_bad	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad;
+                	l1a_l1s_com.aec_task.parameters.block_init	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init;
+//                	l1a_l1s_com.aec_task.parameters.block_size	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size;
+
+				}
+
+                if (l1a.dyn_dwnld.semaphore_vect[AEC_STATE_MACHINE] == GREEN)
+                {
+                  // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when
+                  // activating the command at L1s level
+
+                  // Start the L1S AEC task
+                  l1a_l1s_com.aec_task.command.start = TRUE;
+
+                *state = WAIT_AEC_CON;
+                }
+                else
+                {
+                  *state = WAIT_DYN_DWNLD;
+
+                  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                    if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                    {
+                      char str[30];
+                      sprintf(str,"AEC SM blocked by DYN DWNLD\r\n");
+                      #if(CODE_VERSION == SIMULATION)
+                        trace_fct_simu_dyn_dwnld(str);
+                      #else
+                        rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                      #endif
+                    }
+                  #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+                }
+              }
+
+              // End process
+              return;
+            }
+ // omaps00090550             break;
+            case WAIT_DYN_DWNLD:
+            {
+              if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+              {
+                // Start the L1S AEC task
+                l1a_l1s_com.aec_task.command.start = TRUE;
+
+                *state = WAIT_AEC_CON;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                    {
+                      char str[30];
+                      sprintf(str,"AEC SM un-blocked\r\n");
+                      #if(CODE_VERSION == SIMULATION)
+                        trace_fct_simu_dyn_dwnld(str);
+                      #else
+                        rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                      #endif
+                    }
+                 #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            return;
+            }
+ // omaps00090550          break;
+            case WAIT_AEC_CON:
+            {
+              if (SignalCode == L1_AQI_AEC_CON)
+              {
+                // Send the AEC confirmation message
+                l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE);
+
+                    *state = RESET;
+              }
+              else
+              {
+                // End process
+                return;
+              }
+            }
+            break;
+          } // switch
+        } // while(1)
+      }
+  #else
+      void l1a_mmi_aec_process(xSignalHeaderRec *msg)
+      {
+        enum states
+        {
+          RESET         = 0,
+          WAIT_AEC_REQ  = 1,
+          WAIT_AEC_CON  = 2
+        };
+
+        UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
+        UWORD32   SignalCode  = msg->SignalCode;
+
+        while(1)
+        {
+          switch(*state)
+          {
+            case RESET:
+            {
+              // Reset the command
+              l1a_l1s_com.aec_task.command.start = FALSE;
+
+              *state = WAIT_AEC_REQ;
+            }
+            break;
+
+            case WAIT_AEC_REQ:
+            {
+              if (SignalCode == MMI_AQI_AEC_REQ)
+              {
+                // Load the message into the l1a_l1s_com memory.
+                l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control;
+
+                if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP)
+                {
+
+                	l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter;
+                	l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att;
+                	l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth;
+                	l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max;
+                	l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad;
+                	l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs;
+                	l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil;
+                	l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut;
+                	l1a_l1s_com.aec_task.parameters.aec_mode        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode;
+                	l1a_l1s_com.aec_task.parameters.mu			    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu;
+                	l1a_l1s_com.aec_task.parameters.scale_input_ul  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul;
+                	l1a_l1s_com.aec_task.parameters.scale_input_dl  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl;
+                	l1a_l1s_com.aec_task.parameters.div_dmax		= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax;
+                	l1a_l1s_com.aec_task.parameters.div_swap_good	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good;
+                	l1a_l1s_com.aec_task.parameters.div_swap_bad	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad;
+                	l1a_l1s_com.aec_task.parameters.block_init	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init;
+//                	l1a_l1s_com.aec_task.parameters.block_size	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size;
+
+				}
+
+              #if (L1_ANR == 1)
+                if (l1a_l1s_com.aec_task.aec_control & 0x0004)
+                {
+                  // Noise suppression enabled: enable new ANR module for backward compatibility
+                  l1a_l1s_com.aec_task.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control
+
+                  // Enable L1S ANR task (default settings are used)
+                  l1a_l1s_com.anr_task.parameters.anr_enable       = 1;
+                  l1a_l1s_com.anr_task.parameters.min_gain         = 0x3313;
+                  l1a_l1s_com.anr_task.parameters.div_factor_shift = -2;
+                  l1a_l1s_com.anr_task.parameters.ns_level         = 1;
+                  l1a_l1s_com.anr_task.command.update              = TRUE;
+
+                  // Here we do not wait for L1S confirmation to have simple implementation
+                  // because the state machine already wait for AEC confirmation and
+                  // ANR confirmation would occur on the same frame
+                }
+                else
+                {
+                  // Noise suppression disabled: disable ANR
+                  l1a_l1s_com.anr_task.parameters.anr_enable       = 0;
+                  l1a_l1s_com.anr_task.command.update              = TRUE;
+
+                  // Here we do not wait for L1S confirmation to have simple implementation
+                  // because the state machine already wait for AEC confirmation and
+                  // ANR confirmation would occur on the same frame
+                }
+              #endif
+
+                // Start the L1S AEC task
+                l1a_l1s_com.aec_task.command.start = TRUE;
+
+                *state = WAIT_AEC_CON;
+              }
+
+              // End process
+              return;
+            }
+            break;
+
+            case WAIT_AEC_CON:
+            {
+              if (SignalCode == L1_AQI_AEC_CON)
+              {
+                // Send the AEC confirmation message
+                l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE);
+
+                    *state = RESET;
+              }
+              else
+              {
+                // End process
+                return;
+              }
+            }
+            break;
+          } // switch
+        } // while(1)
+      }
+    #endif // L1_DYN_DSP_DWNLD == 1
+    #endif // L1_AEC == 2
+
+
+  #if (FIR)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_fir_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* FIR feature.                                          */
+    /*                                                       */
+    /* Starting messages:        MMI_AUDIO_FIR_REQ           */
+    /*                                                       */
+    /* Result messages (input):  none                        */
+    /*                                                       */
+    /* Result messages (output): MMI_AUDIO_FIR_CON           */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_fir_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET         = 0,
+        WAIT_FIR_REQ  = 1,
+        WAIT_FIR_CON  = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_FIR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.fir_task.command.start = FALSE;
+
+            *state = WAIT_FIR_REQ;
+          }
+          break;
+
+          case WAIT_FIR_REQ:
+          {
+            if (SignalCode == MMI_AUDIO_FIR_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.fir_task.parameters.fir_loop = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_loop;
+              l1a_l1s_com.fir_task.parameters.update_fir = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->update_fir;
+              l1a_l1s_com.fir_task.parameters.fir_ul_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_ul_coefficient;
+
+              // we update FIR coefficients even if L1_IIR==1 because in case of loop mode
+              // this is the old FIR API that is used
+              l1a_l1s_com.fir_task.parameters.fir_dl_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient;
+
+              #if (L1_IIR == 1)
+                if (l1a_l1s_com.fir_task.parameters.update_fir & DL_FIR)
+                {
+                  // FIR DL update enabled: enable new IIR/DL module for backward compatibility
+
+                  // Enable L1S IIR task
+                  // Settings tuned to have same behavior as DL FIR
+                  l1a_l1s_com.iir_task.parameters.iir_enable          = 1; // Filter always enabled
+                  l1a_l1s_com.iir_task.parameters.nb_iir_blocks       = 0; // IIR part disabled
+                  l1a_l1s_com.iir_task.parameters.iir_coefs           = 0;
+                  l1a_l1s_com.iir_task.parameters.nb_fir_coefs        = 0x1f;
+                  l1a_l1s_com.iir_task.parameters.fir_coefs           = (WORD16 *)((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient;
+                  l1a_l1s_com.iir_task.parameters.input_scaling       = 0;
+                  l1a_l1s_com.iir_task.parameters.fir_scaling         = 0;
+                  l1a_l1s_com.iir_task.parameters.input_gain_scaling  = 0;
+                  l1a_l1s_com.iir_task.parameters.output_gain_scaling = 0;
+                  l1a_l1s_com.iir_task.parameters.output_gain         = 0xffff; // Used for IIR using in FIR mode
+                  l1a_l1s_com.iir_task.parameters.feedback            = 0;
+                  l1a_l1s_com.iir_task.command.update                 = TRUE;
+
+                  // Here we do not wait for L1S confirmation to have simple implementation
+                  // because the state machine already wait for FIR confirmation and
+                  // there is no chance that upper layer frees the memory used to store
+                  // DL coefficients before L1S copy them into API
+                }
+              #endif
+
+              // Start the L1S FIR task
+              l1a_l1s_com.fir_task.command.start = TRUE;
+
+              *state = WAIT_FIR_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550        break;
+
+          case WAIT_FIR_CON:
+          {
+            if (SignalCode == L1_AUDIO_FIR_CON)
+            {
+              // Send the FIR confirmation message
+              l1a_audio_send_confirmation(MMI_AUDIO_FIR_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // FIR
+  #if (AUDIO_MODE)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_audio_mode_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* audio mode features.                                  */
+    /*                                                       */
+    /* Starting messages:        MMI_AUDIO_MODE_REQ          */
+    /*                                                       */
+    /* Result messages (input):  none                        */
+    /*                                                       */
+    /* Result messages (output): MMI_AUDIO_MODE_CON          */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_audio_mode_process (xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET                = 0,
+        WAIT_AUDIO_MODE_REQ  = 1,
+        WAIT_AUDIO_MODE_CON  = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AUDIO_MODE_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.audio_mode_task.command.start = FALSE;
+
+            *state = WAIT_AUDIO_MODE_REQ;
+          }
+          break;
+
+          case WAIT_AUDIO_MODE_REQ:
+          {
+            if (SignalCode == MMI_AUDIO_MODE_REQ)
+            {
+              switch (((T_MMI_AUDIO_MODE *)(msg->SigP))->audio_mode)
+              {
+                case GSM_ONLY:
+                {
+                  // Set the GSM only mode
+                  l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_GSM_ONLY;
+                  break;
+                }
+                case BT_CORDLESS:
+                {
+                  // Set the bluetooth cordless mode
+                  l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_CORDLESS;
+                  break;
+                }
+                case BT_HEADSET:
+                {
+                  // Set the bluetooth headset mode
+                  l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_HEADSET;
+                  break;
+                }
+                default :
+                {
+                  break;
+                }
+              } // switch
+
+              // Start the L1S AUDIO MODE task
+              l1a_l1s_com.audio_mode_task.command.start = TRUE;
+
+              *state = WAIT_AUDIO_MODE_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+
+          case WAIT_AUDIO_MODE_CON:
+          {
+            if (SignalCode == L1_AUDIO_MODE_CON)
+            {
+              // Send the AUDIO MODE confirmation message
+              l1a_audio_send_confirmation(MMI_AUDIO_MODE_CON);
+
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // AUDIO_MODE
+  #if (MELODY_E2)
+  #if(L1_DYN_DSP_DWNLD==1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_melody0_e2_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* melody 0 format E2 feature.                           */
+    /*                                                       */
+    /* Starting messages:        MMI_MELODY0_E2_START_REQ    */
+    /*                                                       */
+    /* Result messages (input):  L1_MELODY0_E2_START_CON     */
+    /*                                                       */
+    /* Result messages (output): MMI_MELODY0_E2_START_CON    */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
+    /*                           L1_MELODY0_E2_STOP_CON      */
+    /*                                                       */
+    /* Stop message (output):    MMI_MELODY0_E2_STOP_CON     */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        M0_RESET                  = 0,
+        M0_WAIT_START_REQ         = 1,
+        WAIT_DYN_DWNLD = 2,
+        M0_WAIT_LOAD_INSTRUMENT   = 3,
+        M0_WAIT_STOP              = 4,
+        M0_WAIT_UNLOAD_INSTRUMENT = 5
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_MELODY0_E2_STATE], i;
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case M0_RESET:
+          {
+            // Reset the commands:
+            l1a_l1s_com.melody0_e2_task.command.start = FALSE;
+            l1a_l1s_com.melody0_e2_task.command.stop  = FALSE;
+
+            *state = M0_WAIT_START_REQ;
+          }
+          break;
+
+          case M0_WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_MELODY0_E2_START_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.melody0_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;
+
+              if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE]==GREEN)
+              {
+
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+                // Disable trace DSP upon E2 MELODY activation
+                l1_disable_dsp_trace();
+#endif
+                // Reset the emergency flag
+                l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE;
+
+                // Initialize the buffer parameters
+                l1a_l1s_com.melody0_e2_task.parameters.ptr_buf        = NULL;
+                l1a_l1s_com.melody0_e2_task.parameters.buffer_size    = 0;
+                l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                 &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                 l1a_l1s_com.melody0_e2_task.parameters.session_id);
+
+                // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
+                l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1;
+
+                // Jump the NumberOfOscillator parameter
+                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+
+                // Read the Header of the melody description in order to download the time factor
+                // clean the MSB of the global time factor register
+                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
+                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;
+
+
+                // Find the number of insturment of the melody (jump the header memory)
+                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument));
+
+                for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++)
+                {
+                  // find the beginning of the melody description (after the header field)
+                  // and put it in the buf_ptr buffer
+                  l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                     &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                     (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                     1,
+                                                                                     &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]));
+                }
+
+                // Initialize the size (in byte unit) of the header
+                l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument;
+
+                // download the instrument
+                l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0);
+
+                // Send the start confirmation message
+                l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON);
+
+                *state = M0_WAIT_LOAD_INSTRUMENT;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"E20 SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN))
+            {
+              // Reset the emergency flag
+              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE;
+
+              // Initialize the buffer parameters
+              l1a_l1s_com.melody0_e2_task.parameters.ptr_buf        = NULL;
+              l1a_l1s_com.melody0_e2_task.parameters.buffer_size    = 0;
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                 &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                 l1a_l1s_com.melody0_e2_task.parameters.session_id);
+
+              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
+              l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1;
+
+              // Jump the NumberOfOscillator parameter
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+
+              // Read the Header of the melody description in order to download the time factor
+              // clean the MSB of the global time factor register
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;
+
+
+              // Find the number of insturment of the melody (jump the header memory)
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument));
+
+              for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++)
+              {
+                // find the beginning of the melody description (after the header field)
+                // and put it in the buf_ptr buffer
+                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                     &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                     (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                     1,
+                                                                                     &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]));
+              }
+
+              // Initialize the size (in byte unit) of the header
+              l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument;
+
+              // download the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON);
+
+              *state = M0_WAIT_LOAD_INSTRUMENT;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"E20 SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+          break;
+          case M0_WAIT_LOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
+              {
+                // The load instrument confirmation message is for the melody 0
+                if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop)
+                {
+                  // Unload the instrument
+                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);
+
+                  *state = M0_WAIT_UNLOAD_INSTRUMENT;
+
+                }
+                else
+                {
+                  // Start to play the melody0
+                  l1a_l1s_com.melody0_e2_task.command.start = TRUE;
+
+                  *state = M0_WAIT_STOP;
+                }
+              }
+            }
+            else
+            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
+            {
+              // Set the emergency flag
+              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M0_WAIT_STOP:
+          {
+            if (SignalCode == L1_MELODY0_E2_STOP_CON)
+            {
+              // Unload the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);
+
+              *state = M0_WAIT_UNLOAD_INSTRUMENT;
+            }
+            else
+            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
+            {
+              // Stop the melody 0 L1S task:
+              l1a_l1s_com.melody0_e2_task.command.stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M0_WAIT_UNLOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
+              {
+                // Send the stop confirmation message
+                l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON);
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+                // Enable trace DSP upon E2 MELODY deactivation
+                l1_enable_dsp_trace();
+#endif
+
+                *state = M0_RESET;
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_melody1_e2_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* melody 1 format E2 feature.                           */
+    /*                                                       */
+    /* Starting messages:        MMI_MELODY1_E2_START_REQ    */
+    /*                                                       */
+    /* Result messages (input):  L1_MELODY1_E2_START_CON     */
+    /*                                                       */
+    /* Result messages (output): MMI_MELODY1_E2_START_CON    */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
+    /*                           L1_MELODY1_E2_STOP_CON      */
+    /*                                                       */
+    /* Stop message (output):    MMI_MELODY1_E2_STOP_CON     */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        M1_RESET                  = 0,
+        M1_WAIT_START_REQ         = 1,
+        WAIT_DYN_DWNLD = 2,
+        M1_WAIT_LOAD_INSTRUMENT   = 3,
+        M1_WAIT_STOP              = 4,
+        M1_WAIT_UNLOAD_INSTRUMENT = 5
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_MELODY1_E2_STATE], i;
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case M1_RESET:
+          {
+            // Reset the commands:
+            l1a_l1s_com.melody1_e2_task.command.start = FALSE;
+            l1a_l1s_com.melody1_e2_task.command.stop  = FALSE;
+
+            *state = M1_WAIT_START_REQ;
+          }
+          break;
+
+          case M1_WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_MELODY1_E2_START_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.melody1_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;
+
+              if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+                // Disable trace DSP upon E2 MELODY activation
+                l1_disable_dsp_trace();
+#endif
+                // Reset the emergency flag
+                l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE;
+
+                // Initialize the buffer parameters
+                l1a_l1s_com.melody1_e2_task.parameters.ptr_buf        = NULL;
+                l1a_l1s_com.melody1_e2_task.parameters.buffer_size    = 0;
+                l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                 &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                 l1a_l1s_com.melody1_e2_task.parameters.session_id);
+
+                // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
+                l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1;
+
+                // Jump the NumberOfOscillator parameter
+                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+
+                // Read the Header of the melody description in order to download the time factor
+                // clean the MSB of the global time factor register
+                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
+                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;
+
+
+                // Find the number of insturment of the melody (jump the header memory)
+                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument));
+
+                for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++)
+                {
+                  // find the beginning of the melody description (after the header field)
+                  // and put it in the buf_ptr buffer
+                  l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                     &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                     (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                     1,
+                                                                                     &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]));
+                }
+
+                // Initialize the size (in byte unit) of the header
+                l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument;
+
+                // download the instrument
+                l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1);
+
+                // Send the start confirmation message
+                l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON);
+
+                *state = M1_WAIT_LOAD_INSTRUMENT;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"E21 SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN))
+            {
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+              // Disable trace DSP upon E2 MELODY activation
+              l1_disable_dsp_trace();
+#endif
+              // Reset the emergency flag
+              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE;
+
+              // Initialize the buffer parameters
+              l1a_l1s_com.melody1_e2_task.parameters.ptr_buf        = NULL;
+              l1a_l1s_com.melody1_e2_task.parameters.buffer_size    = 0;
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                 &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                 l1a_l1s_com.melody1_e2_task.parameters.session_id);
+
+              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
+              l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1;
+
+              // Jump the NumberOfOscillator parameter
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+
+              // Read the Header of the melody description in order to download the time factor
+              // clean the MSB of the global time factor register
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;
+
+
+              // Find the number of insturment of the melody (jump the header memory)
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument));
+
+              for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++)
+              {
+                // find the beginning of the melody description (after the header field)
+                // and put it in the buf_ptr buffer
+                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                     &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                     (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                     1,
+                                                                                     &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]));
+              }
+
+              // Initialize the size (in byte unit) of the header
+              l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument;
+
+              // download the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON);
+
+              *state = M1_WAIT_LOAD_INSTRUMENT;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"E21 SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+          break;
+          case M1_WAIT_LOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
+              {
+                // The load instrument confirmation message is for the melody 1
+                if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop)
+                {
+                  // Unload the instrument
+                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);
+
+                  *state = M1_WAIT_UNLOAD_INSTRUMENT;
+
+                }
+                else
+                {
+                  // Start to play the melody1
+                  l1a_l1s_com.melody1_e2_task.command.start = TRUE;
+
+                  *state = M1_WAIT_STOP;
+                }
+              }
+            }
+            else
+            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
+            {
+              // Set the emergency flag
+              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M1_WAIT_STOP:
+          {
+            if (SignalCode == L1_MELODY1_E2_STOP_CON)
+            {
+              // Unload the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);
+
+              *state = M1_WAIT_UNLOAD_INSTRUMENT;
+            }
+            else
+            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
+            {
+              // Stop the melody 0 L1S task:
+              l1a_l1s_com.melody1_e2_task.command.stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M1_WAIT_UNLOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
+              {
+                // Send the stop confirmation message
+                l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON);
+
+                *state = M1_RESET;
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+                // Enable trace DSP upon E2 MELODY deactivation
+                l1_enable_dsp_trace();
+#endif
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+#else // L1_DYN_DSP_DWNLD = 0
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_melody0_e2_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* melody 0 format E2 feature.                           */
+    /*                                                       */
+    /* Starting messages:        MMI_MELODY0_E2_START_REQ    */
+    /*                                                       */
+    /* Result messages (input):  L1_MELODY0_E2_START_CON     */
+    /*                                                       */
+    /* Result messages (output): MMI_MELODY0_E2_START_CON    */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
+    /*                           L1_MELODY0_E2_STOP_CON      */
+    /*                                                       */
+    /* Stop message (output):    MMI_MELODY0_E2_STOP_CON     */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+
+    void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        M0_RESET                  = 0,
+        M0_WAIT_START_REQ         = 1,
+        M0_WAIT_LOAD_INSTRUMENT   = 2,
+        M0_WAIT_STOP              = 3,
+        M0_WAIT_UNLOAD_INSTRUMENT = 4
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_MELODY0_E2_STATE], i;
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case M0_RESET:
+          {
+            // Reset the commands:
+            l1a_l1s_com.melody0_e2_task.command.start = FALSE;
+            l1a_l1s_com.melody0_e2_task.command.stop  = FALSE;
+
+            *state = M0_WAIT_START_REQ;
+          }
+          break;
+
+          case M0_WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_MELODY0_E2_START_REQ)
+            {
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+              // Disable trace DSP upon E2 MELODY activation
+              l1_disable_dsp_trace();
+#endif
+              // Download the parameters from the message:
+              l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.melody0_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;
+
+              // Reset the emergency flag
+              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE;
+
+              // Initialize the buffer parameters
+              l1a_l1s_com.melody0_e2_task.parameters.ptr_buf        = NULL;
+              l1a_l1s_com.melody0_e2_task.parameters.buffer_size    = 0;
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                 &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                 l1a_l1s_com.melody0_e2_task.parameters.session_id);
+
+              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
+              l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1;
+
+              // Jump the NumberOfOscillator parameter
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+
+              // Read the Header of the melody description in order to download the time factor
+              // clean the MSB of the global time factor register
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;
+
+
+              // Find the number of insturment of the melody (jump the header memory)
+              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument));
+
+              for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++)
+              {
+                // find the beginning of the melody description (after the header field)
+                // and put it in the buf_ptr buffer
+                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
+                                                                                     &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
+                                                                                     (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
+                                                                                     1,
+                                                                                     &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]));
+              }
+
+              // Initialize the size (in byte unit) of the header
+              l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument;
+
+              // download the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON);
+
+              *state = M0_WAIT_LOAD_INSTRUMENT;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M0_WAIT_LOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
+              {
+                // The load instrument confirmation message is for the melody 0
+                if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop)
+                {
+                  // Unload the instrument
+                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);
+
+                  *state = M0_WAIT_UNLOAD_INSTRUMENT;
+
+                }
+                else
+                {
+                  // Start to play the melody0
+                  l1a_l1s_com.melody0_e2_task.command.start = TRUE;
+
+                  *state = M0_WAIT_STOP;
+                }
+              }
+            }
+            else
+            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
+            {
+              // Set the emergency flag
+              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M0_WAIT_STOP:
+          {
+            if (SignalCode == L1_MELODY0_E2_STOP_CON)
+            {
+              // Unload the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);
+
+              *state = M0_WAIT_UNLOAD_INSTRUMENT;
+            }
+            else
+            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
+            {
+              // Stop the melody 0 L1S task:
+              l1a_l1s_com.melody0_e2_task.command.stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M0_WAIT_UNLOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
+              {
+                // Send the stop confirmation message
+                l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON);
+
+                *state = M0_RESET;
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+                // Enable trace DSP upon E2 MELODY deactivation
+                l1_enable_dsp_trace();
+#endif
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_melody1_e2_process()                          */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* melody 1 format E2 feature.                           */
+    /*                                                       */
+    /* Starting messages:        MMI_MELODY1_E2_START_REQ    */
+    /*                                                       */
+    /* Result messages (input):  L1_MELODY1_E2_START_CON     */
+    /*                                                       */
+    /* Result messages (output): MMI_MELODY1_E2_START_CON    */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
+    /*                           L1_MELODY1_E2_STOP_CON      */
+    /*                                                       */
+    /* Stop message (output):    MMI_MELODY1_E2_STOP_CON     */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        M1_RESET                  = 0,
+        M1_WAIT_START_REQ         = 1,
+        M1_WAIT_LOAD_INSTRUMENT   = 2,
+        M1_WAIT_STOP              = 3,
+        M1_WAIT_UNLOAD_INSTRUMENT = 4
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_MELODY1_E2_STATE], i;
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case M1_RESET:
+          {
+            // Reset the commands:
+            l1a_l1s_com.melody1_e2_task.command.start = FALSE;
+            l1a_l1s_com.melody1_e2_task.command.stop  = FALSE;
+
+            *state = M1_WAIT_START_REQ;
+          }
+          break;
+
+          case M1_WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_MELODY1_E2_START_REQ)
+            {
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+            // Disable trace DSP upon E2 MELODY activation
+            l1_disable_dsp_trace();
+#endif
+
+              // Download the parameters from the message:
+              l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
+              l1a_l1s_com.melody1_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;
+
+              // Reset the emergency flag
+              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE;
+
+              // Initialize the buffer parameters
+              l1a_l1s_com.melody1_e2_task.parameters.ptr_buf        = NULL;
+              l1a_l1s_com.melody1_e2_task.parameters.buffer_size    = 0;
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                 &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                 l1a_l1s_com.melody1_e2_task.parameters.session_id);
+
+              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
+              l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1;
+
+              // Jump the NumberOfOscillator parameter
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+
+              // Read the Header of the melody description in order to download the time factor
+              // clean the MSB of the global time factor register
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   (UWORD8 *)(&(i)));
+              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;
+
+
+              // Find the number of insturment of the melody (jump the header memory)
+              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                   1,
+                                                                                   &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument));
+
+              for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++)
+              {
+                // find the beginning of the melody description (after the header field)
+                // and put it in the buf_ptr buffer
+                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
+                                                                                     &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
+                                                                                     (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
+                                                                                     1,
+                                                                                     &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]));
+              }
+
+              // Initialize the size (in byte unit) of the header
+              l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument;
+
+              // download the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1);
+
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON);
+
+              *state = M1_WAIT_LOAD_INSTRUMENT;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M1_WAIT_LOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
+              {
+                // The load instrument confirmation message is for the melody 1
+                if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop)
+                {
+                  // Unload the instrument
+                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);
+
+                  *state = M1_WAIT_UNLOAD_INSTRUMENT;
+
+                }
+                else
+                {
+                  // Start to play the melody1
+                  l1a_l1s_com.melody1_e2_task.command.start = TRUE;
+
+                  *state = M1_WAIT_STOP;
+                }
+              }
+            }
+            else
+            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
+            {
+              // Set the emergency flag
+              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M1_WAIT_STOP:
+          {
+            if (SignalCode == L1_MELODY1_E2_STOP_CON)
+            {
+              // Unload the instrument
+              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);
+
+              *state = M1_WAIT_UNLOAD_INSTRUMENT;
+            }
+            else
+            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
+            {
+              // Stop the melody 0 L1S task:
+              l1a_l1s_com.melody1_e2_task.command.stop = TRUE;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case M1_WAIT_UNLOAD_INSTRUMENT:
+          {
+            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
+            {
+              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
+              {
+                // Send the stop confirmation message
+                l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON);
+
+                *state = M1_RESET;
+#if ((TRACE_TYPE==1) || (TRACE_TYPE == 4))
+                // Enable trace DSP upon E2 MELODY deactivation
+                l1_enable_dsp_trace();
+#endif
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // L1_DYN_DSP_DWNLD
+  #endif // MELODY_E2
+
+  #if (L1_CPORT == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_cport_process()                               */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* cport configuration feature.                          */
+    /*                                                       */
+    /* Starting messages:        MMI_CPORT_CONFIGURE_REQ     */
+    /*                                                       */
+    /* Result messages (input):  L1_CPORT_CONFIGURE_CON      */
+    /*                                                       */
+    /* Result messages (output): MMI_CPORT_CONFIGURE_CON     */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_cport_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_CPORT_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.cport_task.command.start = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_CPORT_CONFIGURE_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.cport_task.parameters.configuration = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->configuration;
+              l1a_l1s_com.cport_task.parameters.cpcfr1        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr1;
+              l1a_l1s_com.cport_task.parameters.cpcfr2        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr2;
+              l1a_l1s_com.cport_task.parameters.cpcfr3        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr3;
+              l1a_l1s_com.cport_task.parameters.cpcfr4        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr4;
+              l1a_l1s_com.cport_task.parameters.cptctl        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptctl;
+              l1a_l1s_com.cport_task.parameters.cptdat        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptdat;
+              l1a_l1s_com.cport_task.parameters.cpttaddr      = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpttaddr;
+              l1a_l1s_com.cport_task.parameters.cptvs         = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptvs;
+              l1a_l1s_com.cport_task.parameters.ctrl          = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->ctrl;
+
+              // Start the L1S cport task
+              l1a_l1s_com.cport_task.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_CPORT_CONFIGURE_CON)
+            {
+              // Forward the stop confirmation message
+              l1a_audio_send_result(MMI_CPORT_CONFIGURE_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+        } // switch
+      } // while(1)
+    }
+  #endif // L1_CPORT == 1
+
+  #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_audio_onoff_process()                         */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* audio on/off feature.                                 */
+    /*                                                       */
+    /* Starting messages:        MMI_AUDIO_ONOFF_REQ         */
+    /*                                                       */
+    /* Result messages (input):  L1_AUDIO_ONOFF_CON          */
+    /*                                                       */
+    /* Result messages (output): MMI_AUDIO_ONOFF_CON         */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AUDIO_ONOFF_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.audio_onoff_task.command.start = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_AUDIO_ONOFF_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.audio_onoff_task.parameters.onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->onoff_value;
+
+              // Start the L1S keybeep task
+              l1a_l1s_com.audio_onoff_task.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_AUDIO_ONOFF_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif
+
+  #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_audio_onoff_process()                         */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* audio on/off feature.                                 */
+    /*                                                       */
+    /* Starting messages:        MMI_AUDIO_ONOFF_REQ         */
+    /*                                                       */
+    /* Result messages (input):  L1_AUDIO_ONOFF_CON          */
+    /*                                                       */
+    /* Result messages (output): MMI_AUDIO_ONOFF_CON         */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AUDIO_ONOFF_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.audio_onoff_task.command.start = FALSE;
+
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_AUDIO_ONOFF_REQ)
+            {
+              // Download the parameters from the message:
+              l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vul_onoff_value;
+              l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vdl_onoff_value;
+              // Start the L1S keybeep task
+              l1a_l1s_com.audio_onoff_task.command.start = TRUE;
+
+              *state = WAIT_START_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550        break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_AUDIO_ONOFF_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550      break;
+        } // switch
+      } // while(1)
+    }
+  #endif
+
+
+  #if (L1_EXT_AUDIO_MGT == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_ext_audio_mgt_process()                       */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* external audio management feature.                    */
+    /*                                                       */
+    /* Starting messages:        MMI_EXT_AUDIO_MGT_START_REQ */
+    /*                                                       */
+    /* Result messages (input):  L1_STEREOPATH_DRV_START_CON */
+    /*                                                       */
+    /* Result messages (output): MMI_EXT_AUDIO_MGT_START_CON */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     MMI_EXT_AUDIO_MGT_STOP_REQ  */
+    /*                           L1_STEREOPATH_DRV_STOP_CON  */
+    /*                                                       */
+    /* Stop message (output):    MMI_EXT_AUDIO_MGT_STOP_CON  */
+    /*                                                       */
+    /* Rem:                                                  */
+    /* ----                                                  */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_ext_audio_mgt_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_START_REQ    = 1,
+        WAIT_START_CON    = 2,
+        WAIT_STOP         = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_EXT_AUDIO_MGT_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+      UWORD8 sample_rate;
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+#if(L1_BT_AUDIO ==1)
+	      midi_task_running=FALSE;
+#endif
+            *state = WAIT_START_REQ;
+          }
+          break;
+
+          case WAIT_START_REQ:
+          {
+            if (SignalCode == MMI_EXT_AUDIO_MGT_START_REQ)
+            {
+              // save global variable
+              l1s.ext_audio_mgt.session_id = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->session_id;
+		#if(L1_BT_AUDIO ==1)
+		  l1_audio_bt_init(AUDIO_EXT_MIDI_BUFFER_SIZE);
+		  if(bt_audio.connected_status==TRUE)
+            	  {
+			bt_audio.pcmconfig.bitsPerSample=16;
+			bt_audio.pcmconfig.numChannels =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo+1;
+	              sample_rate   =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency;
+			bt_audio.pcmconfig.sampleRate   =l1_ext_audio_get_frequencyrate(sample_rate);
+			bt_audio.audio_configure_callback(&bt_audio.pcmconfig);
+            	  }	
+		 #endif
+	if(bt_audio.connected_status==FALSE)
+     	  {
+              // Download the stereopath description.
+              l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency    = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency;
+              l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation        = AUDIO_SP_DMA_ALLOC_MCU;
+              l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct  = l1_ext_audio_mgt_dma_handler;
+              l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number    = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->DMA_channel_number;
+              l1a_l1s_com.stereopath_drv_task.parameters.data_type             = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->data_type;
+              l1a_l1s_com.stereopath_drv_task.parameters.source_port           = AUDIO_SP_SOURCE_IMIF;
+              l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->source_buffer_address;
+              l1a_l1s_com.stereopath_drv_task.parameters.element_number        = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->element_number;
+              l1a_l1s_com.stereopath_drv_task.parameters.frame_number          = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->frame_number;
+              l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo           = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo;
+              l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier    = AUDIO_SP_EXT_AUDIO_ID;
+
+              // Start the L1S stereopath task
+              l1a_l1s_com.stereopath_drv_task.command.start = TRUE;
+#if(L1_BT_AUDIO ==1)
+              midi_task_running=TRUE;
+#endif
+
+              *state = WAIT_START_CON;
+            }
+	   else
+	  {
+ 		  l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON);
+
+              *state = WAIT_STOP;
+	   }
+            // End process
+            return;
+          }
+          }
+ // omaps00090550         break;
+
+          case WAIT_START_CON:
+          {
+            if (SignalCode == L1_STEREOPATH_DRV_START_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON);
+
+              *state = WAIT_STOP;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550        break;
+
+          case WAIT_STOP:
+          {
+            if (SignalCode == MMI_EXT_AUDIO_MGT_STOP_REQ)
+            {
+		if(bt_audio.connected_status==TRUE)
+     	  	{
+
+	       // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON);
+	        midi_task_running=FALSE;
+	       *state = RESET;
+		}
+		else
+		{
+              // Stop the L1S stereopath task
+              l1a_l1s_com.stereopath_drv_task.command.stop = TRUE;
+
+              // End process
+              return;
+            }
+            }
+
+            if (SignalCode == L1_STEREOPATH_DRV_STOP_CON)
+            {
+
+              // Send the stop confirmation message
+              l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON);
+	      #if(L1_BT_AUDIO ==1)
+              midi_task_running=FALSE;
+	     #endif
+              *state = RESET;
+            }
+            else
+            {
+              // End process
+              return;
+            }
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // EXT_AUDIO_MGT == 1
+
+  #if (L1_ANR == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_anr_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* ANR feature.                                          */
+    /*                                                       */
+    /* Starting messages:        MMI_ANR_REQ                 */
+    /*                                                       */
+    /* Result messages (input):  L1_ANR_CON                  */
+    /*                                                       */
+    /* Result messages (output): MMI_ANR_CON                 */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if(L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.anr_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_ANR_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.anr_task.parameters.anr_enable       = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable;
+              l1a_l1s_com.anr_task.parameters.min_gain         = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain;
+              l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift;
+              l1a_l1s_com.anr_task.parameters.ns_level         = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level;
+
+              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
+                // when activating the task at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.anr_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"ANR SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.anr_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"ANR SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_ANR_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_ANR_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.anr_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_ANR_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.anr_task.parameters.anr_enable       = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable;
+              l1a_l1s_com.anr_task.parameters.min_gain         = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain;
+              l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift;
+              l1a_l1s_com.anr_task.parameters.ns_level         = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level;
+
+              // Enable the L1S task
+              l1a_l1s_com.anr_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_ANR_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_ANR_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#endif // L1_DYN_DSP_DWNLD
+  #endif // L1_ANR
+#if (L1_ANR == 2) // ANR 2.13
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_anr_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* ANR 2.13 feature.                                     */
+    /*                                                       */
+    /* Starting messages:        MMI_AQI_ANR_REQ             */
+    /*                                                       */
+    /* Result messages (input):  L1_AQI_ANR_CON              */
+    /*                                                       */
+    /* Result messages (output): MMI_AQI_ANR_CON             */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if(L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.anr_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_ANR_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.anr_task.parameters.anr_ul_control     = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control;
+              l1a_l1s_com.anr_task.parameters.control            = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control;
+              l1a_l1s_com.anr_task.parameters.ns_level           = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level;
+              l1a_l1s_com.anr_task.parameters.tone_ene_th        = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th;
+              l1a_l1s_com.anr_task.parameters.tone_cnt_th        = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th;
+
+              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
+                // when activating the task at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.anr_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"ANR SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+          case WAIT_DYN_DWNLD:
+          {
+            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.anr_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"ANR SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+ // omaps00090550        break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_ANR_CON)
+            {
+              // Send the confirmation message
+              l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.anr_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_ANR_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.anr_task.parameters.anr_ul_control   = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control;
+              l1a_l1s_com.anr_task.parameters.control          = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control;
+              l1a_l1s_com.anr_task.parameters.ns_level         = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level;
+              l1a_l1s_com.anr_task.parameters.tone_ene_th      = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th;
+              l1a_l1s_com.anr_task.parameters.tone_cnt_th      = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th;
+
+              // Enable the L1S task
+              l1a_l1s_com.anr_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_ANR_CON)
+            {
+              // Send the confirmation message
+              l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#endif // L1_DYN_DSP_DWNLD
+#endif // L1_ANR
+
+  #if (L1_IIR == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_iir_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* IIR feature.                                          */
+    /*                                                       */
+    /* Starting messages:        MMI_IIR_REQ                 */
+    /*                                                       */
+    /* Result messages (input):  L1_IIR_CON                  */
+    /*                                                       */
+    /* Result messages (output): MMI_IIR_CON                 */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_iir_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_IIR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.iir_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_IIR_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.iir_task.parameters.iir_enable          = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_enable;
+              l1a_l1s_com.iir_task.parameters.nb_iir_blocks       = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_iir_blocks;
+              l1a_l1s_com.iir_task.parameters.iir_coefs           = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_coefs;
+              l1a_l1s_com.iir_task.parameters.nb_fir_coefs        = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_fir_coefs;
+              l1a_l1s_com.iir_task.parameters.fir_coefs           = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_coefs;
+              l1a_l1s_com.iir_task.parameters.input_scaling       = ((T_MMI_IIR_REQ *)(msg->SigP))->input_scaling;
+              l1a_l1s_com.iir_task.parameters.fir_scaling         = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_scaling;
+              l1a_l1s_com.iir_task.parameters.input_gain_scaling  = ((T_MMI_IIR_REQ *)(msg->SigP))->input_gain_scaling;
+              l1a_l1s_com.iir_task.parameters.output_gain_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain_scaling;
+              l1a_l1s_com.iir_task.parameters.output_gain         = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain;
+              l1a_l1s_com.iir_task.parameters.feedback            = ((T_MMI_IIR_REQ *)(msg->SigP))->feedback;
+
+              // Enable the L1S task
+              l1a_l1s_com.iir_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_IIR_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_IIR_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif // L1_IIR
+
+ #if (L1_AGC_UL == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_agc_ul_process()                              */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* AGC UL feature.                                       */
+    /*                                                       */
+    /* Starting messages:        MMI_AQI_AGC_UL_REQ          */
+    /*                                                       */
+    /* Result messages (input):  L1_AQI_AGC_UL_CON           */
+    /*                                                       */
+    /* Result messages (output): MMI_AQI_AGC_UL_CON          */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if(L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AGC_UL_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.agc_ul_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_AGC_UL_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.agc_ul_task.parameters.agc_ul_control         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control;
+              l1a_l1s_com.agc_ul_task.parameters.control                = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control;
+              l1a_l1s_com.agc_ul_task.parameters.frame_size             = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size;
+              l1a_l1s_com.agc_ul_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level;
+              l1a_l1s_com.agc_ul_task.parameters.signal_up              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up;
+              l1a_l1s_com.agc_ul_task.parameters.signal_down            = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down;
+              l1a_l1s_com.agc_ul_task.parameters.max_scale              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
+              l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag;
+
+
+              if (l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
+                // when activating the task at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.agc_ul_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"AGC_UL SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.agc_ul_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"AGC_UL SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+ // omaps00090550        break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_AGC_UL_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AGC_UL_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.agc_ul_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_AGC_UL_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.agc_ul_task.parameters.agc_ul_control         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control;
+              l1a_l1s_com.agc_ul_task.parameters.control                = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control;
+              l1a_l1s_com.agc_ul_task.parameters.frame_size             = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size;
+              l1a_l1s_com.agc_ul_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level;
+              l1a_l1s_com.agc_ul_task.parameters.signal_up              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up;
+              l1a_l1s_com.agc_ul_task.parameters.signal_down            = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down;
+              l1a_l1s_com.agc_ul_task.parameters.max_scale              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
+              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
+              l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag;
+
+              // Enable the L1S task
+              l1a_l1s_com.agc_ul_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_AGC_UL_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#endif // L1_DYN_DSP_DWNLD
+
+#endif // L1_AGC_UL
+
+
+#if (L1_AGC_DL == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_agc_dl_process()                              */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* AGC DL feature.                                       */
+    /*                                                       */
+    /* Starting messages:        MMI_AQI_AGC_DL_REQ          */
+    /*                                                       */
+    /* Result messages (input):  L1_AQI_AGC_DL_CON           */
+    /*                                                       */
+    /* Result messages (output): MMI_AQI_AGC_DL_CON          */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if(L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AGC_DL_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.agc_dl_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_AGC_DL_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.agc_dl_task.parameters.agc_dl_control         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control;
+              l1a_l1s_com.agc_dl_task.parameters.control                = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control;
+              l1a_l1s_com.agc_dl_task.parameters.frame_size             = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size;
+              l1a_l1s_com.agc_dl_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level;
+              l1a_l1s_com.agc_dl_task.parameters.signal_up              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up;
+              l1a_l1s_com.agc_dl_task.parameters.signal_down            = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down;
+              l1a_l1s_com.agc_dl_task.parameters.max_scale              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
+              l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag;
+
+
+              if (l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
+                // when activating the task at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.agc_dl_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"AGC_DL SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+          case WAIT_DYN_DWNLD:
+          {
+            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.agc_dl_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"AGC_DL SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_AGC_DL_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_AGC_DL_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.agc_dl_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_AGC_DL_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.agc_dl_task.parameters.agc_dl_control         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control;
+              l1a_l1s_com.agc_dl_task.parameters.control                = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control;
+              l1a_l1s_com.agc_dl_task.parameters.frame_size             = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size;
+              l1a_l1s_com.agc_dl_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level;
+              l1a_l1s_com.agc_dl_task.parameters.signal_up              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up;
+              l1a_l1s_com.agc_dl_task.parameters.signal_down            = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down;
+              l1a_l1s_com.agc_dl_task.parameters.max_scale              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
+              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
+              l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag;
+
+              // Enable the L1S task
+              l1a_l1s_com.agc_dl_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_AGC_DL_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#endif // L1_DYN_DSP_DWNLD
+
+#endif // L1_AGC_DL
+
+
+  #if (L1_IIR == 2)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_iir_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* IIR feature.                                          */
+    /*                                                       */
+    /* Starting messages:        MMI_AQI_IIR_DL_REQ             */
+    /*                                                       */
+    /* Result messages (input):  L1_AQI_IIR_DL_CON              */
+    /*                                                       */
+    /* Result messages (output): MMI_AQI_IIR_DL_CON             */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_iir_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_IIR_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.iir_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_IIR_DL_REQ)
+            {
+	          l1a.iir_req_msg_ptr = msg;
+              l1a.l1_msg_forwarded = TRUE;
+
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.iir_task.parameters = (T_MMI_AQI_IIR_DL_REQ *) (msg->SigP);
+
+              // Enable the L1S task
+              l1a_l1s_com.iir_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_IIR_DL_CON)
+            {
+              os_free_sig(l1a.iir_req_msg_ptr);
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_IIR_DL_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550         break;
+        } // switch
+      } // while(1)
+    }
+  #endif // L1_IIR
+
+  #if (L1_WCM == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_wcm_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* WCM feature.                                          */
+    /*                                                       */
+    /* Starting messages:        MMI_AQI_WCM_REQ             */
+    /*                                                       */
+    /* Result messages (input):  L1_AQI_WCM_CON              */
+    /*                                                       */
+    /* Result messages (output): MMI_AQI_WCM_CON             */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+
+#if(L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_wcm_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_WCM_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.wcm_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_WCM_REQ)
+            {
+	          l1a.wcm_req_msg_ptr = msg;
+      	      l1a.l1_msg_forwarded = TRUE;
+
+              // Load the message into the l1a_l1s_com memory
+              l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP);
+
+              if (l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
+                // when activating the task at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.wcm_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"WCM SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.wcm_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"WCM SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_WCM_CON)
+            {
+              os_free_sig(l1a.wcm_req_msg_ptr);
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_wcm_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_WCM_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.wcm_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_WCM_REQ)
+            {
+	          l1a.wcm_req_msg_ptr = msg;
+      	      l1a.l1_msg_forwarded = TRUE;
+
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP);
+
+              // Enable the L1S task
+              l1a_l1s_com.wcm_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_WCM_CON)
+            {
+              os_free_sig(l1a.wcm_req_msg_ptr);
+              // Send the start confirmation message
+              l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#endif // L1_DYN_DSP_DWNLD
+
+#endif // L1_WCM
+
+#if (L1_DRC == 1) // DRC 1.x
+// DRC NDB API
+T_DRC_MCU_DSP *drc_ndb;
+#if (CODE_VERSION == SIMULATION)
+  T_DRC_MCU_DSP drc_ndb_sim;
+#endif
+
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_drc_process()                                 */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* DRC 1.x feature.                                     */
+    /*                                                       */
+    /* Starting messages:        MMI_AQI_DRC_REQ             */
+    /*                                                       */
+    /* Result messages (input):  L1_AQI_DRC_CON              */
+    /*                                                       */
+    /* Result messages (output): MMI_AQI_DRC_CON             */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if(L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_drc_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD    = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_DRC_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.drc_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_DRC_REQ)
+            {
+	          l1a.drc_req_msg_ptr = msg;
+       	      l1a.l1_msg_forwarded = TRUE;
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP);
+
+              if (l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
+                // when activating the task at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.drc_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"DRC SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_DYN_DWNLD:
+          {
+            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.drc_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"DRC SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_DRC_CON)
+            {
+              os_free_sig(l1a.drc_req_msg_ptr);
+              // Send the confirmation message
+              l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+        } // switch
+      } // while(1)
+    }
+#else
+    void l1a_mmi_drc_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_DRC_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.drc_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_AQI_DRC_REQ)
+            {
+	          l1a.drc_req_msg_ptr = msg;
+       	      l1a.l1_msg_forwarded = TRUE;
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP);
+
+              // Enable the L1S task
+              l1a_l1s_com.drc_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+            // End process
+            return;
+          }
+          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_AQI_DRC_CON)
+            {
+              os_free_sig(l1a.drc_req_msg_ptr);
+
+              // Send the confirmation message
+              l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+#endif // L1_DYN_DSP_DWNLD
+#endif // L1_DRC
+
+  #if (L1_LIMITER == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_limiter_process()                             */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* LIMITER feature.                                      */
+    /*                                                       */
+    /* Starting messages:        MMI_LIMITER_REQ             */
+    /*                                                       */
+    /* Result messages (input):  L1_LIMITER_CON              */
+    /*                                                       */
+    /* Result messages (output): MMI_LIMITER_CON             */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+    void l1a_mmi_limiter_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_LIMITER_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the commands
+            l1a_l1s_com.limiter_task.command.update         = FALSE;
+            l1a_l1s_com.limiter_task.command.partial_update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_LIMITER_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory.
+              l1a_l1s_com.limiter_task.parameters.limiter_enable      = ((T_MMI_LIMITER_REQ *)(msg->SigP))->limiter_enable;
+              l1a_l1s_com.limiter_task.parameters.block_size          = ((T_MMI_LIMITER_REQ *)(msg->SigP))->block_size;
+              l1a_l1s_com.limiter_task.parameters.slope_update_period = ((T_MMI_LIMITER_REQ *)(msg->SigP))->slope_update_period;
+              l1a_l1s_com.limiter_task.parameters.nb_fir_coefs        = ((T_MMI_LIMITER_REQ *)(msg->SigP))->nb_fir_coefs;
+              l1a_l1s_com.limiter_task.parameters.filter_coefs        = ((T_MMI_LIMITER_REQ *)(msg->SigP))->filter_coefs;
+              l1a_l1s_com.limiter_task.parameters.thr_low_0           = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_0;
+              l1a_l1s_com.limiter_task.parameters.thr_low_slope       = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_slope;
+              l1a_l1s_com.limiter_task.parameters.thr_high_0          = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_0;
+              l1a_l1s_com.limiter_task.parameters.thr_high_slope      = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_slope;
+              l1a_l1s_com.limiter_task.parameters.gain_fall           = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_fall;
+              l1a_l1s_com.limiter_task.parameters.gain_rise           = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_rise;
+
+              // Enable the L1S task
+              l1a_l1s_com.limiter_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_LIMITER_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_LIMITER_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550         break;
+        } // switch
+      } // while(1)
+    }
+  #endif // L1_LIMITER
+
+  #if (L1_ES == 1)
+    /*-------------------------------------------------------*/
+    /* l1a_mmi_es_process()                                  */
+    /*-------------------------------------------------------*/
+    /*                                                       */
+    /* Description:                                          */
+    /* ------------                                          */
+    /* This function is a state machine which handles the    */
+    /* Echo Suppressor feature.                              */
+    /*                                                       */
+    /* Starting messages:        MMI_ES_REQ                  */
+    /*                                                       */
+    /* Result messages (input):  L1_ES_CON                   */
+    /*                                                       */
+    /* Result messages (output): MMI_ES_CON                  */
+    /*                                                       */
+    /* Reset messages (input):   none                        */
+    /*                                                       */
+    /* Stop message (input):     none                        */
+    /*                                                       */
+    /* Stop message (output):    none                        */
+    /*                                                       */
+    /*-------------------------------------------------------*/
+#if (L1_DYN_DSP_DWNLD == 1)
+    void l1a_mmi_es_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_DYN_DWNLD = 2,
+        WAIT_CON          = 3
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_ES_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.es_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_ES_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory
+              l1a_l1s_com.es_task.parameters.es_enable     = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable;
+              l1a_l1s_com.es_task.parameters.es_behavior   = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior;
+
+              if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM)
+              {
+                // Load every parameters from the message
+                l1a_l1s_com.es_task.parameters.es_config.es_mode               = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode;
+                l1a_l1s_com.es_task.parameters.es_config.es_gain_dl            = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl;
+                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1;
+                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr            = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr;
+                l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr            = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr;
+                l1a_l1s_com.es_task.parameters.es_config.switching_time        = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time;
+                l1a_l1s_com.es_task.parameters.es_config.switching_time_dt     = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt;
+                l1a_l1s_com.es_task.parameters.es_config.hang_time             = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time;
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3];
+              }
+              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+              {
+                // WARNING: The following code must be copied in the state WAIT_DYN_DWNLD
+                // when ES task is activated at L1s level
+
+                // Enable the L1S task
+                l1a_l1s_com.es_task.command.update = TRUE;
+
+                *state = WAIT_CON;
+              }
+              else
+              {
+                *state = WAIT_DYN_DWNLD;
+
+                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"ES SM blocked by DYN DWNLD\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+              }
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550           break;
+          case WAIT_DYN_DWNLD:
+          {
+            if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
+            {
+              // Enable the L1S task
+              l1a_l1s_com.es_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+
+              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
+                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
+                  {
+                    char str[30];
+                    sprintf(str,"ES SM un-blocked\r\n");
+                    #if(CODE_VERSION == SIMULATION)
+                      trace_fct_simu_dyn_dwnld(str);
+                    #else
+                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
+                    #endif
+                  }
+               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
+            }
+            return;
+          }
+ // omaps00090550          break;
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_ES_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_ES_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+ // omaps00090550          break;
+        } // switch
+      } // while(1)
+    }
+
+#else
+    void l1a_mmi_es_process(xSignalHeaderRec *msg)
+    {
+      enum states
+      {
+        RESET             = 0,
+        WAIT_REQ          = 1,
+        WAIT_CON          = 2
+      };
+
+      UWORD8    *state      = &l1a.state[L1A_ES_STATE];
+      UWORD32   SignalCode  = msg->SignalCode;
+
+      while(1)
+      {
+        switch(*state)
+        {
+          case RESET:
+          {
+            // Reset the command
+            l1a_l1s_com.es_task.command.update = FALSE;
+
+            *state = WAIT_REQ;
+          }
+          break;
+
+          case WAIT_REQ:
+          {
+            if (SignalCode == MMI_ES_REQ)
+            {
+              // Load the message into the l1a_l1s_com memory
+              l1a_l1s_com.es_task.parameters.es_enable     = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable;
+              l1a_l1s_com.es_task.parameters.es_behavior   = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior;
+
+              if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM)
+              {
+                // Load every parameters from the message
+                l1a_l1s_com.es_task.parameters.es_config.es_mode               = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode;
+                l1a_l1s_com.es_task.parameters.es_config.es_gain_dl            = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl;
+                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1;
+                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr;
+                l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr            = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr;
+                l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr            = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr;
+                l1a_l1s_com.es_task.parameters.es_config.switching_time        = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time;
+                l1a_l1s_com.es_task.parameters.es_config.switching_time_dt     = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt;
+                l1a_l1s_com.es_task.parameters.es_config.hang_time             = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time;
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2];
+                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3];
+              }
+
+              // Enable the L1S task
+              l1a_l1s_com.es_task.command.update = TRUE;
+
+              *state = WAIT_CON;
+            }
+
+            // End process
+            return;
+          }
+          break;
+
+          case WAIT_CON:
+          {
+            if (SignalCode == L1_ES_CON)
+            {
+              // Send the start confirmation message
+              l1a_audio_send_confirmation(MMI_ES_CON);
+
+              *state = RESET;
+            }
+
+            // End process
+            return;
+          }
+          break;
+        } // switch
+      } // while(1)
+    }
+  #endif //L1_DYN_DSP_DWNLD
+  #endif // L1_ES
+
+// New Vocoder IF process
+
+#if (L1_VOCODER_IF_CHANGE == 1)
+  void l1a_mmi_vocoder_cfg_process    (xSignalHeaderRec *msg)
+  {
+
+    BOOL msg_parameter;
+
+    enum states
+    {
+      WAIT_REQ = 0,
+      WAIT_ENABLE_CON = 1,
+      WAIT_DISABLE_CON = 2
+    };
+
+    enum vocoder_cfg_req
+    {
+      VOCODER_DISABLE_REQ  = 0,
+      VOCODER_ENABLE_REQ  = 1
+    };
+
+    UWORD8    *state      = &l1a.state[L1A_VOCODER_CFG_STATE];
+    UWORD32   SignalCode  = msg->SignalCode;
+
+    while (1)
+    {
+      switch(*state)
+      {
+        case WAIT_REQ:
+        {
+
+          // Waiting PS messages....
+
+          // If SignalCode is an MPHC_STOP_DEDICATED_REQ and vocoders are enabled, they must be stopped automatically
+
+#if(L1_CHECK_COMPATIBLE == 1)
+          if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE)) || (l1a.vch_auto_disable == TRUE))
+#else
+          if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE)))          
+#endif		 	
+          {
+             // Command vocoder disabling at L1A-L1s interface and set the automatic disable flag to TRUE
+             l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND;
+             l1a.vocoder_state.automatic_disable = TRUE;
+             *state = WAIT_DISABLE_CON;
+#if(L1_CHECK_COMPATIBLE == 1)			
+  	      l1a.vch_auto_disable = FALSE;
+#endif
+          }
+          else if (SignalCode == MMI_TCH_VOCODER_CFG_REQ)
+          {
+            // In case the vocoder START or STOP is commanded by PS
+
+          
+            msg_parameter = ((T_MMI_TCH_VOCODER_CFG_REQ *) (msg->SigP))->vocoder_state;
+            // If it is an explicit STOP....
+            if (msg_parameter == VOCODER_DISABLE_REQ)
+            {
+#if (AUDIO_DEBUG == 1)
+              trace_info.audio_debug_var.vocoder_enable_status = 0;
+#endif
+
+              //... explicitely disable vocoders if they're enabled commanidng the stop at L1A-L1s interface
+              if (l1a.vocoder_state.enabled == TRUE)
+              {
+                 l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND;
+                 l1a.vocoder_state.automatic_disable = FALSE;
+                 *state = WAIT_DISABLE_CON;
+              }
+              else
+              {
+                // ...else, if vocoders are already disabled but PS is sending erroneously the request
+                // send him however the confirmation without doing anything (protection check).
+                // In case L1 standalone or SIMULATION, confirmation message must be
+                // sent to MMI mailbox, else with complete PS software the message must be
+                // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).
+
+                l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
+              }
+            }
+            else if (msg_parameter == VOCODER_ENABLE_REQ)
+            {
+#if (AUDIO_DEBUG == 1)
+              trace_info.audio_debug_var.vocoder_enable_status = 1;
+#endif
+              // If it is a START
+              if (l1a.vocoder_state.enabled == FALSE)
+              {
+                // Command the start at L1A-L1s interface if vocoders are disabled
+                l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_ENABLE_COMMAND;
+                *state = WAIT_ENABLE_CON;
+              }
+              else
+              {
+                // ...else, if vocoders are already enabled but PS is sending erroneously the request
+                // send him however the confirmation without doing anything (protection check).
+                // In case L1 standalone or SIMULATION, confirmation message must be
+                // sent to MMI mailbox, else with complete PS software the message must be
+                // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).
+
+                l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
+              }
+            }
+          }
+        return;
+        }
+ // omaps00090550        break;
+        case WAIT_ENABLE_CON:
+        {
+          if (SignalCode == L1_VOCODER_CFG_ENABLE_CON)
+          {
+            // when L1s confirms the enabling, forward the confirmation to PS and set the vocoders enabled flag to TRUE
+            l1a.vocoder_state.enabled = TRUE;
+
+            // in case L1 standalone or SIMULATION, confirmation message must be
+            // sent to MMI mailbox, else with complete PS software the message must be
+            // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).
+
+            l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
+            *state = WAIT_REQ;
+          }
+          return;
+        }
+ // omaps00090550        break;
+        case WAIT_DISABLE_CON:
+        {
+          if (SignalCode == L1_VOCODER_CFG_DISABLE_CON)
+          {
+            // when L1s confirms the disabling, forwards the confirmation to PS and set the vocoders enabled flag to FALSE
+            l1a.vocoder_state.enabled = FALSE;
+            *state = WAIT_REQ;
+
+            if (l1a.vocoder_state.automatic_disable == FALSE)
+            {
+              // Only in case it is an explicit request to STOP the vocoders (made previously by PS)
+              // send him the confirmation.
+              // In case L1 standalone or SIMULATION, confirmation message must be
+              // sent to MMI mailbox, else with complete PS software the message must be
+              // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).
+
+              l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
+            }
+            else
+            	// Reset automatic disable flag
+            	l1a.vocoder_state.automatic_disable = FALSE;
+          }
+        return;
+        }
+      // omaps00090550 break;
+      }
+    }
+
+  }
+#endif // L1_VOCODER_IF_CHANGE == 1
+  void l1a_mmi_outen_cfg_process    (xSignalHeaderRec *msg)
+  {
+#if (OP_RIV_AUDIO == 1)
+
+    UWORD32 SignalCode = msg->SignalCode;
+    void              *p_message;
+    T_RVF_MB_STATUS   mb_status;
+
+    if (SignalCode == MMI_OUTEN_CFG_REQ)
+    {
+      l1a_l1s_com.outen_cfg_task.outen1 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen1;
+      l1a_l1s_com.outen_cfg_task.outen2 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen2;
+      l1a_l1s_com.outen_cfg_task.outen3 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen3;
+      l1a_l1s_com.outen_cfg_task.classD  = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->classD;
+
+      l1a_l1s_com.outen_cfg_task.command_requested++;
+      // Send the confirmation message
+      l1a_audio_send_confirmation(MMI_OUTEN_CFG_CON);
+     }
+     else if(SignalCode == MMI_OUTEN_CFG_READ_REQ)
+     {
+        // Allocate the Riviera buffer
+        mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
+                                  sizeof (T_MMI_OUTEN_CFG_READ_CON),
+                                  (T_RVF_BUFFER **) (&p_message));
+
+        // If insufficient resources, then report a memory error and abort.
+        if (mb_status == RVF_RED)
+        {
+          // the memory is insufficient to continue the non regression test
+          AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
+          return;
+        }
+
+        // Fill the message ID
+        ((T_MMI_OUTEN_CFG_READ_CON *)(p_message))->header.msg_id = MMI_OUTEN_CFG_READ_CON;
+
+        // Fill the message parameter
+        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen1 = l1a_l1s_com.outen_cfg_task.outen1;
+        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen2 = l1a_l1s_com.outen_cfg_task.outen2;
+        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen3 = l1a_l1s_com.outen_cfg_task.outen3;
+        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->classD  = l1a_l1s_com.outen_cfg_task.classD;
+
+          // send the messsage to the audio entity
+          rvf_send_msg (p_audio_gbl_var->addrId,p_message);
+     }
+#endif /*OP_RIV_AUDIO*/
+  } /* end function l1a_mmi_outen_cfg_process */
+
+#if(L1_BT_AUDIO ==1)
+void l1a_mmi_bt_process(xSignalHeaderRec *msg)
+{             
+     UWORD32 SignalCode = msg->SignalCode;
+	 
+     if (SignalCode == MMI_BT_ENABLE_REQ)
+           bt_audio.connected_status   = TRUE;
+     else if(SignalCode == MMI_BT_DISABLE_REQ)
+	    bt_audio.connected_status  = FALSE;
+
+}
+#endif
+#endif // AUDIO_TASK
+