view src/cs/layer1/audio_cfile/l1audio_async.c @ 234:b870b6a44d31

l1audio and l1tm reconstructed source imported from tcs211-l1-reconst
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 20 Mar 2017 00:51:20 +0000
parents
children
line wrap: on
line source

/************* Revision Controle System Header *************
 *                  GSM Layer 1 software
 * L1AUDIO_ASYNC.C
 *
 *        Filename l1audio_async.c
 *  Copyright 2003 (C) Texas Instruments
 *
 ************* Revision Controle System Header *************/

/************************************/
/* Include files...                 */
/************************************/

#include "l1_macro.h"
#include "l1_confg.h"

#if (AUDIO_TASK == 1)

  #include "l1_types.h"
  #include "sys_types.h"

  #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION)

    #include <stdlib.h>
    #include <string.h>

    #include "iq.h"             // Debug / Init hardware  ("eva3.lib")
    #include "l1_ver.h"
    #include "l1_const.h"
    #include "l1_signa.h"
    #include "cust_os.h"

    #if TESTMODE
      #include "l1tm_defty.h"
    #endif

    #include "l1audio_const.h"
    #include "l1audio_cust.h"
    #include "l1audio_signa.h"
    #include "l1audio_defty.h"
    #include "l1audio_msgty.h"
    #include "l1audio_varex.h"
    #include "l1audio_proto.h"

    #if (L1_GTT == 1)
      #include "l1gtt_const.h"
      #include "l1gtt_defty.h"
    #endif

    #if (L1_MIDI == 1)
      #include "l1midi_defty.h"
    #endif


    #if (L1_MP3 == 1)
      #include "l1mp3_defty.h"
    #endif

    #if (L1_AAC == 1)
      #include "l1aac_defty.h"
    #endif
    #if (L1_DYN_DSP_DWNLD==1)
     #include "l1_dyn_dwl_defty.h"
     #include "l1_dyn_dwl_const.h"
     #include "l1_dyn_dwl_signa.h"
    #endif

    #include "l1_defty.h"
    #include "l1_msgty.h"
    #include "l1_varex.h"

    #include "l1_mftab.h"
    #include "l1_tabs.h"
    #include "l1_ctl.h"


    #include "l1_time.h"
    #include "l1_scen.h"

  #else

    // Layer1 and debug include files.
    #include <ctype.h>
    #include <math.h>
    #include "l1_ver.h"
    #include "l1_const.h"
    #include "l1_signa.h"
    #include "cust_os.h"

    #if TESTMODE
      #include "l1tm_defty.h"
    #endif

    #include "l1audio_const.h"
    #include "l1audio_cust.h"
    #include "l1audio_signa.h"
    #include "l1audio_defty.h"
    #include "l1audio_msgty.h"
    #include "l1audio_varex.h"
    #include "l1audio_proto.h"

    #if (L1_GTT == 1)
      #include "l1gtt_const.h"
      #include "l1gtt_defty.h"
    #endif

    #if (L1_MP3 == 1)
      #include "l1mp3_defty.h"
    #endif

    #if (L1_MIDI == 1)
      #include "l1midi_defty.h"
    #endif

    #if (L1_AAC == 1)
      #include "l1aac_defty.h"
    #endif

    #if (L1_DYN_DSP_DWNLD==1)
     #include "l1_dyn_dwl_defty.h"
     #include "l1_dyn_dwl_const.h"
     #include "l1_dyn_dwl_signa.h"
    #endif

#if (RF_FAM == 61)
#include "l1_rf61.h"
#endif 

    #include "l1_defty.h"
    #include "l1_msgty.h"
    #include "tpudrv.h"       // TPU drivers.           ("eva3.lib")
    #include "l1_varex.h"

    #include "l1_proto.h"
    #include "l1_mftab.h"
    #include "l1_tabs.h"
    #include "mem.h"
    #include "armio.h"
    #include "timer.h"
    #include "timer1.h"
    #include "dma.h"
    #include "inth.h"
    #include "ulpd.h"
    #include "rhea_arm.h"
    #include "clkm.h"         // Clockm  ("eva3.lib")
    #include "l1_ctl.h"

    #include "l1_time.h"

    #if L2_L3_SIMUL
      #include "l1_scen.h"
    #endif

    #if (OP_RIV_AUDIO == 1)
      #include "rv_general.h"
      #include "audio_api.h"
      #include "audio_structs_i.h"
      #include "audio_var_i.h"
      #include "audio_macro_i.h"
      #include "audio_const_i.h"
    #endif
  #endif

  #include "l1audio_macro.h"

  #if(L1_DYN_DSP_DWNLD == 1)
    #if (TRACE_TYPE == 1) ||(TRACE_TYPE == 4) || (TRACE_TYPE == 5) || (TRACE_TYPE == 7) || (TESTMODE)
      #include "l1_trace.h"
    #endif
    #if(CODE_VERSION == SIMULATION)
      extern void trace_fct_simu_dyn_dwnld(CHAR *fct_name);
    #endif
  #endif

#if 0
  #if (L1_MP3)
     extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR
  #endif
//#pragma DUPLICATE_FOR_INTERNAL_RAM_END

#endif
#if ( L1_AAC)
extern UWORD16  a_aac_dma_input_buffer[2][C_AAC_OUTPUT_BUFFER_SIZE];
extern UWORD8   d_aac_dma_current_buffer_id;

#endif

#if (L1_MP3)
extern T_MP3_MCU_DSP *mp3_ndb;//Mp3-FR
#endif
  /**************************************/
  /* Prototypes for L1 ASYNCH task      */
  /**************************************/
  #if (OP_RIV_AUDIO == 1)
    #if (L1_AUDIO_DRIVER == 1)
      void l1a_audio_driver_process     (xSignalHeaderRec *msg);
    #endif
  #endif
  #if (KEYBEEP)
    void l1a_mmi_keybeep_process        (xSignalHeaderRec *msg);
  #endif
  #if (TONE)
    void l1a_mmi_tone_process           (xSignalHeaderRec *msg);
  #endif
  #if (L1_CPORT == 1)
    void l1a_mmi_cport_process          (xSignalHeaderRec *msg);
  #endif
  #if (MELODY_E1)
    void l1a_mmi_melody0_process        (xSignalHeaderRec *msg);
    void l1a_mmi_melody1_process        (xSignalHeaderRec *msg);
  #endif
  #if (VOICE_MEMO)
    void l1a_mmi_vm_playing_proccess    (xSignalHeaderRec *msg);
    void l1a_mmi_vm_recording_process   (xSignalHeaderRec *msg);
  #endif
  #if (L1_PCM_EXTRACTION)
    void l1a_mmi_pcm_download_process   (xSignalHeaderRec *msg);
    void l1a_mmi_pcm_upload_process     (xSignalHeaderRec *msg);
  #endif
  #if (L1_VOICE_MEMO_AMR)
    void l1a_mmi_vm_amr_playing_proccess (xSignalHeaderRec *msg);
    void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg);
  #endif
  #if (SPEECH_RECO)
    void l1a_mmi_sr_enroll_process      (xSignalHeaderRec *msg);
    void l1a_mmi_sr_update_process      (xSignalHeaderRec *msg);
    void l1a_mmi_sr_reco_process        (xSignalHeaderRec *msg);
    void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg);
  #endif
  #if (AEC == 1)
    void l1a_mmi_aec_process            (xSignalHeaderRec *msg);
  #endif
  #if (AEC == 2)
    void l1a_mmi_aec_process            (xSignalHeaderRec *msg);
  #endif
  #if (FIR)
    void l1a_mmi_fir_process            (xSignalHeaderRec *msg);
  #endif
  #if (AUDIO_MODE)
    void l1a_mmi_audio_mode_process     (xSignalHeaderRec *msg);
  #endif
  #if (MELODY_E2)
    void l1a_mmi_melody0_e2_process     (xSignalHeaderRec *msg);
    void l1a_mmi_melody1_e2_process     (xSignalHeaderRec *msg);
  #endif
  #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1)
    void l1a_mmi_audio_onoff_process     (xSignalHeaderRec *msg);
  #endif
  #if (L1_EXT_AUDIO_MGT == 1)
    void l1a_mmi_ext_audio_mgt_process   (xSignalHeaderRec *msg);
  #endif
  #if (L1_ANR == 1 || L1_ANR == 2)
    void l1a_mmi_anr_process             (xSignalHeaderRec *msg);
  #endif
  #if (L1_AGC_UL == 1)
    void l1a_mmi_agc_ul_process           (xSignalHeaderRec *msg);
  #endif
  #if (L1_AGC_DL == 1)
    void l1a_mmi_agc_dl_process           (xSignalHeaderRec *msg);
  #endif
  #if (L1_IIR == 1 || L1_IIR == 2)
    void l1a_mmi_iir_process             (xSignalHeaderRec *msg);
  #endif
  #if (L1_WCM == 1)
    void l1a_mmi_wcm_process           (xSignalHeaderRec *msg);
  #endif
#if (L1_DRC == 1)
    void l1a_mmi_drc_process             (xSignalHeaderRec *msg);
  #endif
  #if (L1_LIMITER == 1)
    void l1a_mmi_limiter_process         (xSignalHeaderRec *msg);
  #endif
  #if (L1_ES == 1)
    void l1a_mmi_es_process              (xSignalHeaderRec *msg);
  #endif
  #if (L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_vocoder_cfg_process(xSignalHeaderRec *msg);
  #endif
#if(L1_BT_AUDIO==1)
   void l1a_mmi_bt_process(xSignalHeaderRec *msg);
#endif
  /**************************************/
  /* External prototypes                */
  /**************************************/
  extern UWORD8  copy_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_dst);
  extern UWORD8  copy_data_to_buffer   (UWORD8 session_id, UWORD16 *buffer_size, UWORD16 **ptr_buf, UWORD16 data_size, API *ptr_src);
  extern UWORD8  Cust_get_pointer      (UWORD16 **ptr, UWORD16 *buffer_size, UWORD8 session_id);
  #if (MELODY_E2)
    extern UWORD8  copy_byte_data_from_buffer (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_dst);
    extern UWORD8  copy_byte_data_to_buffer   (UWORD8 session_id, UWORD16 *buffer_size, UWORD8 **ptr_buf, UWORD16 data_size, UWORD8 *ptr_src);
  #endif
  #if (L1_EXT_AUDIO_MGT == 1)
   T_MIDI_DMA_PARAM midi_buf;
  #if (CODE_VERSION == NOT_SIMULATION)
#pragma DATA_SECTION(midi_buf,".l1s_global")
#endif
    extern void l1_ext_audio_mgt_dma_handler(SYS_UWORD16 dma_status);
  #endif
  #if(L1_BT_AUDIO ==1)
   BOOL midi_task_running;
   extern T_L1_BT_AUDIO bt_audio;
   extern void l1_audio_bt_init(UINT16 media_buf_size);
  #endif

  #if (OP_RIV_AUDIO == 1)
    #if (L1_AUDIO_DRIVER == 1)
      void l1a_audio_driver_process(xSignalHeaderRec *msg)
      {
        UWORD32 SignalCode = msg->SignalCode;

        if (SignalCode == L1_AUDIO_DRIVER_IND)
          l1a_audio_send_result(AUDIO_DRIVER_NOTIFICATION_MSG, msg, MMI_QUEUE);
      }
    #endif
  #endif

  #if (KEYBEEP)
    /*-------------------------------------------------------*/
    /* l1a_mmi_keybeep_process()                             */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* keybeep feature.                                      */
    /*                                                       */
    /* Starting messages:        MMI_KEYBEEP_START_REQ       */
    /*                                                       */
    /* Result messages (input):  L1_KEYBEEP_START_CON        */
    /*                                                       */
    /* Result messages (output): MMI_KEYBEEP_START_CON       */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_KEYBEEP_STOP_REQ        */
    /*                           L1_KEYBEEP_STOP_CON         */
    /*                                                       */
    /* Stop message (output):    MMI_KEYBEEP_STOP_CON        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_keybeep_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_KEYBEEP_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.keybeep_task.command.start = FALSE;
            l1a_l1s_com.keybeep_task.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_KEYBEEP_START_REQ)
            {
              // Download the keybeep description in the NDB.
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt0= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt0;
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_kt1= ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt1;
              l1s_dsp_com.dsp_ndb_ptr->d_dur_kb  = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_dur_kb;

              // Start the L1S keybeep task
              l1a_l1s_com.keybeep_task.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
 // OMPAS00090550           break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_KEYBEEP_START_CON)
            {
              // Disable the start command
              l1a_l1s_com.keybeep_task.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_KEYBEEP_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // ompas00090550           break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_KEYBEEP_STOP_REQ)
            {
              // Stop the L1S keybeep task
              l1a_l1s_com.keybeep_task.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_KEYBEEP_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_KEYBEEP_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
     // omaps00090550       break;
        } // switch
      } // while(1)
    }
  #endif // KEYBEEP

  #if (TONE)
    /*-------------------------------------------------------*/
    /* l1a_mmi_tone_process()                                */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* tone feature.                                         */
    /*                                                       */
    /* Starting messages:        MMI_TONE_START_REQ          */
    /*                                                       */
    /* Result messages (input):  L1_TONE_START_CON           */
    /*                                                       */
    /* Result messages (output): MMI_TONE_START_CON          */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_TONE_STOP_REQ           */
    /*                           L1_TONE_STOP_CON            */
    /*                                                       */
    /* Stop message (output):    MMI_TONE_STOP_CON           */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_tone_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_TONE_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.tone_task.command.start = FALSE;
            l1a_l1s_com.tone_task.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_TONE_START_REQ)
            {
              // Download the tone description in the NDB.
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t0;
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t1;
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t2;
              l1s_dsp_com.dsp_ndb_ptr->d_pe_rep  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_rep;
              l1s_dsp_com.dsp_ndb_ptr->d_pe_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_off;
              l1s_dsp_com.dsp_ndb_ptr->d_se_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_se_off;
              l1s_dsp_com.dsp_ndb_ptr->d_bu_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_bu_off;
              l1s_dsp_com.dsp_ndb_ptr->d_t0_on   = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_on;
              l1s_dsp_com.dsp_ndb_ptr->d_t0_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_off;
              l1s_dsp_com.dsp_ndb_ptr->d_t1_on   = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_on;
              l1s_dsp_com.dsp_ndb_ptr->d_t1_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_off;
              l1s_dsp_com.dsp_ndb_ptr->d_t2_on   = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_on;
              l1s_dsp_com.dsp_ndb_ptr->d_t2_off  = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_off;


              // Start the L1S tone task
              l1a_l1s_com.tone_task.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
   //omaps00090550          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_TONE_START_CON)
            {
              // Disable the start command
              l1a_l1s_com.tone_task.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_TONE_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550           break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_TONE_STOP_REQ)
            {
              // Stop the L1S tone task
              l1a_l1s_com.tone_task.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_TONE_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_TONE_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // TONE





  #if (MELODY_E1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_melody0_process()                             */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* melody 0 feature.                                     */
    /*                                                       */
    /* Starting messages:        MMI_MELODY0_START_REQ       */
    /*                                                       */
    /* Result messages (input):  L1_MELODY0_START_CON        */
    /*                                                       */
    /* Result messages (output): MMI_MELODY0_START_CON       */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_MELDOY0_STOP_REQ        */
    /*                           L1_MELODY0_STOP_CON         */
    /*                                                       */
    /* Stop message (output):    MMI_MELODY0_STOP_CON        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_melody0_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        M0_RESET            = 0,
        M0_WAIT_START_REQ   = 1,
        M0_WAIT_START_CON   = 2,
        M0_WAIT_STOP        = 3
      };

      UWORD8    *state      = &l1a.state[L1A_MELODY0_STATE];
      UWORD32   SignalCode  = msg->SignalCode;
      UWORD8    melody_osc, used_osc;

      while(1)
      {
        switch(*state)
        {
          case M0_RESET:
          {
            // Reset the commands:
            l1a_l1s_com.melody0_task.command.start = FALSE;
            l1a_l1s_com.melody0_task.command.stop  = FALSE;

            // Initialize the translation table
            for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++)
              l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR;

            *state = M0_WAIT_START_REQ;
          }
          break;

          case M0_WAIT_START_REQ:
          {
            if (SignalCode == MMI_MELODY0_START_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.melody0_task.parameters.session_id                = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.melody0_task.parameters.loopback                  = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback;
              l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap    = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap;

              // Initialize the buffer parameters
              l1a_l1s_com.melody0_task.parameters.ptr_buf        = NULL;
              l1a_l1s_com.melody0_task.parameters.buffer_size    = 0;
              l1a_l1s_com.melody0_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf,
                                                                              &l1a_l1s_com.melody0_task.parameters.buffer_size,
                                                                              l1a_l1s_com.melody0_task.parameters.session_id);

              // Read the Header of the melody description to have the melody bitmap
              l1a_l1s_com.melody0_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody0_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_task.parameters.buffer_size,
                                                                                   (UWORD16 **)&l1a_l1s_com.melody0_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap);

              l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT);

              // Build the array of translation between the melody mapping and the oscillators used
              used_osc = 0;
              melody_osc = 0;
              while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
              {
                // find the next oscillator available in the melody
                while( ((l1a_l1s_com.melody0_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
                  melody_osc++;

                // find the next oscillator available in the oscillator used
                while( ((l1a_l1s_com.melody0_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
                  used_osc++;

                // Fill the translation table
                if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
                  l1a_l1s_com.melody0_task.parameters.melody_to_oscillator[melody_osc] = used_osc;
                melody_osc++;
                used_osc++;
              }

              // Start the melody 0 L1S task:
              l1a_l1s_com.melody0_task.command.start = TRUE;

              *state = M0_WAIT_START_CON;
            }

            // End process
            return;
          }
 // omaps00090550          break;

          case M0_WAIT_START_CON:
          {
            if (SignalCode == L1_MELODY0_START_CON)
            {
              // Disable the start command
              l1a_l1s_com.melody0_task.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_MELODY0_START_CON);

              *state = M0_WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550           break;

          case M0_WAIT_STOP:
          {
            if (SignalCode == L1_MELODY0_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_MELODY0_STOP_CON);

              *state = M0_RESET;
            }
            else
            if (SignalCode == MMI_MELODY0_STOP_REQ)
            {
              // Stop the melody 0 L1S task:
              l1a_l1s_com.melody0_task.command.stop = TRUE;

              // End process
              return;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_melody1_process()                             */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* melody 1 feature.                                     */
    /*                                                       */
    /* Starting messages:        MMI_MELODY1_START_REQ       */
    /*                                                       */
    /* Result messages (input):  L1_MELODY1_START_CON        */
    /*                                                       */
    /* Result messages (output): MMI_MELODY1_START_CON       */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_MELDOY1_STOP_REQ        */
    /*                           L1_MELODY1_STOP_CON         */
    /*                                                       */
    /* Stop message (output):    MMI_MELODY1_STOP_CON        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_melody1_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        M1_RESET            = 0,
        M1_WAIT_START_REQ   = 1,
        M1_WAIT_START_CON   = 2,
        M1_WAIT_STOP        = 3
      };

      UWORD8    *state      = &l1a.state[L1A_MELODY1_STATE];
      UWORD32   SignalCode  = msg->SignalCode;
      UWORD8    melody_osc, used_osc;

      while(1)
      {
        switch(*state)
        {
          case M1_RESET:
          {
            // Reset the commands:
            l1a_l1s_com.melody1_task.command.start = FALSE;
            l1a_l1s_com.melody1_task.command.stop  = FALSE;

            // Initialize the translation table
            for (melody_osc=0; melody_osc<SC_NUMBER_OSCILLATOR; melody_osc++)
              l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = SC_NUMBER_OSCILLATOR;


            *state = M1_WAIT_START_REQ;
          }
          break;

          case M1_WAIT_START_REQ:
          {
            if (SignalCode == MMI_MELODY1_START_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.melody1_task.parameters.session_id                = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.melody1_task.parameters.loopback                  = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback;
              l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap    = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap;

              // Initialize the buffer parameters
              l1a_l1s_com.melody1_task.parameters.ptr_buf        = NULL;
              l1a_l1s_com.melody1_task.parameters.buffer_size    = 0;
              l1a_l1s_com.melody1_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf,
                                                                              &l1a_l1s_com.melody1_task.parameters.buffer_size,
                                                                              l1a_l1s_com.melody1_task.parameters.session_id);

              // Read the Header of the melody description to have the melody bitmap
              l1a_l1s_com.melody1_task.parameters.error_id = copy_data_from_buffer (l1a_l1s_com.melody1_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_task.parameters.buffer_size,
                                                                                   (UWORD16 **)&l1a_l1s_com.melody1_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap);

              l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap = Field(l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap, SC_MELO_OSCILLATOR_USED_MASK, SC_MELO_OSCILLATOR_USED_SHIFT);
              // Build the array of translation between the melody maaping and the oscillators used
              used_osc = 0;
              melody_osc = 0;
              while ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
              {
                // find the next oscillator available in the melody
                while( ((l1a_l1s_com.melody1_task.parameters.oscillator_melody_bitmap & (0x1<<melody_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
                  melody_osc++;

                // find the next oscillator available in the oscillator used
                while( ((l1a_l1s_com.melody1_task.parameters.oscillator_used_bitmap & (0x1<<used_osc)) == 0) && (melody_osc < SC_NUMBER_OSCILLATOR) )
                  used_osc++;

                // Fill the translation table
                if ( (melody_osc < SC_NUMBER_OSCILLATOR) && (used_osc < SC_NUMBER_OSCILLATOR) )
                  l1a_l1s_com.melody1_task.parameters.melody_to_oscillator[melody_osc] = used_osc;
                melody_osc++;
                used_osc++;
              }

              // Start the melody 1 L1S task:
              l1a_l1s_com.melody1_task.command.start = TRUE;

              *state = M1_WAIT_START_CON;
            }

            // End process
            return;
          }
 // omaps00090550           break;

          case M1_WAIT_START_CON:
          {
            if (SignalCode == L1_MELODY1_START_CON)
            {
              // Disable the start command
              l1a_l1s_com.melody1_task.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_MELODY1_START_CON);

              *state = M1_WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550           break;
          case M1_WAIT_STOP:
          {
            if (SignalCode == L1_MELODY1_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_MELODY1_STOP_CON);

              *state = M1_RESET;
            }
            else
            if (SignalCode == MMI_MELODY1_STOP_REQ)
            {
              // Stop the melody 0 L1S task:
              l1a_l1s_com.melody1_task.command.stop = TRUE;

              // End process
              return;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // MELODY_E1

#if (VOICE_MEMO)
    /*-------------------------------------------------------*/
    /* l1a_mmi_vm_playing_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* voice memorization playing feature.                   */
    /*                                                       */
    /* Starting messages:        MMI_VM_PLAY_START_REQ       */
    /*                                                       */
    /* Result messages (input):  L1_VM_PLAY_START_CON        */
    /*                                                       */
    /* Result messages (output): MMI_VM_PLAY_START_CON       */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_VM_PLAY_STOP_REQ        */
    /*                           L1_VM_PLAY_STOP_CON         */
    /*                                                       */
    /* Stop message (output):    MMI_VM_PLAY_STOP_CON        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_vm_playing_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_VM_PLAY_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.voicememo_task.play.command.start = FALSE;
            l1a_l1s_com.voicememo_task.play.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_VM_PLAY_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.voicememo_task.play.parameters.session_id =  ((T_MMI_VM_PLAY_REQ *)(msg->SigP))->session_id;

              // Start the L1S voice memo playing task
              l1a_l1s_com.voicememo_task.play.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
 // omaps00090550        break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_VM_PLAY_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.voicememo_task.play.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_VM_PLAY_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550         break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_VM_PLAY_STOP_REQ)
            {
              // Stop the L1S voice memo playing task
              l1a_l1s_com.voicememo_task.play.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_VM_PLAY_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_VM_PLAY_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_vm_recording_process()                        */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* voice memorization recording feature.                 */
    /*                                                       */
    /* Starting messages:        MMI_VM_RECORD_START_REQ     */
    /*                                                       */
    /* Result messages (input):  L1_VM_RECORD_START_CON      */
    /*                                                       */
    /* Result messages (output): MMI_VM_RECORD_START_CON     */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_VM_RECORD_STOP_REQ      */
    /*                           L1_VM_RECORD_STOP_CON       */
    /*                                                       */
    /* Stop message (output):    MMI_VM_RECORD_STOP_CON      */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_vm_recording_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_VM_RECORD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.voicememo_task.record.command.start = FALSE;
            l1a_l1s_com.voicememo_task.record.command.stop  = FALSE;
            l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_VM_RECORD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.voicememo_task.record.parameters.session_id   =  ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.voicememo_task.record.parameters.maximum_size =  ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->maximum_size;
              l1a_l1s_com.voicememo_task.record.parameters.dtx          =  ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->dtx_used;

              // Download UL/DL audio gain to the NDB
              l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_ul;
              l1s_dsp_com.dsp_ndb_ptr->d_shiftdl = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_dl;

              // Download the tone description in the NDB.
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t0 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t0;
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t1 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t1;
              l1s_dsp_com.dsp_ndb_ptr->d_k_x1_t2 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t2;
              l1s_dsp_com.dsp_ndb_ptr->d_pe_rep  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_rep;
              l1s_dsp_com.dsp_ndb_ptr->d_pe_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_off;
              l1s_dsp_com.dsp_ndb_ptr->d_se_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_se_off;
              l1s_dsp_com.dsp_ndb_ptr->d_bu_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_bu_off;
              l1s_dsp_com.dsp_ndb_ptr->d_t0_on   = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_on;
              l1s_dsp_com.dsp_ndb_ptr->d_t0_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_off;
              l1s_dsp_com.dsp_ndb_ptr->d_t1_on   = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_on;
              l1s_dsp_com.dsp_ndb_ptr->d_t1_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_off;
              l1s_dsp_com.dsp_ndb_ptr->d_t2_on   = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_on;
              l1s_dsp_com.dsp_ndb_ptr->d_t2_off  = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_off;

              // Start the L1S voice memo recording task
              l1a_l1s_com.voicememo_task.record.command.start = TRUE;

              // Start the L1S voice memo tone uplink task
              l1a_l1s_com.voicememo_task.record.tone_ul.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
 // omaps00090550      break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_VM_RECORD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.voicememo_task.record.tone_ul.start = FALSE;

              // Reset the start command
              l1a_l1s_com.voicememo_task.record.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_VM_RECORD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550         break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_VM_RECORD_STOP_REQ)
            {
              // Stop the L1S voice memo recording task
              l1a_l1s_com.voicememo_task.record.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_VM_RECORD_STOP_CON)
            {
              // Forward the stop confirmation message
              l1a_audio_send_result(MMI_VM_RECORD_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // VOICE_MEMO

  #if (L1_PCM_EXTRACTION)
  #if (L1_DYN_DSP_DWNLD == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_pcm_download_process()                        */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* PCM download feature.                                 */
    /*                                                       */
    /* Starting messages:        MMI_PCM_DOWNLOAD_START_REQ  */
    /*                                                       */
    /* Result messages (input):  L1_PCM_DOWNLOAD_START_CON   */
    /*                                                       */
    /* Result messages (output): MMI_PCM_DOWNLOAD_START_CON  */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_PCM_DOWNLOAD_STOP_REQ   */
    /*                           L1_PCM_DOWNLOAD_STOP_CON    */
    /*                                                       */
    /* Stop message (output):    MMI_PCM_DOWNLOAD_STOP_CON   */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_START_CON    = 3,
        WAIT_STOP         = 4
      };

      UWORD8    *state      = &l1a.state[L1A_PCM_DOWNLOAD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      BOOL end_process = 0;

      while(!end_process)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.pcm_task.download.command.start = FALSE;
            l1a_l1s_com.pcm_task.download.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.pcm_task.download.parameters.session_id =  ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size;

              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1);
              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |=
                                                        ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8);

            if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN)
            {
              // Start the L1S PCM download task
              l1a_l1s_com.pcm_task.download.command.start = TRUE;
              *state = WAIT_START_CON;
		    }
		    else
		    {
			  *state = WAIT_DYN_DWNLD;
                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[30];
                   sprintf(str,"PCM Extraction SM blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                 }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
		}

            // End process
            end_process = 1;
          }
          break;

          case WAIT_DYN_DWNLD:
          {
            if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN))
             {
                 // Start the L1S PCM download task
                l1a_l1s_com.pcm_task.download.command.start = TRUE;
                *state = WAIT_START_CON;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[32];
                   sprintf(str,"PCM Extraction SM un-blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                 }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
             }
            // End process
            end_process = 1;
		  }
		  break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_PCM_DOWNLOAD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.pcm_task.download.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_STOP:
          {

            UWORD32 maximum_size;

            if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ)
            {
              maximum_size =  ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size;
              if(maximum_size == 0)
              {
              // Stop the L1S PCM download task
              l1a_l1s_com.pcm_task.download.command.stop = TRUE;
              }
              else
              {
                l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size;

              }

              // End process
              return;
            }
            else
            if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(!end_process)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_pcm_upload_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* PCM upload feature.                                   */
    /*                                                       */
    /* Starting messages:        MMI_PCM_UPLOAD_START_REQ    */
    /*                                                       */
    /* Result messages (input):  L1_PCM_UPLOAD_START_CON     */
    /*                                                       */
    /* Result messages (output): MMI_PCM_UPLOAD_START_CON    */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_PCM_UPLOAD_STOP_REQ     */
    /*                           L1_PCM_UPLOAD_STOP_CON      */
    /*                                                       */
    /* Stop message (output):    MMI_PCM_UPLOAD_STOP_CON     */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_START_CON    = 3,
        WAIT_STOP         = 4
      };

      UWORD8    *state      = &l1a.state[L1A_PCM_UPLOAD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      BOOL end_process = 0;

      while(!end_process)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.pcm_task.upload.command.start = FALSE;
            l1a_l1s_com.pcm_task.upload.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_PCM_UPLOAD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.pcm_task.upload.parameters.session_id   =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.pcm_task.upload.parameters.maximum_size =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size;

              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1);
              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8);

            if (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE]==GREEN)
            {
              // Start the L1S PCM upload task
              l1a_l1s_com.pcm_task.upload.command.start = TRUE;
              *state = WAIT_START_CON;
		    }
		    else
		    {
			  *state = WAIT_DYN_DWNLD;
                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[30];
                   sprintf(str,"PCM Extraction SM blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                 }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }


          }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_DYN_DWNLD:
          {
            if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[PCM_EXTRACTION_STATE_MACHINE] == GREEN))
             {
                 // Start the L1S PCM upload task
                l1a_l1s_com.pcm_task.upload.command.start = TRUE;
                *state = WAIT_START_CON;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[32];
                   sprintf(str,"PCM Extraction SM un-blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                 }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
             }
            // End process
            end_process = 1;
		  }
		  break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_PCM_UPLOAD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.pcm_task.upload.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ)
            {
              // Stop the L1S PCM recording task
              l1a_l1s_com.pcm_task.upload.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_PCM_UPLOAD_STOP_CON)
            {
              // Forward the stop confirmation message
              l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(!end_process)
    }

#else /*L1_DYN_DSP_DWNLD == 0

// l1a_mmi_pcm_download_process()
// Description:
// This function is a state machine which handles the    */
//     PCM download feature.
    // Starting messages:        MMI_PCM_DOWNLOAD_START_REQ
//     Result messages (input):  L1_PCM_DOWNLOAD_START_CON
    // Result messages (output): MMI_PCM_DOWNLOAD_START_CON
//    Reset messages (input):   none
    // Stop message (input):     MMI_PCM_DOWNLOAD_STOP_REQ
    //L1_PCM_DOWNLOAD_STOP_CON
//    Stop message (output):    MMI_PCM_DOWNLOAD_STOP_CON   */
    //Rem:                                                  */

    void l1a_mmi_pcm_download_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_PCM_DOWNLOAD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      BOOL end_process = 0;

      while(!end_process)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.pcm_task.download.command.start = FALSE;
            l1a_l1s_com.pcm_task.download.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_PCM_DOWNLOAD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.pcm_task.download.parameters.session_id =  ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.pcm_task.download.parameters.maximum_size = ((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->maximum_size;

              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download = ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_ul_gain) << 1);
              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_download |=
                                                        ((((T_MMI_PCM_DOWNLOAD_START_REQ *)(msg->SigP))->download_dl_gain) << 8);
              // Start the L1S PCM download task
              l1a_l1s_com.pcm_task.download.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_PCM_DOWNLOAD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.pcm_task.download.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_STOP:
          {

            UWORD32 maximum_size;

            if (SignalCode == MMI_PCM_DOWNLOAD_STOP_REQ)
            {
              maximum_size =  ((T_MMI_PCM_DOWNLOAD_STOP_REQ *)(msg->SigP))->maximum_size;
              if(maximum_size == 0)
              {
              // Stop the L1S PCM download task
              l1a_l1s_com.pcm_task.download.command.stop = TRUE;
              }
              else
              {
                l1a_l1s_com.pcm_task.download.parameters.maximum_size = maximum_size;

              }

              // End process
              return;
            }
            else
            if (SignalCode == L1_PCM_DOWNLOAD_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_PCM_DOWNLOAD_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(!end_process)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_pcm_upload_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* PCM upload feature.                                   */
    /*                                                       */
    /* Starting messages:        MMI_PCM_UPLOAD_START_REQ    */
    /*                                                       */
    /* Result messages (input):  L1_PCM_UPLOAD_START_CON     */
    /*                                                       */
    /* Result messages (output): MMI_PCM_UPLOAD_START_CON    */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_PCM_UPLOAD_STOP_REQ     */
    /*                           L1_PCM_UPLOAD_STOP_CON      */
    /*                                                       */
    /* Stop message (output):    MMI_PCM_UPLOAD_STOP_CON     */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_pcm_upload_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_PCM_UPLOAD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      BOOL end_process = 0;

      while(!end_process)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.pcm_task.upload.command.start = FALSE;
            l1a_l1s_com.pcm_task.upload.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_PCM_UPLOAD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.pcm_task.upload.parameters.session_id   =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.pcm_task.upload.parameters.maximum_size =  ((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->maximum_size;

              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload = ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_ul_gain) << 1);
              l1s_dsp_com.dsp_ndb_ptr->d_pcm_api_upload |= ((((T_MMI_PCM_UPLOAD_START_REQ *)(msg->SigP))->upload_dl_gain) << 8);

              // Start the L1S voice memo recording task
              l1a_l1s_com.pcm_task.upload.command.start = TRUE;


              *state = WAIT_START_CON;
            }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_PCM_UPLOAD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.pcm_task.upload.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_PCM_UPLOAD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            end_process = 1;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_PCM_UPLOAD_STOP_REQ)
            {
              // Stop the L1S PCM recording task
              l1a_l1s_com.pcm_task.upload.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_PCM_UPLOAD_STOP_CON)
            {
              // Forward the stop confirmation message
              l1a_audio_send_result(MMI_PCM_UPLOAD_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(!end_process)
    }
  #endif /* L1_DYN_DSP_DWNLD */

  #endif /* L1_PCM_EXTRACTION */

  #if (L1_VOICE_MEMO_AMR)

  #if (L1_DYN_DSP_DWNLD==1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_vm_amr_playing_process()                      */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* voice memorization playing feature.                   */
    /*                                                       */
    /* Starting messages:        MMI_VM_AMR_PLAY_START_REQ   */
    /*                                                       */
    /* Result messages (input):  L1_VM_AMR_PLAY_START_CON    */
    /*                                                       */
    /* Result messages (output): MMI_VM_AMR_PLAY_START_CON   */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_VM_AMR_PLAY_STOP_REQ    */
    /*                           L1_VM_AMR_PLAY_STOP_CON     */
    /*                                                       */
    /* Stop message (output):    MMI_VM_AMR_PLAY_STOP_CON    */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
  void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_START_CON    = 3,
        WAIT_STOP         = 4
      #if 0	/* FreeCalypso TCS211 reconstruction */
        VM_AMR_PLAY       = 5,
        VM_AMR_PAUSE      = 6,
        VM_AMR_PAUSE_CON  = 7,
        WAIT_RESUME_CON   = 8
      #endif
      };

      UWORD8    *state      = &l1a.state[L1A_VM_AMR_PLAY_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;
            l1a_l1s_com.voicememo_amr_task.play.command.stop  = FALSE;
          #if 0	/* FreeCalypso TCS211 reconstruction */
            l1a_l1s_com.voicememo_amr_task.play.command.pause  = FALSE;
            l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE;
          #endif
            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if(SignalCode == MMI_VM_AMR_PLAY_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
               l1a_l1s_com.voicememo_amr_task.play.parameters.session_id =  ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id;

              if (l1a.dyn_dwnld.semaphore_vect[VOICE_PLAY_AMR_SM]==GREEN)
              {
                 // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
                 // Start the L1S voice memo playing task
                 l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE;
                *state = WAIT_START_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[30];
                   sprintf(str,"VOICE PLAY AMR SM blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                 }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }
            // End process
            return;
          }
// omaps00090550          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode==API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VOICE_PLAY_AMR_SM] == GREEN))
             {
                 // Start the L1S voice memo playing task
                 l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE;
                *state = WAIT_START_CON;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[32];
                   sprintf(str,"VOICE PLAY AMR SM un-blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                 }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
             }
             return;
          }
 // omaps00090550          break;
          case WAIT_START_CON:
          {
            if (SignalCode == L1_VM_AMR_PLAY_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550        break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_VM_AMR_PLAY_STOP_REQ)
            {
              // Stop the L1S voice memo playing task
              l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_VM_AMR_PLAY_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

      #if 0	/* FreeCalypso TCS211 reconstruction */
        case VM_AMR_PLAY:
          {
            switch (SignalCode)
            {
              case MMI_VM_AMR_PAUSE_REQ:
              {
              // Stop the L1S voice memo playing task
              l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE;
              *state = VM_AMR_PAUSE_CON;

              }
              break;

              case MMI_VM_AMR_PLAY_STOP_REQ:
              {
                // Stop the L1S voice memo playing task
                l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE;
                *state=WAIT_STOP;
              }
              break;

              case L1_VM_AMR_PLAY_STOP_CON:
              {
                l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);
                *state = RESET;
              }
              break;
            }
            return;
          }

          case VM_AMR_PAUSE_CON:
          {
            if(SignalCode==L1_VM_AMR_PAUSE_CON)
            {
                // Send confirmation to upper layers
                l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON);

              // Change state
              *state=VM_AMR_PAUSE;
            }
            else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
          return;
          }   // case WAIT_PAUSE_CON
      // *************
      // * VM_AMR_PAUSE *
      // *************
      case VM_AMR_PAUSE:
      {
        switch(SignalCode)
        {
          // * MMI requests VM_AMR resume *
          case MMI_VM_AMR_RESUME_REQ:
          {
            l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE;
           l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE;

            // Change state
            *state=WAIT_RESUME_CON;

          }
          break;
          // *-----------------------*
          // * MMI requests VM_AMR stop *
          // *-----------------------*
          case MMI_VM_AMR_PLAY_STOP_REQ:
          {
            // Store stop request in L1A/HISR interface
            l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE;

            // Change state
            *state=WAIT_STOP;

          }
          break;
          case L1_VM_AMR_PLAY_STOP_CON:
            {
             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
            break;
         }
              return;
            }
      // case VM_AMR_PAUSE
      // *******************
      // * WAIT_RESUME_CON *
      // *******************
      case WAIT_RESUME_CON:
      {
        if(SignalCode==L1_VM_AMR_RESUME_CON)
        {
           l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE;
          // Send confirmation to upper layers
                l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON);

            // Change state
            *state=VM_AMR_PLAY;
          }
         return;
      }   // case WAIT_RESUME_CON
      #endif
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_vm_amr_recording_process()                    */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* voice memorization recording feature.                 */
    /*                                                       */
    /* Starting messages:        MMI_VM_AMR_RECORD_START_REQ */
    /*                                                       */
    /* Result messages (input):  L1_VM_AMR_RECORD_START_CON  */
    /*                                                       */
    /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_VM_AMR_RECORD_STOP_REQ  */
    /*                           L1_VM_AMR_RECORD_STOP_CON   */
    /*                                                       */
    /* Stop message (output):    MMI_VM_AMR_RECORD_STOP_CON  */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_START_CON    = 3,
        WAIT_STOP         = 4
      };

      UWORD8    *state      = &l1a.state[L1A_VM_AMR_RECORD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;
            l1a_l1s_com.voicememo_amr_task.record.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_VM_AMR_RECORD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.voicememo_amr_task.record.parameters.session_id   =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size;
              l1a_l1s_com.voicememo_amr_task.record.parameters.dtx          =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used;
              l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder  =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder;

               // Download UL/DL audio gain to the NDB
              l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul;

              if(l1a.dyn_dwnld.semaphore_vect[VOICE_MEMO_AMR_SM]==GREEN)
              {
                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
                // Start the L1S voice memo recording task
                l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE;

                *state = WAIT_START_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"VOICE MEMO AMR SM blocked \r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            	}
            // End process
            return;
          }
 // omaps00090550          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[VOICE_MEMO_AMR_SM] == GREEN))
              {
               // Start the L1S voice memo recording task
               l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE;
               *state = WAIT_START_CON;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                 if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                 {
                   char str[32];
                   sprintf(str,"VOICE MEMO AMR SM un-blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                     trace_fct_simu_dyn_dwnld(str);
                   #else
                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                   #endif
                 }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
           return;
          }
 // omaps00090550       break;
          case WAIT_START_CON:
          {
            if (SignalCode == L1_VM_AMR_RECORD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ)
            {
              // Stop the L1S voice memo recording task
              l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_VM_AMR_RECORD_STOP_CON)
            {
              // Forward the stop confirmation message
              l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

#else // L1_DYN_DSP_DWNLD = 0

    /*-------------------------------------------------------*/
    /* l1a_mmi_vm_amr_playing_process()                      */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* voice memorization playing feature.                   */
    /*                                                       */
    /* Starting messages:        MMI_VM_AMR_PLAY_START_REQ   */
    /*                                                       */
    /* Result messages (input):  L1_VM_AMR_PLAY_START_CON    */
    /*                                                       */
    /* Result messages (output): MMI_VM_AMR_PLAY_START_CON   */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_VM_AMR_PLAY_STOP_REQ    */
    /*                           L1_VM_AMR_PLAY_STOP_CON     */
    /*                                                       */
    /* Stop message (output):    MMI_VM_AMR_PLAY_STOP_CON    */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/

    void l1a_mmi_vm_amr_playing_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3,
        VM_AMR_PLAY       = 4,
        VM_AMR_PAUSE      = 5,
        VM_AMR_PAUSE_CON  = 6,
        WAIT_RESUME_CON   = 7

      };

      UWORD8    *state      = &l1a.state[L1A_VM_AMR_PLAY_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;
            l1a_l1s_com.voicememo_amr_task.play.command.stop  = FALSE;
            l1a_l1s_com.voicememo_amr_task.play.command.pause  = FALSE;
            l1a_l1s_com.voicememo_amr_task.play.command.resume = FALSE;
            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_VM_AMR_PLAY_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.voicememo_amr_task.play.parameters.session_id =  ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id;

              // Start the L1S voice memo playing task
              l1a_l1s_com.voicememo_amr_task.play.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_VM_AMR_PLAY_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.voicememo_amr_task.play.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_START_CON);

              *state = VM_AMR_PLAY ;
            }

            // End process
            return;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == L1_VM_AMR_PLAY_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        case VM_AMR_PLAY:
          {
            switch (SignalCode)
            {
              case MMI_VM_AMR_PAUSE_REQ:
              {
              // Stop the L1S voice memo playing task
              l1a_l1s_com.voicememo_amr_task.play.command.pause= TRUE;
              *state = VM_AMR_PAUSE_CON;

              }
	            break;
              case MMI_VM_AMR_PLAY_STOP_REQ:
            {
              // Stop the L1S voice memo playing task
              l1a_l1s_com.voicememo_amr_task.play.command.stop = TRUE;
              *state=WAIT_STOP;

              }
              break;
              case L1_VM_AMR_PLAY_STOP_CON:
            {
             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
            break;
           }
              return;
            }

          case VM_AMR_PAUSE_CON:
          {
            if(SignalCode==L1_VM_AMR_PAUSE_CON)
            {
                // Send confirmation to upper layers
                l1a_audio_send_confirmation(MMI_VM_AMR_PAUSE_CON);

              // Change state
              *state=VM_AMR_PAUSE;
            }
            else if(SignalCode== L1_VM_AMR_PLAY_STOP_CON)
            {
              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
          return;
          }   // case WAIT_PAUSE_CON
      // *************
      // * VM_AMR_PAUSE *
      // *************
      case VM_AMR_PAUSE:
      {
        switch(SignalCode)
        {
          // * MMI requests VM_AMR resume *
          case MMI_VM_AMR_RESUME_REQ:
          {
            l1a_l1s_com.voicememo_amr_task.play.command.pause= FALSE;
           l1a_l1s_com.voicememo_amr_task.play.command.resume=TRUE;

            // Change state
            *state=WAIT_RESUME_CON;

          }
          break;
          // *-----------------------*
          // * MMI requests VM_AMR stop *
          // *-----------------------*
          case MMI_VM_AMR_PLAY_STOP_REQ:
          {
            // Store stop request in L1A/HISR interface
            l1a_l1s_com.voicememo_amr_task.play.command.stop=TRUE;

            // Change state
            *state=WAIT_STOP;

          }
          break;
          case L1_VM_AMR_PLAY_STOP_CON:
            {
             l1a_audio_send_confirmation(MMI_VM_AMR_PLAY_STOP_CON);

              *state = RESET;
            }
            break;
         }
              return;
            }
      // case VM_AMR_PAUSE
      // *******************
      // * WAIT_RESUME_CON *
      // *******************
      case WAIT_RESUME_CON:
      {
        if(SignalCode==L1_VM_AMR_RESUME_CON)
        {
           l1a_l1s_com.voicememo_amr_task.play.command.resume=FALSE;
          // Send confirmation to upper layers
                l1a_audio_send_confirmation(MMI_VM_AMR_RESUME_CON);

            // Change state
            *state=VM_AMR_PLAY;
          }
         return;
      }   // case WAIT_RESUME_CON
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_vm_amr_recording_process()                    */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* voice memorization recording feature.                 */
    /*                                                       */
    /* Starting messages:        MMI_VM_AMR_RECORD_START_REQ */
    /*                                                       */
    /* Result messages (input):  L1_VM_AMR_RECORD_START_CON  */
    /*                                                       */
    /* Result messages (output): MMI_VM_AMR_RECORD_START_CON */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_VM_AMR_RECORD_STOP_REQ  */
    /*                           L1_VM_AMR_RECORD_STOP_CON   */
    /*                                                       */
    /* Stop message (output):    MMI_VM_AMR_RECORD_STOP_CON  */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/

    void l1a_mmi_vm_amr_recording_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_VM_AMR_RECORD_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;
            l1a_l1s_com.voicememo_amr_task.record.command.stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_VM_AMR_RECORD_START_REQ)
            {
              // Download the parameters of the message to the l1a_l1s_com structure.
              l1a_l1s_com.voicememo_amr_task.record.parameters.session_id   =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.voicememo_amr_task.record.parameters.maximum_size =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size;
              l1a_l1s_com.voicememo_amr_task.record.parameters.dtx          =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used;
              l1a_l1s_com.voicememo_amr_task.record.parameters.amr_vocoder  =  ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder;

              // Download UL/DL audio gain to the NDB
              l1s_dsp_com.dsp_ndb_ptr->d_shiftul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul;

              // Start the L1S voice memo recording task
              l1a_l1s_com.voicememo_amr_task.record.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_VM_AMR_RECORD_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.voicememo_amr_task.record.command.start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_VM_AMR_RECORD_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_VM_AMR_RECORD_STOP_REQ)
            {
              // Stop the L1S voice memo recording task
              l1a_l1s_com.voicememo_amr_task.record.command.stop = TRUE;

              // End process
              return;
            }
            else
            if (SignalCode == L1_VM_AMR_RECORD_STOP_CON)
            {
              // Forward the stop confirmation message
              l1a_audio_send_result(MMI_VM_AMR_RECORD_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
   #endif // L1_DYN_DSP_DWNLD
  #endif // L1_VOICE_MEMO_AMR

  #if (SPEECH_RECO)
  #if(L1_DYN_DSP_DWNLD == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_sr_enroll_process()                           */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* speech recognition enrollment feature.                */
    /*                                                       */
    /* Starting messages:        MMI_SR_ENROLL_START_REQ     */
    /*                                                       */
    /* Result messages (input):  L1_SR_ENROLL_START_CON      */
    /*                                                       */
    /* Result messages (output): MMI_SR_ENROLL_START_CON     */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_SR_ENROLL_STOP_REQ      */
    /*                           L1_SR_ENROLL_STOP_CON       */
    /*                                                       */
    /* Stop message (output):    MMI_SR_ENROLL_STOP_CON      */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET               = 0,
        WAIT_START_REQ      = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_START_CON      = 3,
        WAIT_STOP           = 4,
        WAIT_BACK_TASK_DONE = 5,
        WAIT_L1S_STOP       = 6,
        WAIT_BACK_STOP      = 7
      };

      UWORD8            *state      = &l1a.state[L1A_SR_ENROLL_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
      #else
        xSignalHeaderRec  *conf_msg;
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
            l1a_l1s_com.speechreco_task.command.enroll_stop  = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_ENROLL_START_REQ)
            {
              // Download the message parameters to the parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech;
              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address;

              if(l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM]==GREEN)
              {

                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
                // Set the start command of the speech recording task
                l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

                // Start the speech recognition enrollment task
                l1a_l1s_com.speechreco_task.command.enroll_start = TRUE;

              *state = WAIT_START_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"SPEECH RECO SM blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                     trace_fct_simu_dyn_dwnld(str);
                   #else
                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                   #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN))
            {
              // Set the start command of the speech recording task
              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

              // Start the speech recognition enrollment task
              l1a_l1s_com.speechreco_task.command.enroll_start = TRUE;
              *state = WAIT_START_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                {
                  char str[30];
                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                     trace_fct_simu_dyn_dwnld(str);
                   #else
                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                   #endif
                }
              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
          break;
          case WAIT_START_CON:
          {
            if (SignalCode == L1_SR_ENROLL_START_CON)
            {
              // Reset the commands
              l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
            {
              // Stop the speech recognition enroll task
              l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SR_ENROLL_STOP_CON)
            {
              // There is an error during the acquisition task?
              if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // Reset the background task emergency stop
                l1_srback_com.emergency_stop = FALSE;

                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);

                *state = WAIT_BACK_TASK_DONE;

                // End process
                return;
              }
              else
              // There is an error
              {
                // Forward the stop confirmation message
                l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
              }
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_TASK_DONE:
          {
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the stop confirmation message with no error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) );
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;

              //Fill the message
              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;

            }
            else
            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;

              // End process
              return;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;

              //Fill the message
              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if (SignalCode == L1_SR_ENROLL_STOP_CON)
            {
              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;

              //Fill the message
              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_sr_update_process()                           */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* speech recognition update feature.                    */
    /*                                                       */
    /* Starting messages:        MMI_SR_UPDATE_START_REQ     */
    /*                                                       */
    /* Result messages (input):  L1_SR_UPDATE_START_CON      */
    /*                                                       */
    /* Result messages (output): MMI_SR_UPDATE_START_CON     */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_SR_UPDATE_STOP_REQ      */
    /*                           L1_SR_UPDATE_STOP_CON       */
    /*                                                       */
    /* Stop message (output):    MMI_SR_UPDATE_STOP_CON      */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_sr_update_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET               = 0,
        WAIT_START_REQ      = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_MODEL_LOADED   = 3,
        WAIT_START_CON      = 4,
        WAIT_STOP           = 5,
        WAIT_BACK_TASK_DONE = 6,
        WAIT_L1S_STOP       = 7,
        WAIT_BACK_STOP      = 8
      };

      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
      #else
        xSignalHeaderRec  *conf_msg;
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_UPDATE_START_REQ)
            {
              // Download the message parameters to the parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech;
              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address;

              // Reset the background task emergency stop
              l1_srback_com.emergency_stop = FALSE;

              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;

              if(l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)
              {

                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
                // Start to download the model to the API
                l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

                // Send the start confirmation message
                l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON);

                *state = WAIT_MODEL_LOADED;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"SPEECH RECO SM blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                     trace_fct_simu_dyn_dwnld(str);
                   #else
                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                   #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN))
            {
               // Start to download the model to the API
              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON);

              *state = WAIT_MODEL_LOADED;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                {
                  char str[30];
                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
                  #if(CODE_VERSION == SIMULATION)
                    trace_fct_simu_dyn_dwnld(str);
                  #else
                    rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                  #endif
                }
              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)

            }
            return;
          }
          break;
          case WAIT_MODEL_LOADED:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }
            else
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Set the start command of the speech recording task
              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

              // Start the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;
            }
            else
            if (SignalCode == L1_SR_UPDATE_START_CON)
            {
              // Reset the commands
              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SR_UPDATE_STOP_CON)
            {
              // There is an error during the update task?
              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // Reset the background task emergency stop
                l1_srback_com.emergency_stop = FALSE;

                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);

                *state = WAIT_BACK_TASK_DONE;

                // End process
                return;
              }
              else
              {
                // Forward the stop confirmation message
                l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
              }
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_TASK_DONE:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }
            else
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) ||
                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) )
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if (SignalCode == L1_SR_UPDATE_STOP_CON)
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_sr_reco_process()                             */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* speech recognition reco feature.                      */
    /*                                                       */
    /* Starting messages:        MMI_SR_RECO_START_REQ       */
    /*                                                       */
    /* Result messages (input):  L1_SR_RECO_START_CON        */
    /*                                                       */
    /* Result messages (output): MMI_SR_RECO_START_CON       */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_SR_RECO_STOP_REQ        */
    /*                           L1_SR_RECO_STOP_IND         */
    /*                                                       */
    /* Stop message (output):    MMI_SR_RECO_STOP_CON        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET                 = 0,
        WAIT_START_REQ        = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_RECO_START       = 3,
        WAIT_RECO_STOP        = 4,
        LOAD_MODEL            = 5,
        WAIT_MODEL_LOADED     = 6,
        WAIT_PROCESSING_STOP  = 7,
        WAIT_L1S_STOP         = 8,
        WAIT_BACK_STOP        = 9
      };

      UWORD8            *state      = &l1a.state[L1A_SR_RECO_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
      #else
        xSignalHeaderRec  *conf_msg;
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.reco_start        = FALSE;
            l1a_l1s_com.speechreco_task.command.reco_stop         = FALSE;
            l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
            l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_RECO_START_REQ)
            {
              // Reset the index counter
              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;

              // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id     = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size;
              l1a_l1s_com.speechreco_task.parameters.model_address   = l1s_dsp_com.dsp_ndb_ptr->a_model;

              // The CTO algorithm must be used?
              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
              {
                // Enable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;

                // Double the vocabulary size
                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
              }
              else
              {
                // Disable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
              }

              if (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)
              {

                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
                // Start the speech recognition reco task
                l1a_l1s_com.speechreco_task.command.reco_start = TRUE;

                *state = WAIT_RECO_START;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"SPEECH RECO SM blocked\r\n");
                   #if(CODE_VERSION == SIMULATION)
                     trace_fct_simu_dyn_dwnld(str);
                   #else
                     rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                   #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }
            // End process
            return;
          }
          break;

          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN))
            {
              // Start the speech recognition reco task
              l1a_l1s_com.speechreco_task.command.reco_start = TRUE;
              *state = WAIT_RECO_START;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                {
                  char str[30];
                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
                  #if(CODE_VERSION == SIMULATION)
                    trace_fct_simu_dyn_dwnld(str);
                  #else
                    rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                  #endif
                }
              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)

            }
            return;
          }
          break;
          case WAIT_RECO_START:
          {
            if (SignalCode == L1_SR_RECO_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.speechreco_task.command.reco_start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_RECO_START_CON);

              *state = WAIT_RECO_STOP;
            }
            // End process
            return;
          }
          break;

          case WAIT_RECO_STOP:
          {
            if (SignalCode == L1_SR_RECO_STOP_CON)
            {
              // The acqusition is good or not?
              if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                *state = LOAD_MODEL;
              }
              else
              {
                // Send the message MMI_SR_RECO_STOP_CON with an error
              #if (OP_RIV_AUDIO == 1)
                // Allocate the Riviera buffer
                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                        sizeof (T_MMI_SR_RECO_STOP_CON),
                                        (T_RVF_BUFFER **) (&p_message));

                // If insufficient resources, then report a memory error and abort.
                if (mb_status == RVF_RED)
                {
                  // the memory is insufficient to continue the non regression test
                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                  return;
                }

                // Fill the message ID
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

                // Fill the message parameter
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
                  ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;

                // send the messsage to the audio entity
                rvf_send_msg (p_audio_gbl_var->addrId,
                              p_message);
              #else // OP_RIV_AUDIO
                // Allocate confirmation message...
                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
                DEBUGMSG(status,NU_ALLOC_ERR)
                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
                // File the message
                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;

                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                    l1_trace_message(conf_msg);
                #endif

                // Send the confirmation message...
                os_send_sig(conf_msg, MMI_QUEUE);
                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
              #endif // OP_RIV_AUDIO

                *state = RESET;
              }
            }
            else
            if(SignalCode == MMI_SR_RECO_STOP_REQ)
            {
              // Stop the speech recognition task
              l1a_l1s_com.speechreco_task.command.reco_stop = TRUE;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case LOAD_MODEL:
          {
            // Initialize the background task stop command
            l1_srback_com.emergency_stop = FALSE;

            // Start to load the model to the API
            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

            // Increase the index counter
            l1a_l1s_com.speechreco_task.parameters.index_counter++;

            *state = WAIT_MODEL_LOADED;

            // End process
            return;
          }
          break;

          case WAIT_MODEL_LOADED:
          {
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Start the DSP processing task
              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;

              *state = WAIT_PROCESSING_STOP;
            }
            else
            if (SignalCode == MMI_SR_RECO_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_PROCESSING_STOP:
          {
            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
            {
              // The processing phase is good or not?
              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                *state = LOAD_MODEL;
              }
              else
              {
                // Send the MMI_SR_RECO_STOP_CON message with an error
              #if (OP_RIV_AUDIO == 1)
                // Allocate the Riviera buffer
                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                        sizeof (T_MMI_SR_RECO_STOP_CON),
                                        (T_RVF_BUFFER **) (&p_message));

                // If insufficient resources, then report a memory error and abort.
                if (mb_status == RVF_RED)
                {
                  // the memory is insufficient to continue the non regression test
                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                  return;
                }

                // Fill the message ID
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

                // Fill the message parameter
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
              #else // OP_RIV_AUDIO
                // Allocate confirmation message...
                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
                DEBUGMSG(status,NU_ALLOC_ERR)
                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
                // File the message
                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;

                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                    l1_trace_message(conf_msg);
                #endif

                // Send the confirmation message...
                os_send_sig(conf_msg, MMI_QUEUE);
                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
              #endif // OP_RIV_AUDIO

                *state = RESET;
              }
            }
            else
            if (SignalCode == L1_SR_RECO_STOP_IND)
            {
              // The CTO algorithm is used?
              if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
              {
                // There is an error during the recognition?
                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
                {
                  // The best word is odd?
                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
                  {
                    // Change the error to tSC_CTO_WORD
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;
                  }
                  else
                  {
                    // Devided by 2 the 4 indexes of the best words in the message
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
                  }
                }
              }
                // Forward the message in the MMI_SR_RECO_STOP_CON
                l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
            }
            else
            if (SignalCode == MMI_SR_RECO_STOP_REQ)
            {
              // Stop the L1S processing task
              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;

              *state = WAIT_L1S_STOP;

              // end process
              return;
            }
            else
            {
              // end process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
                 (SignalCode == L1_SR_RECO_STOP_IND) )
            {
              // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_RECO_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
              // File the message
              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Send the MMI_SR_RECO_STOP_CON with an bad recognition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_RECO_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
              // Fill the message
              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*---------------------------------------------------------*/
    /* l1a_mmi_sr_update_check_process()                       */
    /*---------------------------------------------------------*/
    /*                                                         */
    /* Description:                                            */
    /* ------------                                            */
    /* This function is a state machine which handles the      */
    /* speech recognition update check feature.                */
    /*                                                         */
    /* Starting messages:        MMI_SR_UPDATE_CHECK_START_REQ */
    /*                                                         */
    /* Result messages (input):  L1_SR_UPDATE_START_CON        */
    /*                                                         */
    /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */
    /*                                                         */
    /* Reset messages (input):   none                          */
    /*                                                         */
    /* Stop message (input):     MMI_SR_UPDATE_CHECK_STOP_REQ  */
    /*                           L1_SR_RECO_STOP_IND           */
    /*                                                         */
    /* Stop message (output):    MMI_SR_UPDATE_CHECK_STOP_CON  */
    /*                                                         */
    /* Rem:                                                    */
    /* ----                                                    */
    /*                                                         */
    /*---------------------------------------------------------*/
    void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET                 = 0,
        WAIT_START_REQ        = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_MODEL            = 3,
        WAIT_UPDATE_START     = 4,
        WAIT_UPDATE_STOP      = 5,
        WAIT_TEMP_SAVE_DONE   = 6,
        LOAD_MODEL            = 7,
        WAIT_MODEL_LOADED     = 8,
        WAIT_PROCESSING_STOP  = 9,
        WAIT_SAVE_DONE        = 10,
        WAIT_L1S_STOP         = 11,
        WAIT_BACK_STOP        = 12
      };

      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_CHECK_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
        #define AUDIO_MSG (p_message)
      #else
        xSignalHeaderRec  *conf_msg;
        #define AUDIO_MSG (conf_msg->SigP)
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if(SignalCode == MMI_SR_UPDATE_CHECK_START_REQ)
            {
              // Download the message parameters to the parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id        = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.word_index         = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.word_to_check      = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.model_address      = l1s_dsp_com.dsp_ndb_ptr->a_model;
              l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address;
              l1a_l1s_com.speechreco_task.parameters.speech             = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech;
              l1a_l1s_com.speechreco_task.parameters.speech_address     = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address;
              l1a_l1s_com.speechreco_task.parameters.vocabulary_size    = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size;

              // Reset the background task emergency stop
              l1_srback_com.emergency_stop = FALSE;

              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;

              if (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN)
              {

                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
                // Start to download the model to the API
                l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

                // Send the start confirmation message
                l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON);

                *state = WAIT_MODEL;
              }
              else
              {
               *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"SPEECH RECO SM blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[SPEECH_RECO_SM] == GREEN))
            {

              // Start to download the model to the API
              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON);

              *state = WAIT_MODEL;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                {
                  char str[30];
                  sprintf(str,"SPEECH RECO SM un-blocked\r\n");
                  #if(CODE_VERSION == SIMULATION)
                    trace_fct_simu_dyn_dwnld(str);
                  #else
                    rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                  #endif
                }
              #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)

            }
            return;
          }
          break;
          case WAIT_MODEL:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }
            else
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Set the start command of the speech recording task
              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

              // Start the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_start = TRUE;

              *state = WAIT_UPDATE_START;
            }

            // End process
            return;
          }
          break;

          case WAIT_UPDATE_START:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;
            }
            else
            if (SignalCode == L1_SR_UPDATE_START_CON)
            {
              // Reset the commands
              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;

              *state = WAIT_UPDATE_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_UPDATE_STOP:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SR_UPDATE_STOP_CON)
            {
              // There is an error during the update task?
              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // Reset the background task emergency stop
                l1_srback_com.emergency_stop = FALSE;

                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
                l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ);

                *state = WAIT_TEMP_SAVE_DONE;

                // End process
                return;
              }
              else
              {
                // Forward the stop confirmation message
                l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
              }
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_TEMP_SAVE_DONE:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON)
            {
              // Reset the command
              l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
              l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;

              // Reset the index counter
              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;

              // The CTO algorithm must be used?
              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
              {
                // Enable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;

                // Double the vocabulary size
                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
              }
              else
              {
                // Disable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
              }

              *state = LOAD_MODEL;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case LOAD_MODEL:
          {
            // Initialize the background task stop command
            l1_srback_com.emergency_stop = FALSE;

            // Start to load the model to the API
            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

            // Increase the index counter
            l1a_l1s_com.speechreco_task.parameters.index_counter++;

            *state = WAIT_MODEL_LOADED;

            // End process
            return;
          }
          break;

          case WAIT_MODEL_LOADED:
          {
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Start the DSP processing task
              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;

              *state = WAIT_PROCESSING_STOP;
            }
            else
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_PROCESSING_STOP:
          {
            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
            {
              // The processing phase is good or not?
              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                *state = LOAD_MODEL;
              }
              else
              {
                // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
              #if (OP_RIV_AUDIO == 1)
                // Allocate the Riviera buffer
                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                        sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                        (T_RVF_BUFFER **) (&p_message));

                // If insufficient resources, then report a memory error and abort.
                if (mb_status == RVF_RED)
                {
                  // the memory is insufficient to continue the non regression test
                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                  return;
                }

                // Fill the message ID
                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;

                // Fill the message parameter
                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id =
                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;

                // send the messsage to the audio entity
                rvf_send_msg (p_audio_gbl_var->addrId,
                              p_message);
              #else // OP_RIV_AUDIO
                // Allocate confirmation message...
                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
                DEBUGMSG(status,NU_ALLOC_ERR)
                conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
                // File the message
                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;

                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                    l1_trace_message(conf_msg);
                #endif

                // Send the confirmation message...
                os_send_sig(conf_msg, MMI_QUEUE);
                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
              #endif // OP_RIV_AUDIO

                *state = RESET;
              }
            }
            else
            if (SignalCode == L1_SR_RECO_STOP_IND)
            {
              // There is an error during the recognition?
              if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // The CTO algorithm is used?
                if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
                {
                  // The best word is odd?
                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
                  {
                    // Change the error to SC_CTO_WORD
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;

                    // Forward the message in the MMI_SR_RECO_STOP_CON
                    l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);

                    *state = RESET;

                    // End process
                    return;
                  }
                  else
                  {
                    // Devided by 2 the 4 indexes of the best words in the message
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
                  }
                }
                // Is it the good word?
                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index ==
                     l1a_l1s_com.speechreco_task.parameters.word_to_check )
                {
                  // Save the message informations in the l1a_l1s_com memory
                  l1a_l1s_com.speechreco_task.parameters.best_word_index        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.best_word_score        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.third_best_word_index  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.third_best_word_score  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_level          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level;
                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise;
                  l1a_l1s_com.speechreco_task.parameters.d_sr_model_size        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size;

                  // Reset the stop background task
                  l1_srback_com.emergency_stop = FALSE;

                  // Start the background task to save the model in the database
                  l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check;
                  l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address;
                  l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);

                  *state = WAIT_SAVE_DONE;

                  // End process
                  return;
                }
                else
                {
                  // Change the error to SC_CHECK_ERROR
                  ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR;
                }
              }
              // Forward the message in the MMI_SR_RECO_STOP_CON
              l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop the L1S processing task
              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;

              *state = WAIT_L1S_STOP;

              // end process
              return;
            }
            else
            {
              // end process
              return;
            }
          }
          break;

          case WAIT_SAVE_DONE:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
            #endif // OP_RIV_AUDIO

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id                = SC_NO_ERROR;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index         = l1a_l1s_com.speechreco_task.parameters.best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score         = l1a_l1s_com.speechreco_task.parameters.best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index  = l1a_l1s_com.speechreco_task.parameters.second_best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score  = l1a_l1s_com.speechreco_task.parameters.second_best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index   = l1a_l1s_com.speechreco_task.parameters.third_best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score   = l1a_l1s_com.speechreco_task.parameters.third_best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size         = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size;

            #if (OP_RIV_AUDIO == 1)
              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON)  ||
                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ||
                 (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) )
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if ( (SignalCode == L1_SR_UPDATE_STOP_CON)     ||
                 (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
                 (SignalCode == L1_SR_RECO_STOP_IND) )
            {
              // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)

      // Undefine message pointer macro.
      #undef MSG_AUDIO

    }
    #else // L1_DYN_DSP_DWNLD = 0
    /*-------------------------------------------------------*/
    /* l1a_mmi_sr_enroll_process()                           */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* speech recognition enrollment feature.                */
    /*                                                       */
    /* Starting messages:        MMI_SR_ENROLL_START_REQ     */
    /*                                                       */
    /* Result messages (input):  L1_SR_ENROLL_START_CON      */
    /*                                                       */
    /* Result messages (output): MMI_SR_ENROLL_START_CON     */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_SR_ENROLL_STOP_REQ      */
    /*                           L1_SR_ENROLL_STOP_CON       */
    /*                                                       */
    /* Stop message (output):    MMI_SR_ENROLL_STOP_CON      */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_sr_enroll_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET               = 0,
        WAIT_START_REQ      = 1,
        WAIT_START_CON      = 2,
        WAIT_STOP           = 3,
        WAIT_BACK_TASK_DONE = 4,
        WAIT_L1S_STOP       = 5,
        WAIT_BACK_STOP      = 6
      };

      UWORD8            *state      = &l1a.state[L1A_SR_ENROLL_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
      #else
        xSignalHeaderRec  *conf_msg;
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
            l1a_l1s_com.speechreco_task.command.enroll_stop  = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_ENROLL_START_REQ)
            {
              // Download the message parameters to the parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech;
              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address;

              // Set the start command of the speech recording task
              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

              // Start the speech recognition enrollment task
              l1a_l1s_com.speechreco_task.command.enroll_start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_SR_ENROLL_START_CON)
            {
              // Reset the commands
              l1a_l1s_com.speechreco_task.command.enroll_start = FALSE;
              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_ENROLL_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
            {
              // Stop the speech recognition enroll task
              l1a_l1s_com.speechreco_task.command.enroll_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SR_ENROLL_STOP_CON)
            {
              // There is an error during the acquisition task?
              if ( ((T_L1_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // Reset the background task emergency stop
                l1_srback_com.emergency_stop = FALSE;

                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);

                *state = WAIT_BACK_TASK_DONE;

                // End process
                return;
              }
              else
              // There is an error
              {
                // Forward the stop confirmation message
                l1a_audio_send_result(MMI_SR_ENROLL_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
              }
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_TASK_DONE:
          {
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the stop confirmation message with no error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig( sizeof(T_MMI_SR_ENROLL_STOP_CON) );
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;

              //Fill the message
              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;

            }
            else
            if (SignalCode == MMI_SR_ENROLL_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;

              // End process
              return;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;

              //Fill the message
              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if (SignalCode == L1_SR_ENROLL_STOP_CON)
            {
              // Send the message MMI_SR_ENROLL_STOP_CON with an acquisition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_ENROLL_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->header.msg_id = MMI_SR_ENROLL_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_ENROLL_STOP_CON *)(p_message))->error_id = SC_BAD_ACQUISITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_ENROLL_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_ENROLL_STOP_CON;

              //Fill the message
              ((T_MMI_SR_ENROLL_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_ACQUISITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_sr_update_process()                           */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* speech recognition update feature.                    */
    /*                                                       */
    /* Starting messages:        MMI_SR_UPDATE_START_REQ     */
    /*                                                       */
    /* Result messages (input):  L1_SR_UPDATE_START_CON      */
    /*                                                       */
    /* Result messages (output): MMI_SR_UPDATE_START_CON     */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_SR_UPDATE_STOP_REQ      */
    /*                           L1_SR_UPDATE_STOP_CON       */
    /*                                                       */
    /* Stop message (output):    MMI_SR_UPDATE_STOP_CON      */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_sr_update_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET               = 0,
        WAIT_START_REQ      = 1,
        WAIT_MODEL_LOADED   = 2,
        WAIT_START_CON      = 3,
        WAIT_STOP           = 4,
        WAIT_BACK_TASK_DONE = 5,
        WAIT_L1S_STOP       = 6,
        WAIT_BACK_STOP      = 7
      };

      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
      #else
        xSignalHeaderRec  *conf_msg;
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_UPDATE_START_REQ)
            {
              // Download the message parameters to the parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id    = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.word_index     = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.model_address  = l1s_dsp_com.dsp_ndb_ptr->a_model;
              l1a_l1s_com.speechreco_task.parameters.speech         = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech;
              l1a_l1s_com.speechreco_task.parameters.speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address;

              // Reset the background task emergency stop
              l1_srback_com.emergency_stop = FALSE;

              // Start to download the model to the API
              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_UPDATE_START_CON);

              *state = WAIT_MODEL_LOADED;
            }

            // End process
            return;
          }
          break;

          case WAIT_MODEL_LOADED:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }
            else
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Set the start command of the speech recording task
              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

              // Start the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;
            }
            else
            if (SignalCode == L1_SR_UPDATE_START_CON)
            {
              // Reset the commands
              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SR_UPDATE_STOP_CON)
            {
              // There is an error during the update task?
              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // Reset the background task emergency stop
                l1_srback_com.emergency_stop = FALSE;

                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
                l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);

                *state = WAIT_BACK_TASK_DONE;

                // End process
                return;
              }
              else
              {
                // Forward the stop confirmation message
                l1a_audio_send_result(MMI_SR_UPDATE_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
              }
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_TASK_DONE:
          {
            if (SignalCode == MMI_SR_UPDATE_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }
            else
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an acquisition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_NO_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_NO_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON) ||
                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) )
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if (SignalCode == L1_SR_UPDATE_STOP_CON)
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_STOP_CON *)(p_message))->error_id = SC_BAD_UPDATE;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_UPDATE;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_sr_reco_process()                             */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* speech recognition reco feature.                      */
    /*                                                       */
    /* Starting messages:        MMI_SR_RECO_START_REQ       */
    /*                                                       */
    /* Result messages (input):  L1_SR_RECO_START_CON        */
    /*                                                       */
    /* Result messages (output): MMI_SR_RECO_START_CON       */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_SR_RECO_STOP_REQ        */
    /*                           L1_SR_RECO_STOP_IND         */
    /*                                                       */
    /* Stop message (output):    MMI_SR_RECO_STOP_CON        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_sr_reco_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET                 = 0,
        WAIT_START_REQ        = 1,
        WAIT_RECO_START       = 2,
        WAIT_RECO_STOP        = 3,
        LOAD_MODEL            = 4,
        WAIT_MODEL_LOADED     = 5,
        WAIT_PROCESSING_STOP  = 6,
        WAIT_L1S_STOP         = 7,
        WAIT_BACK_STOP        = 8
      };

      UWORD8            *state      = &l1a.state[L1A_SR_RECO_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
      #else
        xSignalHeaderRec  *conf_msg;
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.reco_start        = FALSE;
            l1a_l1s_com.speechreco_task.command.reco_stop         = FALSE;
            l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
            l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_RECO_START_REQ)
            {

              // Reset the index counter
              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;

              // Download the parameters to the l1a_l1s_com.speechreco_task.parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id     = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size;
              l1a_l1s_com.speechreco_task.parameters.model_address   = l1s_dsp_com.dsp_ndb_ptr->a_model;

              // The CTO algorithm must be used?
              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
              {
                // Enable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;

                // Double the vocabulary size
                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
              }
              else
              {
                // Disable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
              }

              // Start the speech recognition reco task
              l1a_l1s_com.speechreco_task.command.reco_start = TRUE;

              *state = WAIT_RECO_START;
            }

            // End process
            return;
          }
          break;


          case WAIT_RECO_START:
          {
            if (SignalCode == L1_SR_RECO_START_CON)
            {
              // Reset the start command
              l1a_l1s_com.speechreco_task.command.reco_start = FALSE;

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_RECO_START_CON);

              *state = WAIT_RECO_STOP;
            }
            // End process
            return;
          }
          break;

          case WAIT_RECO_STOP:
          {
            if (SignalCode == L1_SR_RECO_STOP_CON)
            {
              // The acqusition is good or not?
              if ( ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                *state = LOAD_MODEL;
              }
              else
              {
                // Send the message MMI_SR_RECO_STOP_CON with an error
              #if (OP_RIV_AUDIO == 1)
                // Allocate the Riviera buffer
                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                        sizeof (T_MMI_SR_RECO_STOP_CON),
                                        (T_RVF_BUFFER **) (&p_message));

                // If insufficient resources, then report a memory error and abort.
                if (mb_status == RVF_RED)
                {
                  // the memory is insufficient to continue the non regression test
                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                  return;
                }

                // Fill the message ID
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

                // Fill the message parameter
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
                  ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;

                // send the messsage to the audio entity
                rvf_send_msg (p_audio_gbl_var->addrId,
                              p_message);
              #else // OP_RIV_AUDIO
                // Allocate confirmation message...
                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
                DEBUGMSG(status,NU_ALLOC_ERR)
                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
                // File the message
                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_RECO_STOP_CON *)(msg->SigP))->error_id;

                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                    l1_trace_message(conf_msg);
                #endif

                // Send the confirmation message...
                os_send_sig(conf_msg, MMI_QUEUE);
                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
              #endif // OP_RIV_AUDIO

                *state = RESET;
              }
            }
            else
            if(SignalCode == MMI_SR_RECO_STOP_REQ)
            {
              // Stop the speech recognition task
              l1a_l1s_com.speechreco_task.command.reco_stop = TRUE;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case LOAD_MODEL:
          {
            // Initialize the background task stop command
            l1_srback_com.emergency_stop = FALSE;

            // Start to load the model to the API
            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

            // Increase the index counter
            l1a_l1s_com.speechreco_task.parameters.index_counter++;

            *state = WAIT_MODEL_LOADED;

            // End process
            return;
          }
          break;

          case WAIT_MODEL_LOADED:
          {
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Start the DSP processing task
              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;

              *state = WAIT_PROCESSING_STOP;
            }
            else
            if (SignalCode == MMI_SR_RECO_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_PROCESSING_STOP:
          {
            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
            {
              // The processing phase is good or not?
              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                *state = LOAD_MODEL;
              }
              else
              {
                // Send the MMI_SR_RECO_STOP_CON message with an error
              #if (OP_RIV_AUDIO == 1)
                // Allocate the Riviera buffer
                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                        sizeof (T_MMI_SR_RECO_STOP_CON),
                                        (T_RVF_BUFFER **) (&p_message));

                // If insufficient resources, then report a memory error and abort.
                if (mb_status == RVF_RED)
                {
                  // the memory is insufficient to continue the non regression test
                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                  return;
                }

                // Fill the message ID
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

                // Fill the message parameter
                ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id =
                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;
              #else // OP_RIV_AUDIO
                // Allocate confirmation message...
                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
                DEBUGMSG(status,NU_ALLOC_ERR)
                conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
                // File the message
                ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;

                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                    l1_trace_message(conf_msg);
                #endif

                // Send the confirmation message...
                os_send_sig(conf_msg, MMI_QUEUE);
                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
              #endif // OP_RIV_AUDIO

                *state = RESET;
              }
            }
            else
            if (SignalCode == L1_SR_RECO_STOP_IND)
            {
              // The CTO algorithm is used?
              if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
              {
                // There is an error during the recognition?
                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
                {
                  // The best word is odd?
                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
                  {
                    // Change the error to tSC_CTO_WORD
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;
                  }
                  else
                  {
                    // Devided by 2 the 4 indexes of the best words in the message
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
                  }
                }
              }
                // Forward the message in the MMI_SR_RECO_STOP_CON
                l1a_audio_send_result(MMI_SR_RECO_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
            }
            else
            if (SignalCode == MMI_SR_RECO_STOP_REQ)
            {
              // Stop the L1S processing task
              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;

              *state = WAIT_L1S_STOP;

              // end process
              return;
            }
            else
            {
              // end process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if ( (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
                 (SignalCode == L1_SR_RECO_STOP_IND) )
            {
              // Send the message MMI_SR_RECO_STOP_CON with a bad recognition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_RECO_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
              // File the message
              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Send the MMI_SR_RECO_STOP_CON with an bad recognition error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_RECO_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->header.msg_id = MMI_SR_RECO_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_RECO_STOP_CON *)(p_message))->error_id = SC_BAD_RECOGNITION;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_RECO_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_RECO_STOP_CON;
              // Fill the message
              ((T_MMI_SR_RECO_STOP_CON *)(conf_msg->SigP))->error_id = SC_BAD_RECOGNITION;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }

    /*---------------------------------------------------------*/
    /* l1a_mmi_sr_update_check_process()                       */
    /*---------------------------------------------------------*/
    /*                                                         */
    /* Description:                                            */
    /* ------------                                            */
    /* This function is a state machine which handles the      */
    /* speech recognition update check feature.                */
    /*                                                         */
    /* Starting messages:        MMI_SR_UPDATE_CHECK_START_REQ */
    /*                                                         */
    /* Result messages (input):  L1_SR_UPDATE_START_CON        */
    /*                                                         */
    /* Result messages (output): MMI_SR_UPDATE_CHECK_START_CON */
    /*                                                         */
    /* Reset messages (input):   none                          */
    /*                                                         */
    /* Stop message (input):     MMI_SR_UPDATE_CHECK_STOP_REQ  */
    /*                           L1_SR_RECO_STOP_IND           */
    /*                                                         */
    /* Stop message (output):    MMI_SR_UPDATE_CHECK_STOP_CON  */
    /*                                                         */
    /* Rem:                                                    */
    /* ----                                                    */
    /*                                                         */
    /*---------------------------------------------------------*/
    void l1a_mmi_sr_update_check_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET                 = 0,
        WAIT_START_REQ        = 1,
        WAIT_MODEL            = 2,
        WAIT_UPDATE_START     = 3,
        WAIT_UPDATE_STOP      = 4,
        WAIT_TEMP_SAVE_DONE   = 5,
        LOAD_MODEL            = 6,
        WAIT_MODEL_LOADED     = 7,
        WAIT_PROCESSING_STOP  = 8,
        WAIT_SAVE_DONE        = 9,
        WAIT_L1S_STOP         = 10,
        WAIT_BACK_STOP        = 11
      };

      UWORD8            *state      = &l1a.state[L1A_SR_UPDATE_CHECK_STATE];
      UWORD32           SignalCode  = msg->SignalCode;
      #if (OP_RIV_AUDIO == 1)
        void              *p_message;
        T_RVF_MB_STATUS   mb_status;
        #define AUDIO_MSG (p_message)
      #else
        xSignalHeaderRec  *conf_msg;
        #define AUDIO_MSG (conf_msg->SigP)
      #endif

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.speechreco_task.command.update_start = FALSE;
            l1a_l1s_com.speechreco_task.command.update_stop  = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_start = FALSE;
            l1a_l1s_com.speechreco_task.command.speech_stop  = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_START_REQ)
            {
              // Download the message parameters to the parameters memory
              l1a_l1s_com.speechreco_task.parameters.database_id        = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id;
              l1a_l1s_com.speechreco_task.parameters.word_index         = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.word_to_check      = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
              l1a_l1s_com.speechreco_task.parameters.model_address      = l1s_dsp_com.dsp_ndb_ptr->a_model;
              l1a_l1s_com.speechreco_task.parameters.model_temp_address = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address;
              l1a_l1s_com.speechreco_task.parameters.speech             = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech;
              l1a_l1s_com.speechreco_task.parameters.speech_address     = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address;
              l1a_l1s_com.speechreco_task.parameters.vocabulary_size    = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size;

              // Reset the background task emergency stop
              l1_srback_com.emergency_stop = FALSE;

              // Start to download the model to the API
              l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
              l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_SR_UPDATE_CHECK_START_CON);

              *state = WAIT_MODEL;
            }

            // End process
            return;
          }
          break;

          case WAIT_MODEL:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }
            else
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Set the start command of the speech recording task
              l1a_l1s_com.speechreco_task.command.speech_start = l1a_l1s_com.speechreco_task.parameters.speech;

              // Start the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_start = TRUE;

              *state = WAIT_UPDATE_START;
            }

            // End process
            return;
          }
          break;

          case WAIT_UPDATE_START:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;
            }
            else
            if (SignalCode == L1_SR_UPDATE_START_CON)
            {
              // Reset the commands
              l1a_l1s_com.speechreco_task.command.update_start = FALSE;
              l1a_l1s_com.speechreco_task.command.speech_start = FALSE;

              *state = WAIT_UPDATE_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_UPDATE_STOP:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop the speech recognition update task
              l1a_l1s_com.speechreco_task.command.update_stop = TRUE;

              // Stop the speech recording task (if present)
              l1a_l1s_com.speechreco_task.command.speech_stop = l1a_l1s_com.speechreco_task.parameters.speech;

              *state = WAIT_L1S_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SR_UPDATE_STOP_CON)
            {
              // There is an error during the update task?
              if ( ((T_L1_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // Reset the background task emergency stop
                l1_srback_com.emergency_stop = FALSE;

                // Send the message L1_SRBACK_SAVE_DATA_REQ to the background task
                l1_send_sr_background_msg(L1_SRBACK_TEMP_SAVE_DATA_REQ);

                *state = WAIT_TEMP_SAVE_DONE;

                // End process
                return;
              }
              else
              {
                // Forward the stop confirmation message
                l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);

                *state = RESET;
              }
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_TEMP_SAVE_DONE:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON)
            {
              // Reset the command
              l1a_l1s_com.speechreco_task.command.processing_start  = FALSE;
              l1a_l1s_com.speechreco_task.command.processing_stop   = FALSE;

              // Reset the index counter
              l1a_l1s_com.speechreco_task.parameters.index_counter = 0;

              // The CTO algorithm must be used?
              if (l1a_l1s_com.speechreco_task.parameters.vocabulary_size <= SC_SR_MAX_WORDS_FOR_CTO)
              {
                // Enable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = TRUE;

                // Double the vocabulary size
                l1a_l1s_com.speechreco_task.parameters.vocabulary_size <<= 1;
              }
              else
              {
                // Disable the CTO algorithm
                l1a_l1s_com.speechreco_task.parameters.CTO_algorithm = FALSE;
              }

              *state = LOAD_MODEL;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case LOAD_MODEL:
          {
            // Initialize the background task stop command
            l1_srback_com.emergency_stop = FALSE;

            // Start to load the model to the API
            l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.index_counter;
            l1_send_sr_background_msg(L1_SRBACK_LOAD_MODEL_REQ);

            // Increase the index counter
            l1a_l1s_com.speechreco_task.parameters.index_counter++;

            *state = WAIT_MODEL_LOADED;

            // End process
            return;
          }
          break;

          case WAIT_MODEL_LOADED:
          {
            if (SignalCode == L1_SRBACK_LOAD_MODEL_CON)
            {
              // Start the DSP processing task
              l1a_l1s_com.speechreco_task.command.processing_start = TRUE;

              *state = WAIT_PROCESSING_STOP;
            }
            else
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;
            }

            // End process
            return;
          }
          break;

          case WAIT_PROCESSING_STOP:
          {
            if (SignalCode == L1_SR_PROCESSING_STOP_CON)
            {
              // The processing phase is good or not?
              if ( ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                *state = LOAD_MODEL;
              }
              else
              {
                // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
              #if (OP_RIV_AUDIO == 1)
                // Allocate the Riviera buffer
                mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                        sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                        (T_RVF_BUFFER **) (&p_message));

                // If insufficient resources, then report a memory error and abort.
                if (mb_status == RVF_RED)
                {
                  // the memory is insufficient to continue the non regression test
                  AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                  return;
                }

                // Fill the message ID
                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;

                // Fill the message parameter
                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id =
                  ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;

                // send the messsage to the audio entity
                rvf_send_msg (p_audio_gbl_var->addrId,
                              p_message);
              #else // OP_RIV_AUDIO
                // Allocate confirmation message...
                conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
                DEBUGMSG(status,NU_ALLOC_ERR)
                conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
                // File the message
                ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = ((T_L1_SR_PROCESSING_STOP_CON *)(msg->SigP))->error_id;

                #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                    l1_trace_message(conf_msg);
                #endif

                // Send the confirmation message...
                os_send_sig(conf_msg, MMI_QUEUE);
                DEBUGMSG(status,NU_SEND_QUEUE_ERR)
              #endif // OP_RIV_AUDIO

                *state = RESET;
              }
            }
            else
            if (SignalCode == L1_SR_RECO_STOP_IND)
            {
              // There is an error during the recognition?
              if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id == SC_NO_ERROR )
              {
                // The CTO algorithm is used?
                if (l1a_l1s_com.speechreco_task.parameters.CTO_algorithm)
                {
                  // The best word is odd?
                  if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index & 0x01 )
                  {
                    // Change the error to SC_CTO_WORD
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CTO_WORD;

                    // Forward the message in the MMI_SR_RECO_STOP_CON
                    l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);

                    *state = RESET;

                    // End process
                    return;
                  }
                  else
                  {
                    // Devided by 2 the 4 indexes of the best words in the message
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index         >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index  >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index   >>= 1;
                    ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index  >>= 1;
                  }
                }
                // Is it the good word?
                if ( ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index ==
                     l1a_l1s_com.speechreco_task.parameters.word_to_check )
                {
                  // Save the message informations in the l1a_l1s_com memory
                  l1a_l1s_com.speechreco_task.parameters.best_word_index        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.best_word_score        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.second_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.second_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->second_best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.third_best_word_index  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.third_best_word_score  = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->third_best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_index;
                  l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->fourth_best_word_score;
                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_level          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_level;
                  l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise          = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_db_noise;
                  l1a_l1s_com.speechreco_task.parameters.d_sr_model_size        = ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->d_sr_model_size;

                  // Reset the stop background task
                  l1_srback_com.emergency_stop = FALSE;

                  // Start the background task to save the model in the database
                  l1a_l1s_com.speechreco_task.parameters.word_index = l1a_l1s_com.speechreco_task.parameters.word_to_check;
                  l1a_l1s_com.speechreco_task.parameters.model_address = l1a_l1s_com.speechreco_task.parameters.model_temp_address;
                  l1_send_sr_background_msg(L1_SRBACK_SAVE_DATA_REQ);

                  *state = WAIT_SAVE_DONE;

                  // End process
                  return;
                }
                else
                {
                  // Change the error to SC_CHECK_ERROR
                  ((T_L1_SR_RECO_STOP_IND *)(msg->SigP))->error_id = SC_CHECK_ERROR;
                }
              }
              // Forward the message in the MMI_SR_RECO_STOP_CON
              l1a_audio_send_result(MMI_SR_UPDATE_CHECK_STOP_CON, msg, MMI_QUEUE);

              *state = RESET;
            }
            else
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop the L1S processing task
              l1a_l1s_com.speechreco_task.command.processing_stop = TRUE;

              *state = WAIT_L1S_STOP;

              // end process
              return;
            }
            else
            {
              // end process
              return;
            }
          }
          break;

          case WAIT_SAVE_DONE:
          {
            if (SignalCode == MMI_SR_UPDATE_CHECK_STOP_REQ)
            {
              // Stop immediatly the background task
              l1_srback_com.emergency_stop = TRUE;

              *state = WAIT_BACK_STOP;

              // End process
              return;
            }
            else
            if (SignalCode == L1_SRBACK_SAVE_DATA_CON)
            {
              // Send the MMI_SR_UPDATE_CHECK_STOP_CON message with an error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;
            #endif // OP_RIV_AUDIO

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->error_id                = SC_NO_ERROR;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_index         = l1a_l1s_com.speechreco_task.parameters.best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->best_word_score         = l1a_l1s_com.speechreco_task.parameters.best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_index  = l1a_l1s_com.speechreco_task.parameters.second_best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->second_best_word_score  = l1a_l1s_com.speechreco_task.parameters.second_best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_index   = l1a_l1s_com.speechreco_task.parameters.third_best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->third_best_word_score   = l1a_l1s_com.speechreco_task.parameters.third_best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_index  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_index;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->fourth_best_word_score  = l1a_l1s_com.speechreco_task.parameters.fourth_best_word_score;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_level           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_level;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_db_noise           = l1a_l1s_com.speechreco_task.parameters.d_sr_db_noise;
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(AUDIO_MSG))->d_sr_model_size         = l1a_l1s_com.speechreco_task.parameters.d_sr_model_size;

            #if (OP_RIV_AUDIO == 1)
              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_BACK_STOP:
          {
            if ( (SignalCode == L1_SRBACK_SAVE_DATA_CON)  ||
                 (SignalCode == L1_SRBACK_LOAD_MODEL_CON) ||
                 (SignalCode == L1_SRBACK_TEMP_SAVE_DATA_CON) )
            {
              // Send the message MMI_SR_UPDATE_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;

          case WAIT_L1S_STOP:
          {
            if ( (SignalCode == L1_SR_UPDATE_STOP_CON)     ||
                 (SignalCode == L1_SR_PROCESSING_STOP_CON) ||
                 (SignalCode == L1_SR_RECO_STOP_CON)       ||
                 (SignalCode == L1_SR_RECO_STOP_IND) )
            {
              // Send the message MMI_SR_UPDATE_CHECK_STOP_CON with an update error
            #if (OP_RIV_AUDIO == 1)
              // Allocate the Riviera buffer
              mb_status = rvf_get_buf ( p_audio_gbl_var->mb_internal,
                                      sizeof (T_MMI_SR_UPDATE_CHECK_STOP_CON),
                                      (T_RVF_BUFFER **) (&p_message));

              // If insufficient resources, then report a memory error and abort.
              if (mb_status == RVF_RED)
              {
                // the memory is insufficient to continue the non regression test
                AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
                return;
              }

              // Fill the message ID
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->header.msg_id = MMI_SR_UPDATE_CHECK_STOP_CON;

              // Fill the message parameter
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(p_message))->error_id                = SC_CHECK_ERROR;

              // send the messsage to the audio entity
              rvf_send_msg (p_audio_gbl_var->addrId,
                            p_message);
            #else // OP_RIV_AUDIO
              // Allocate confirmation message...
              conf_msg = os_alloc_sig(sizeof(T_MMI_SR_UPDATE_CHECK_STOP_CON));
              DEBUGMSG(status,NU_ALLOC_ERR)
              conf_msg->SignalCode = MMI_SR_UPDATE_CHECK_STOP_CON;

              //Fill the message
              ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(conf_msg->SigP))->error_id = SC_CHECK_ERROR;

              #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
                  l1_trace_message(conf_msg);
              #endif

              // Send the confirmation message...
              os_send_sig(conf_msg, MMI_QUEUE);
              DEBUGMSG(status,NU_SEND_QUEUE_ERR)
            #endif // OP_RIV_AUDIO

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)

      // Undefine message pointer macro.
      #undef MSG_AUDIO

    }

  #endif // L1_DYN_DSP_DWNLD
  #endif // SPEECH_RECO
  #if (AEC == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_aec_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* AEC feature.                                          */
    /*                                                       */
    /* Starting messages:        MMI_AEC_REQ                 */
    /*                                                       */
    /* Result messages (input):  none                        */
    /*                                                       */
    /* Result messages (output): MMI_AEC_CON                 */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
#if 0 //(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_aec_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET         = 0,
        WAIT_AEC_REQ  = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_AEC_CON  = 3
      };

      UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.aec_task.command.start = FALSE;

            *state = WAIT_AEC_REQ;
          }
          break;

          case WAIT_AEC_REQ:
          {
            if (SignalCode == MMI_AEC_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control;
            #if (L1_NEW_AEC)
              l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter;
              l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att;
              l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth;
              l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max;
              l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad;
              l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs;
              l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil;
              l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut;
            #endif

            #if (L1_ANR == 1)
              if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004)
              {
                // Noise suppression enabled: enable new ANR module for backward compatibility
                l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control

                // Enable L1S ANR task (default settings are used)
                l1a_l1s_com.anr_task.parameters.anr_enable       = 1;
                l1a_l1s_com.anr_task.parameters.min_gain         = 0x3313;
                l1a_l1s_com.anr_task.parameters.div_factor_shift = -2;
                l1a_l1s_com.anr_task.parameters.ns_level         = 1;
                l1a_l1s_com.anr_task.command.update              = TRUE;

                // Here we do not wait for L1S confirmation to have simple implementation
                // because the state machine already wait for AEC confirmation and
                // ANR confirmation would occur on the same frame
              }
              else
              {
                // Noise suppression disabled: disable ANR
                l1a_l1s_com.anr_task.parameters.anr_enable       = 0;
                l1a_l1s_com.anr_task.command.update              = TRUE;

                // Here we do not wait for L1S confirmation to have simple implementation
                // because the state machine already wait for AEC confirmation and
                // ANR confirmation would occur on the same frame
              }
            #endif
              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
              {
                // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when
                // activating the command at L1s level

                // Start the L1S AEC task
                l1a_l1s_com.aec_task.command.start = TRUE;

              *state = WAIT_AEC_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"AEC SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
            {
              // Start the L1S AEC task
              l1a_l1s_com.aec_task.command.start = TRUE;

              *state = WAIT_AEC_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"AEC SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
          return;
          }
          break;
          case WAIT_AEC_CON:
          {
            if (SignalCode == L1_AEC_CON)
            {
              // Send the AEC confirmation message
              l1a_audio_send_confirmation(MMI_AEC_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_aec_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET         = 0,
        WAIT_AEC_REQ  = 1,
        WAIT_AEC_CON  = 2
      };

      UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.aec_task.command.start = FALSE;

            *state = WAIT_AEC_REQ;
          }
          break;

          case WAIT_AEC_REQ:
          {
            if (SignalCode == MMI_AEC_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.aec_task.parameters.aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control;
            #if (L1_NEW_AEC)
              l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter;
              l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att;
              l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth;
              l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max;
              l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad;
              l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs;
              l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil;
              l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut;
            #endif

            #if (L1_ANR == 1)
              if (l1a_l1s_com.aec_task.parameters.aec_control & 0x0004)
              {
                // Noise suppression enabled: enable new ANR module for backward compatibility
                l1a_l1s_com.aec_task.parameters.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control

                // Enable L1S ANR task (default settings are used)
                l1a_l1s_com.anr_task.parameters.anr_enable       = 1;
                l1a_l1s_com.anr_task.parameters.min_gain         = 0x3313;
                l1a_l1s_com.anr_task.parameters.div_factor_shift = -2;
                l1a_l1s_com.anr_task.parameters.ns_level         = 1;
                l1a_l1s_com.anr_task.command.update              = TRUE;

                // Here we do not wait for L1S confirmation to have simple implementation
                // because the state machine already wait for AEC confirmation and
                // ANR confirmation would occur on the same frame
              }
              else
              {
                // Noise suppression disabled: disable ANR
                l1a_l1s_com.anr_task.parameters.anr_enable       = 0;
                l1a_l1s_com.anr_task.command.update              = TRUE;

                // Here we do not wait for L1S confirmation to have simple implementation
                // because the state machine already wait for AEC confirmation and
                // ANR confirmation would occur on the same frame
              }
            #endif

              // Start the L1S AEC task
              l1a_l1s_com.aec_task.command.start = TRUE;

              *state = WAIT_AEC_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_AEC_CON:
          {
            if (SignalCode == L1_AEC_CON)
            {
              // Send the AEC confirmation message
              l1a_audio_send_confirmation(MMI_AEC_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // L1_DYN_DSP_DWNLD == 1
  #endif // AEC

  #if (AEC == 2)
      /*-------------------------------------------------------*/
      /* l1a_mmi_aec_process()                                 */
      /*-------------------------------------------------------*/
      /*                                                       */
      /* Description:                                          */
      /* ------------                                          */
      /* This function is a state machine which handles the    */
      /* AEC feature.                                          */
      /*                                                       */
      /* Starting messages:        MMI_AEC_REQ                 */
      /*                                                       */
      /* Result messages (input):  none                        */
      /*                                                       */
      /* Result messages (output): MMI_AEC_CON                 */
      /*                                                       */
      /* Reset messages (input):   none                        */
      /*                                                       */
      /* Stop message (input):     none                        */
      /*                                                       */
      /* Stop message (output):    none                        */
      /*                                                       */
      /* Rem:                                                  */
      /* ----                                                  */
      /*                                                       */
      /*-------------------------------------------------------*/
  #if 0 //(L1_DYN_DSP_DWNLD == 1)
      void l1a_mmi_aec_process(xSignalHeaderRec *msg)
      {
        enum states
        {
          RESET         = 0,
          WAIT_AEC_REQ  = 1,
          WAIT_DYN_DWNLD = 2,
          WAIT_AEC_CON  = 3
        };

        UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
        UWORD32   SignalCode  = msg->SignalCode;

        while(1)
        {
          switch(*state)
          {
            case RESET:
            {
              // Reset the command
              l1a_l1s_com.aec_task.command.start = FALSE;

              *state = WAIT_AEC_REQ;
            }
            break;

            case WAIT_AEC_REQ:
            {
              if (SignalCode == MMI_AQI_AEC_REQ)
              {

                // Load the message into the l1a_l1s_com memory.
                l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control;

                if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP)
                {

                	l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter;
                	l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att;
                	l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth;
                	l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max;
                	l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad;
                	l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs;
                	l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil;
                	l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut;
                	l1a_l1s_com.aec_task.parameters.aec_mode        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode;
                	l1a_l1s_com.aec_task.parameters.mu			    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu;
                	l1a_l1s_com.aec_task.parameters.scale_input_ul  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul;
                	l1a_l1s_com.aec_task.parameters.scale_input_dl  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl;
                	l1a_l1s_com.aec_task.parameters.div_dmax		= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax;
                	l1a_l1s_com.aec_task.parameters.div_swap_good	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good;
                	l1a_l1s_com.aec_task.parameters.div_swap_bad	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad;
                	l1a_l1s_com.aec_task.parameters.block_init	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init;
//                	l1a_l1s_com.aec_task.parameters.block_size	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size;

				}

                if (l1a.dyn_dwnld.semaphore_vect[AEC_STATE_MACHINE] == GREEN)
                {
                  // WARNING: The following code must be duplicated in WAIT_DYN_DWNLD state when
                  // activating the command at L1s level

                  // Start the L1S AEC task
                  l1a_l1s_com.aec_task.command.start = TRUE;

                *state = WAIT_AEC_CON;
                }
                else
                {
                  *state = WAIT_DYN_DWNLD;

                  #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                    if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                    {
                      char str[30];
                      sprintf(str,"AEC SM blocked by DYN DWNLD\r\n");
                      #if(CODE_VERSION == SIMULATION)
                        trace_fct_simu_dyn_dwnld(str);
                      #else
                        rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                      #endif
                    }
                  #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
                }
              }

              // End process
              return;
            }
 // omaps00090550             break;
            case WAIT_DYN_DWNLD:
            {
              if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
              {
                // Start the L1S AEC task
                l1a_l1s_com.aec_task.command.start = TRUE;

                *state = WAIT_AEC_CON;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                    {
                      char str[30];
                      sprintf(str,"AEC SM un-blocked\r\n");
                      #if(CODE_VERSION == SIMULATION)
                        trace_fct_simu_dyn_dwnld(str);
                      #else
                        rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                      #endif
                    }
                 #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            return;
            }
 // omaps00090550          break;
            case WAIT_AEC_CON:
            {
              if (SignalCode == L1_AQI_AEC_CON)
              {
                // Send the AEC confirmation message
                l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE);

                    *state = RESET;
              }
              else
              {
                // End process
                return;
              }
            }
            break;
          } // switch
        } // while(1)
      }
  #else
      void l1a_mmi_aec_process(xSignalHeaderRec *msg)
      {
        enum states
        {
          RESET         = 0,
          WAIT_AEC_REQ  = 1,
          WAIT_AEC_CON  = 2
        };

        UWORD8    *state      = &l1a.state[L1A_AEC_STATE];
        UWORD32   SignalCode  = msg->SignalCode;

        while(1)
        {
          switch(*state)
          {
            case RESET:
            {
              // Reset the command
              l1a_l1s_com.aec_task.command.start = FALSE;

              *state = WAIT_AEC_REQ;
            }
            break;

            case WAIT_AEC_REQ:
            {
              if (SignalCode == MMI_AQI_AEC_REQ)
              {
                // Load the message into the l1a_l1s_com memory.
                l1a_l1s_com.aec_task.aec_control = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_control;

                if(l1a_l1s_com.aec_task.aec_control != L1_AQI_AEC_STOP)
                {

                	l1a_l1s_com.aec_task.parameters.cont_filter     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.cont_filter;
                	l1a_l1s_com.aec_task.parameters.granularity_att = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.granularity_att;
                	l1a_l1s_com.aec_task.parameters.coef_smooth     = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.coef_smooth;
                	l1a_l1s_com.aec_task.parameters.es_level_max    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.es_level_max;
                	l1a_l1s_com.aec_task.parameters.fact_vad        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_vad;
                	l1a_l1s_com.aec_task.parameters.thrs_abs        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.thrs_abs;
                	l1a_l1s_com.aec_task.parameters.fact_asd_fil    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_fil;
                	l1a_l1s_com.aec_task.parameters.fact_asd_mut    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.fact_asd_mut;
                	l1a_l1s_com.aec_task.parameters.aec_mode        = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.aec_mode;
                	l1a_l1s_com.aec_task.parameters.mu			    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.mu;
                	l1a_l1s_com.aec_task.parameters.scale_input_ul  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_ul;
                	l1a_l1s_com.aec_task.parameters.scale_input_dl  = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.scale_input_dl;
                	l1a_l1s_com.aec_task.parameters.div_dmax		= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_dmax;
                	l1a_l1s_com.aec_task.parameters.div_swap_good	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_good;
                	l1a_l1s_com.aec_task.parameters.div_swap_bad	= ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.div_swap_bad;
                	l1a_l1s_com.aec_task.parameters.block_init	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_init;
//                	l1a_l1s_com.aec_task.parameters.block_size	    = ((T_MMI_AQI_AEC_REQ *)(msg->SigP))->aec_parameters.block_size;

				}

              #if (L1_ANR == 1)
                if (l1a_l1s_com.aec_task.aec_control & 0x0004)
                {
                  // Noise suppression enabled: enable new ANR module for backward compatibility
                  l1a_l1s_com.aec_task.aec_control &= ~(0x0104); // Clear noise suppression bits in AEC control

                  // Enable L1S ANR task (default settings are used)
                  l1a_l1s_com.anr_task.parameters.anr_enable       = 1;
                  l1a_l1s_com.anr_task.parameters.min_gain         = 0x3313;
                  l1a_l1s_com.anr_task.parameters.div_factor_shift = -2;
                  l1a_l1s_com.anr_task.parameters.ns_level         = 1;
                  l1a_l1s_com.anr_task.command.update              = TRUE;

                  // Here we do not wait for L1S confirmation to have simple implementation
                  // because the state machine already wait for AEC confirmation and
                  // ANR confirmation would occur on the same frame
                }
                else
                {
                  // Noise suppression disabled: disable ANR
                  l1a_l1s_com.anr_task.parameters.anr_enable       = 0;
                  l1a_l1s_com.anr_task.command.update              = TRUE;

                  // Here we do not wait for L1S confirmation to have simple implementation
                  // because the state machine already wait for AEC confirmation and
                  // ANR confirmation would occur on the same frame
                }
              #endif

                // Start the L1S AEC task
                l1a_l1s_com.aec_task.command.start = TRUE;

                *state = WAIT_AEC_CON;
              }

              // End process
              return;
            }
            break;

            case WAIT_AEC_CON:
            {
              if (SignalCode == L1_AQI_AEC_CON)
              {
                // Send the AEC confirmation message
                l1a_audio_send_result(MMI_AQI_AEC_CON, msg, MMI_QUEUE);

                    *state = RESET;
              }
              else
              {
                // End process
                return;
              }
            }
            break;
          } // switch
        } // while(1)
      }
    #endif // L1_DYN_DSP_DWNLD == 1
    #endif // AEC == 2


  #if (FIR)
    /*-------------------------------------------------------*/
    /* l1a_mmi_fir_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* FIR feature.                                          */
    /*                                                       */
    /* Starting messages:        MMI_AUDIO_FIR_REQ           */
    /*                                                       */
    /* Result messages (input):  none                        */
    /*                                                       */
    /* Result messages (output): MMI_AUDIO_FIR_CON           */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_fir_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET         = 0,
        WAIT_FIR_REQ  = 1,
        WAIT_FIR_CON  = 2
      };

      UWORD8    *state      = &l1a.state[L1A_FIR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.fir_task.command.start = FALSE;

            *state = WAIT_FIR_REQ;
          }
          break;

          case WAIT_FIR_REQ:
          {
            if (SignalCode == MMI_AUDIO_FIR_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.fir_task.parameters.fir_loop = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_loop;
              l1a_l1s_com.fir_task.parameters.update_fir = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->update_fir;
              l1a_l1s_com.fir_task.parameters.fir_ul_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_ul_coefficient;

              // we update FIR coefficients even if L1_IIR==1 because in case of loop mode
              // this is the old FIR API that is used
              l1a_l1s_com.fir_task.parameters.fir_dl_coefficient = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient;

              #if (L1_IIR == 1)
                if (l1a_l1s_com.fir_task.parameters.update_fir & DL_FIR)
                {
                  // FIR DL update enabled: enable new IIR/DL module for backward compatibility

                  // Enable L1S IIR task
                  // Settings tuned to have same behavior as DL FIR
                  l1a_l1s_com.iir_task.parameters.iir_enable          = 1; // Filter always enabled
                  l1a_l1s_com.iir_task.parameters.nb_iir_blocks       = 0; // IIR part disabled
                  l1a_l1s_com.iir_task.parameters.iir_coefs           = 0;
                  l1a_l1s_com.iir_task.parameters.nb_fir_coefs        = 0x1f;
                  l1a_l1s_com.iir_task.parameters.fir_coefs           = (WORD16 *)((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient;
                  l1a_l1s_com.iir_task.parameters.input_scaling       = 0;
                  l1a_l1s_com.iir_task.parameters.fir_scaling         = 0;
                  l1a_l1s_com.iir_task.parameters.input_gain_scaling  = 0;
                  l1a_l1s_com.iir_task.parameters.output_gain_scaling = 0;
                  l1a_l1s_com.iir_task.parameters.output_gain         = 0xffff; // Used for IIR using in FIR mode
                  l1a_l1s_com.iir_task.parameters.feedback            = 0;
                  l1a_l1s_com.iir_task.command.update                 = TRUE;

                  // Here we do not wait for L1S confirmation to have simple implementation
                  // because the state machine already wait for FIR confirmation and
                  // there is no chance that upper layer frees the memory used to store
                  // DL coefficients before L1S copy them into API
                }
              #endif

              // Start the L1S FIR task
              l1a_l1s_com.fir_task.command.start = TRUE;

              *state = WAIT_FIR_CON;
            }

            // End process
            return;
          }
 // omaps00090550        break;

          case WAIT_FIR_CON:
          {
            if (SignalCode == L1_AUDIO_FIR_CON)
            {
              // Send the FIR confirmation message
              l1a_audio_send_confirmation(MMI_AUDIO_FIR_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // FIR
  #if (AUDIO_MODE)
    /*-------------------------------------------------------*/
    /* l1a_mmi_audio_mode_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* audio mode features.                                  */
    /*                                                       */
    /* Starting messages:        MMI_AUDIO_MODE_REQ          */
    /*                                                       */
    /* Result messages (input):  none                        */
    /*                                                       */
    /* Result messages (output): MMI_AUDIO_MODE_CON          */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_audio_mode_process (xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET                = 0,
        WAIT_AUDIO_MODE_REQ  = 1,
        WAIT_AUDIO_MODE_CON  = 2
      };

      UWORD8    *state      = &l1a.state[L1A_AUDIO_MODE_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.audio_mode_task.command.start = FALSE;

            *state = WAIT_AUDIO_MODE_REQ;
          }
          break;

          case WAIT_AUDIO_MODE_REQ:
          {
            if (SignalCode == MMI_AUDIO_MODE_REQ)
            {
              switch (((T_MMI_AUDIO_MODE *)(msg->SigP))->audio_mode)
              {
                case GSM_ONLY:
                {
                  // Set the GSM only mode
                  l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_GSM_ONLY;
                  break;
                }
                case BT_CORDLESS:
                {
                  // Set the bluetooth cordless mode
                  l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_CORDLESS;
                  break;
                }
                case BT_HEADSET:
                {
                  // Set the bluetooth headset mode
                  l1a_l1s_com.audio_mode_task.parameters.audio_mode = B_BT_HEADSET;
                  break;
                }
                default :
                {
                  break;
                }
              } // switch

              // Start the L1S AUDIO MODE task
              l1a_l1s_com.audio_mode_task.command.start = TRUE;

              *state = WAIT_AUDIO_MODE_CON;
            }

            // End process
            return;
          }
 // omaps00090550          break;

          case WAIT_AUDIO_MODE_CON:
          {
            if (SignalCode == L1_AUDIO_MODE_CON)
            {
              // Send the AUDIO MODE confirmation message
              l1a_audio_send_confirmation(MMI_AUDIO_MODE_CON);

              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // AUDIO_MODE
  #if (MELODY_E2)
  #if(L1_DYN_DSP_DWNLD==1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_melody0_e2_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* melody 0 format E2 feature.                           */
    /*                                                       */
    /* Starting messages:        MMI_MELODY0_E2_START_REQ    */
    /*                                                       */
    /* Result messages (input):  L1_MELODY0_E2_START_CON     */
    /*                                                       */
    /* Result messages (output): MMI_MELODY0_E2_START_CON    */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
    /*                           L1_MELODY0_E2_STOP_CON      */
    /*                                                       */
    /* Stop message (output):    MMI_MELODY0_E2_STOP_CON     */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        M0_RESET                  = 0,
        M0_WAIT_START_REQ         = 1,
        WAIT_DYN_DWNLD = 2,
        M0_WAIT_LOAD_INSTRUMENT   = 3,
        M0_WAIT_STOP              = 4,
        M0_WAIT_UNLOAD_INSTRUMENT = 5
      };

      UWORD8    *state      = &l1a.state[L1A_MELODY0_E2_STATE], i;
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case M0_RESET:
          {
            // Reset the commands:
            l1a_l1s_com.melody0_e2_task.command.start = FALSE;
            l1a_l1s_com.melody0_e2_task.command.stop  = FALSE;

            *state = M0_WAIT_START_REQ;
          }
          break;

          case M0_WAIT_START_REQ:
          {
            if (SignalCode == MMI_MELODY0_E2_START_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.melody0_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;

              if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE]==GREEN)
              {

                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
                // Disable trace DSP upon E2 MELODY activation
                l1_disable_dsp_trace();
#endif
                // Reset the emergency flag
                l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE;

                // Initialize the buffer parameters
                l1a_l1s_com.melody0_e2_task.parameters.ptr_buf        = NULL;
                l1a_l1s_com.melody0_e2_task.parameters.buffer_size    = 0;
                l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                 &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                 l1a_l1s_com.melody0_e2_task.parameters.session_id);

                // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
                l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1;

                // Jump the NumberOfOscillator parameter
                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));

                // Read the Header of the melody description in order to download the time factor
                // clean the MSB of the global time factor register
                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));
                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;


                // Find the number of insturment of the melody (jump the header memory)
                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument));

                for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++)
                {
                  // find the beginning of the melody description (after the header field)
                  // and put it in the buf_ptr buffer
                  l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                     &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                     (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                     1,
                                                                                     &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]));
                }

                // Initialize the size (in byte unit) of the header
                l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument;

                // download the instrument
                l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0);

                // Send the start confirmation message
                l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON);

                *state = M0_WAIT_LOAD_INSTRUMENT;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"E20 SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN))
            {
              // Reset the emergency flag
              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE;

              // Initialize the buffer parameters
              l1a_l1s_com.melody0_e2_task.parameters.ptr_buf        = NULL;
              l1a_l1s_com.melody0_e2_task.parameters.buffer_size    = 0;
              l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                 &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                 l1a_l1s_com.melody0_e2_task.parameters.session_id);

              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
              l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1;

              // Jump the NumberOfOscillator parameter
              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));

              // Read the Header of the melody description in order to download the time factor
              // clean the MSB of the global time factor register
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;


              // Find the number of insturment of the melody (jump the header memory)
              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument));

              for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++)
              {
                // find the beginning of the melody description (after the header field)
                // and put it in the buf_ptr buffer
                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                     &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                     (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                     1,
                                                                                     &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]));
              }

              // Initialize the size (in byte unit) of the header
              l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument;

              // download the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON);

              *state = M0_WAIT_LOAD_INSTRUMENT;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"E20 SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
          break;
          case M0_WAIT_LOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
              {
                // The load instrument confirmation message is for the melody 0
                if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop)
                {
                  // Unload the instrument
                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);

                  *state = M0_WAIT_UNLOAD_INSTRUMENT;

                }
                else
                {
                  // Start to play the melody0
                  l1a_l1s_com.melody0_e2_task.command.start = TRUE;

                  *state = M0_WAIT_STOP;
                }
              }
            }
            else
            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
            {
              // Set the emergency flag
              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M0_WAIT_STOP:
          {
            if (SignalCode == L1_MELODY0_E2_STOP_CON)
            {
              // Unload the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);

              *state = M0_WAIT_UNLOAD_INSTRUMENT;
            }
            else
            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
            {
              // Stop the melody 0 L1S task:
              l1a_l1s_com.melody0_e2_task.command.stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M0_WAIT_UNLOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
              {
                // Send the stop confirmation message
                l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON);
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
                // Enable trace DSP upon E2 MELODY deactivation
                l1_enable_dsp_trace();
#endif

                *state = M0_RESET;
              }
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_melody1_e2_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* melody 1 format E2 feature.                           */
    /*                                                       */
    /* Starting messages:        MMI_MELODY1_E2_START_REQ    */
    /*                                                       */
    /* Result messages (input):  L1_MELODY1_E2_START_CON     */
    /*                                                       */
    /* Result messages (output): MMI_MELODY1_E2_START_CON    */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
    /*                           L1_MELODY1_E2_STOP_CON      */
    /*                                                       */
    /* Stop message (output):    MMI_MELODY1_E2_STOP_CON     */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        M1_RESET                  = 0,
        M1_WAIT_START_REQ         = 1,
        WAIT_DYN_DWNLD = 2,
        M1_WAIT_LOAD_INSTRUMENT   = 3,
        M1_WAIT_STOP              = 4,
        M1_WAIT_UNLOAD_INSTRUMENT = 5
      };

      UWORD8    *state      = &l1a.state[L1A_MELODY1_E2_STATE], i;
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case M1_RESET:
          {
            // Reset the commands:
            l1a_l1s_com.melody1_e2_task.command.start = FALSE;
            l1a_l1s_com.melody1_e2_task.command.stop  = FALSE;

            *state = M1_WAIT_START_REQ;
          }
          break;

          case M1_WAIT_START_REQ:
          {
            if (SignalCode == MMI_MELODY1_E2_START_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.melody1_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;

              if(l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN)
              {
                // WARNING: code below must be duplicated in WAIT_DYN_DWNLD state
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
                // Disable trace DSP upon E2 MELODY activation
                l1_disable_dsp_trace();
#endif
                // Reset the emergency flag
                l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE;

                // Initialize the buffer parameters
                l1a_l1s_com.melody1_e2_task.parameters.ptr_buf        = NULL;
                l1a_l1s_com.melody1_e2_task.parameters.buffer_size    = 0;
                l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                 &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                 l1a_l1s_com.melody1_e2_task.parameters.session_id);

                // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
                l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1;

                // Jump the NumberOfOscillator parameter
                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));

                // Read the Header of the melody description in order to download the time factor
                // clean the MSB of the global time factor register
                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));
                l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;


                // Find the number of insturment of the melody (jump the header memory)
                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument));

                for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++)
                {
                  // find the beginning of the melody description (after the header field)
                  // and put it in the buf_ptr buffer
                  l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                     &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                     (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                     1,
                                                                                     &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]));
                }

                // Initialize the size (in byte unit) of the header
                l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument;

                // download the instrument
                l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1);

                // Send the start confirmation message
                l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON);

                *state = M1_WAIT_LOAD_INSTRUMENT;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"E21 SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }
            // End process
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if((SignalCode == API_L1_DYN_DWNLD_FINISHED) && (l1a.dyn_dwnld.semaphore_vect[E2_STATE_MACHINE] == GREEN))
            {
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
              // Disable trace DSP upon E2 MELODY activation
              l1_disable_dsp_trace();
#endif
              // Reset the emergency flag
              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE;

              // Initialize the buffer parameters
              l1a_l1s_com.melody1_e2_task.parameters.ptr_buf        = NULL;
              l1a_l1s_com.melody1_e2_task.parameters.buffer_size    = 0;
              l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                 &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                 l1a_l1s_com.melody1_e2_task.parameters.session_id);

              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
              l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1;

              // Jump the NumberOfOscillator parameter
              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));

              // Read the Header of the melody description in order to download the time factor
              // clean the MSB of the global time factor register
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;


              // Find the number of insturment of the melody (jump the header memory)
              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument));

              for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++)
              {
                // find the beginning of the melody description (after the header field)
                // and put it in the buf_ptr buffer
                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                     &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                     (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                     1,
                                                                                     &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]));
              }

              // Initialize the size (in byte unit) of the header
              l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument;

              // download the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON);

              *state = M1_WAIT_LOAD_INSTRUMENT;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"E21 SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
          break;
          case M1_WAIT_LOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
              {
                // The load instrument confirmation message is for the melody 1
                if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop)
                {
                  // Unload the instrument
                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);

                  *state = M1_WAIT_UNLOAD_INSTRUMENT;

                }
                else
                {
                  // Start to play the melody1
                  l1a_l1s_com.melody1_e2_task.command.start = TRUE;

                  *state = M1_WAIT_STOP;
                }
              }
            }
            else
            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
            {
              // Set the emergency flag
              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M1_WAIT_STOP:
          {
            if (SignalCode == L1_MELODY1_E2_STOP_CON)
            {
              // Unload the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);

              *state = M1_WAIT_UNLOAD_INSTRUMENT;
            }
            else
            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
            {
              // Stop the melody 0 L1S task:
              l1a_l1s_com.melody1_e2_task.command.stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M1_WAIT_UNLOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
              {
                // Send the stop confirmation message
                l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON);

                *state = M1_RESET;
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
                // Enable trace DSP upon E2 MELODY deactivation
                l1_enable_dsp_trace();
#endif
              }
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }

#else // L1_DYN_DSP_DWNLD = 0

    /*-------------------------------------------------------*/
    /* l1a_mmi_melody0_e2_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* melody 0 format E2 feature.                           */
    /*                                                       */
    /* Starting messages:        MMI_MELODY0_E2_START_REQ    */
    /*                                                       */
    /* Result messages (input):  L1_MELODY0_E2_START_CON     */
    /*                                                       */
    /* Result messages (output): MMI_MELODY0_E2_START_CON    */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
    /*                           L1_MELODY0_E2_STOP_CON      */
    /*                                                       */
    /* Stop message (output):    MMI_MELODY0_E2_STOP_CON     */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/

    void l1a_mmi_melody0_e2_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        M0_RESET                  = 0,
        M0_WAIT_START_REQ         = 1,
        M0_WAIT_LOAD_INSTRUMENT   = 2,
        M0_WAIT_STOP              = 3,
        M0_WAIT_UNLOAD_INSTRUMENT = 4
      };

      UWORD8    *state      = &l1a.state[L1A_MELODY0_E2_STATE], i;
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case M0_RESET:
          {
            // Reset the commands:
            l1a_l1s_com.melody0_e2_task.command.start = FALSE;
            l1a_l1s_com.melody0_e2_task.command.stop  = FALSE;

            *state = M0_WAIT_START_REQ;
          }
          break;

          case M0_WAIT_START_REQ:
          {
            if (SignalCode == MMI_MELODY0_E2_START_REQ)
            {
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
              // Disable trace DSP upon E2 MELODY activation
              l1_disable_dsp_trace();
#endif
              // Download the parameters from the message:
              l1a_l1s_com.melody0_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.melody0_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;

              // Reset the emergency flag
              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = FALSE;

              // Initialize the buffer parameters
              l1a_l1s_com.melody0_e2_task.parameters.ptr_buf        = NULL;
              l1a_l1s_com.melody0_e2_task.parameters.buffer_size    = 0;
              l1a_l1s_com.melody0_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                 &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                 l1a_l1s_com.melody0_e2_task.parameters.session_id);

              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
              l1a_l1s_com.melody0_e2_task.parameters.buffer_size <<= 1;

              // Jump the NumberOfOscillator parameter
              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));

              // Read the Header of the melody description in order to download the time factor
              // clean the MSB of the global time factor register
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;


              // Find the number of insturment of the melody (jump the header memory)
              l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument));

              for (i=0; i<(l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument); i++)
              {
                // find the beginning of the melody description (after the header field)
                // and put it in the buf_ptr buffer
                l1a_l1s_com.melody0_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody0_e2_task.parameters.session_id,
                                                                                     &l1a_l1s_com.melody0_e2_task.parameters.buffer_size,
                                                                                     (UWORD8 **)&l1a_l1s_com.melody0_e2_task.parameters.ptr_buf,
                                                                                     1,
                                                                                     &(l1a_l1s_com.melody0_e2_task.parameters.waves_table_id[i]));
              }

              // Initialize the size (in byte unit) of the header
              l1a_l1s_com.melody0_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody0_e2_task.parameters.number_of_instrument;

              // download the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 0);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_MELODY0_E2_START_CON);

              *state = M0_WAIT_LOAD_INSTRUMENT;
            }

            // End process
            return;
          }
          break;

          case M0_WAIT_LOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
              {
                // The load instrument confirmation message is for the melody 0
                if (l1a_l1s_com.melody0_e2_task.parameters.emergency_stop)
                {
                  // Unload the instrument
                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);

                  *state = M0_WAIT_UNLOAD_INSTRUMENT;

                }
                else
                {
                  // Start to play the melody0
                  l1a_l1s_com.melody0_e2_task.command.start = TRUE;

                  *state = M0_WAIT_STOP;
                }
              }
            }
            else
            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
            {
              // Set the emergency flag
              l1a_l1s_com.melody0_e2_task.parameters.emergency_stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M0_WAIT_STOP:
          {
            if (SignalCode == L1_MELODY0_E2_STOP_CON)
            {
              // Unload the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 0);

              *state = M0_WAIT_UNLOAD_INSTRUMENT;
            }
            else
            if (SignalCode == MMI_MELODY0_E2_STOP_REQ)
            {
              // Stop the melody 0 L1S task:
              l1a_l1s_com.melody0_e2_task.command.stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M0_WAIT_UNLOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 0 )
              {
                // Send the stop confirmation message
                l1a_audio_send_confirmation(MMI_MELODY0_E2_STOP_CON);

                *state = M0_RESET;
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
                // Enable trace DSP upon E2 MELODY deactivation
                l1_enable_dsp_trace();
#endif
              }
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }

    /*-------------------------------------------------------*/
    /* l1a_mmi_melody1_e2_process()                          */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* melody 1 format E2 feature.                           */
    /*                                                       */
    /* Starting messages:        MMI_MELODY1_E2_START_REQ    */
    /*                                                       */
    /* Result messages (input):  L1_MELODY1_E2_START_CON     */
    /*                                                       */
    /* Result messages (output): MMI_MELODY1_E2_START_CON    */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_MELDOY0_E2_STOP_REQ     */
    /*                           L1_MELODY1_E2_STOP_CON      */
    /*                                                       */
    /* Stop message (output):    MMI_MELODY1_E2_STOP_CON     */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_melody1_e2_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        M1_RESET                  = 0,
        M1_WAIT_START_REQ         = 1,
        M1_WAIT_LOAD_INSTRUMENT   = 2,
        M1_WAIT_STOP              = 3,
        M1_WAIT_UNLOAD_INSTRUMENT = 4
      };

      UWORD8    *state      = &l1a.state[L1A_MELODY1_E2_STATE], i;
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case M1_RESET:
          {
            // Reset the commands:
            l1a_l1s_com.melody1_e2_task.command.start = FALSE;
            l1a_l1s_com.melody1_e2_task.command.stop  = FALSE;

            *state = M1_WAIT_START_REQ;
          }
          break;

          case M1_WAIT_START_REQ:
          {
            if (SignalCode == MMI_MELODY1_E2_START_REQ)
            {
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
            // Disable trace DSP upon E2 MELODY activation
            l1_disable_dsp_trace();
#endif

              // Download the parameters from the message:
              l1a_l1s_com.melody1_e2_task.parameters.session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id;
              l1a_l1s_com.melody1_e2_task.parameters.loopback   = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;

              // Reset the emergency flag
              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = FALSE;

              // Initialize the buffer parameters
              l1a_l1s_com.melody1_e2_task.parameters.ptr_buf        = NULL;
              l1a_l1s_com.melody1_e2_task.parameters.buffer_size    = 0;
              l1a_l1s_com.melody1_e2_task.parameters.error_id = Cust_get_pointer((UWORD16 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                 &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                 l1a_l1s_com.melody1_e2_task.parameters.session_id);

              // Convert the buffer size in bytes unit because the E2 melody is defined in byte unit
              l1a_l1s_com.melody1_e2_task.parameters.buffer_size <<= 1;

              // Jump the NumberOfOscillator parameter
              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));

              // Read the Header of the melody description in order to download the time factor
              // clean the MSB of the global time factor register
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor &= 0x00FF;
              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   (UWORD8 *)(&(i)));
              l1s_dsp_com.dsp_ndb_ptr->d_melody_e2_globaltimefactor = i;


              // Find the number of insturment of the melody (jump the header memory)
              l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                   &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                   (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                   1,
                                                                                   &(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument));

              for (i=0; i<(l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument); i++)
              {
                // find the beginning of the melody description (after the header field)
                // and put it in the buf_ptr buffer
                l1a_l1s_com.melody1_e2_task.parameters.error_id = copy_byte_data_from_buffer (l1a_l1s_com.melody1_e2_task.parameters.session_id,
                                                                                     &l1a_l1s_com.melody1_e2_task.parameters.buffer_size,
                                                                                     (UWORD8 **)&l1a_l1s_com.melody1_e2_task.parameters.ptr_buf,
                                                                                     1,
                                                                                     &(l1a_l1s_com.melody1_e2_task.parameters.waves_table_id[i]));
              }

              // Initialize the size (in byte unit) of the header
              l1a_l1s_com.melody1_e2_task.parameters.header_size = 3 + l1a_l1s_com.melody1_e2_task.parameters.number_of_instrument;

              // download the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ, 1);

              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_MELODY1_E2_START_CON);

              *state = M1_WAIT_LOAD_INSTRUMENT;
            }

            // End process
            return;
          }
          break;

          case M1_WAIT_LOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
              {
                // The load instrument confirmation message is for the melody 1
                if (l1a_l1s_com.melody1_e2_task.parameters.emergency_stop)
                {
                  // Unload the instrument
                  l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);

                  *state = M1_WAIT_UNLOAD_INSTRUMENT;

                }
                else
                {
                  // Start to play the melody1
                  l1a_l1s_com.melody1_e2_task.command.start = TRUE;

                  *state = M1_WAIT_STOP;
                }
              }
            }
            else
            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
            {
              // Set the emergency flag
              l1a_l1s_com.melody1_e2_task.parameters.emergency_stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M1_WAIT_STOP:
          {
            if (SignalCode == L1_MELODY1_E2_STOP_CON)
            {
              // Unload the instrument
              l1_send_melody_e2_background_msg(L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ, 1);

              *state = M1_WAIT_UNLOAD_INSTRUMENT;
            }
            else
            if (SignalCode == MMI_MELODY1_E2_STOP_REQ)
            {
              // Stop the melody 0 L1S task:
              l1a_l1s_com.melody1_e2_task.command.stop = TRUE;
            }

            // End process
            return;
          }
          break;

          case M1_WAIT_UNLOAD_INSTRUMENT:
          {
            if (SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)
            {
              if ( ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id == 1 )
              {
                // Send the stop confirmation message
                l1a_audio_send_confirmation(MMI_MELODY1_E2_STOP_CON);

                *state = M1_RESET;
#if 0 //((TRACE_TYPE==1) || (TRACE_TYPE == 4))
                // Enable trace DSP upon E2 MELODY deactivation
                l1_enable_dsp_trace();
#endif
              }
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // L1_DYN_DSP_DWNLD
  #endif // MELODY_E2

  #if (L1_CPORT == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_cport_process()                               */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* cport configuration feature.                          */
    /*                                                       */
    /* Starting messages:        MMI_CPORT_CONFIGURE_REQ     */
    /*                                                       */
    /* Result messages (input):  L1_CPORT_CONFIGURE_CON      */
    /*                                                       */
    /* Result messages (output): MMI_CPORT_CONFIGURE_CON     */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_cport_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2
      };

      UWORD8    *state      = &l1a.state[L1A_CPORT_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.cport_task.command.start = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_CPORT_CONFIGURE_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.cport_task.parameters.configuration = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->configuration;
              l1a_l1s_com.cport_task.parameters.cpcfr1        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr1;
              l1a_l1s_com.cport_task.parameters.cpcfr2        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr2;
              l1a_l1s_com.cport_task.parameters.cpcfr3        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr3;
              l1a_l1s_com.cport_task.parameters.cpcfr4        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpcfr4;
              l1a_l1s_com.cport_task.parameters.cptctl        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptctl;
              l1a_l1s_com.cport_task.parameters.cptdat        = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptdat;
              l1a_l1s_com.cport_task.parameters.cpttaddr      = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cpttaddr;
              l1a_l1s_com.cport_task.parameters.cptvs         = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->cptvs;
              l1a_l1s_com.cport_task.parameters.ctrl          = ((T_MMI_CPORT_CONFIGURE_REQ *)(msg->SigP))->ctrl;

              // Start the L1S cport task
              l1a_l1s_com.cport_task.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_CPORT_CONFIGURE_CON)
            {
              // Forward the stop confirmation message
              l1a_audio_send_result(MMI_CPORT_CONFIGURE_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
          break;

        } // switch
      } // while(1)
    }
  #endif // L1_CPORT == 1

  #if (L1_EXTERNAL_AUDIO_VOICE_ONOFF == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_audio_onoff_process()                         */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* audio on/off feature.                                 */
    /*                                                       */
    /* Starting messages:        MMI_AUDIO_ONOFF_REQ         */
    /*                                                       */
    /* Result messages (input):  L1_AUDIO_ONOFF_CON          */
    /*                                                       */
    /* Result messages (output): MMI_AUDIO_ONOFF_CON         */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2
      };

      UWORD8    *state      = &l1a.state[L1A_AUDIO_ONOFF_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.audio_onoff_task.command.start = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_AUDIO_ONOFF_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.audio_onoff_task.parameters.onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->onoff_value;

              // Start the L1S keybeep task
              l1a_l1s_com.audio_onoff_task.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_AUDIO_ONOFF_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
  #endif

  #if (L1_EXT_MCU_AUDIO_VOICE_ONOFF == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_audio_onoff_process()                         */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* audio on/off feature.                                 */
    /*                                                       */
    /* Starting messages:        MMI_AUDIO_ONOFF_REQ         */
    /*                                                       */
    /* Result messages (input):  L1_AUDIO_ONOFF_CON          */
    /*                                                       */
    /* Result messages (output): MMI_AUDIO_ONOFF_CON         */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_audio_onoff_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2
      };

      UWORD8    *state      = &l1a.state[L1A_AUDIO_ONOFF_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.audio_onoff_task.command.start = FALSE;

            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_AUDIO_ONOFF_REQ)
            {
              // Download the parameters from the message:
              l1a_l1s_com.audio_onoff_task.parameters.vul_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vul_onoff_value;
              l1a_l1s_com.audio_onoff_task.parameters.vdl_onoff_value = ((T_MMI_AUDIO_ONOFF_REQ *)(msg->SigP))->vdl_onoff_value;
              // Start the L1S keybeep task
              l1a_l1s_com.audio_onoff_task.command.start = TRUE;

              *state = WAIT_START_CON;
            }

            // End process
            return;
          }
 // omaps00090550        break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_AUDIO_ONOFF_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_AUDIO_ONOFF_CON);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550      break;
        } // switch
      } // while(1)
    }
  #endif


  #if (L1_EXT_AUDIO_MGT == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_ext_audio_mgt_process()                       */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* external audio management feature.                    */
    /*                                                       */
    /* Starting messages:        MMI_EXT_AUDIO_MGT_START_REQ */
    /*                                                       */
    /* Result messages (input):  L1_STEREOPATH_DRV_START_CON */
    /*                                                       */
    /* Result messages (output): MMI_EXT_AUDIO_MGT_START_CON */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     MMI_EXT_AUDIO_MGT_STOP_REQ  */
    /*                           L1_STEREOPATH_DRV_STOP_CON  */
    /*                                                       */
    /* Stop message (output):    MMI_EXT_AUDIO_MGT_STOP_CON  */
    /*                                                       */
    /* Rem:                                                  */
    /* ----                                                  */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_ext_audio_mgt_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_START_REQ    = 1,
        WAIT_START_CON    = 2,
        WAIT_STOP         = 3
      };

      UWORD8    *state      = &l1a.state[L1A_EXT_AUDIO_MGT_STATE];
      UWORD32   SignalCode  = msg->SignalCode;
      UWORD8 sample_rate;
      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
#if(L1_BT_AUDIO ==1)
	      midi_task_running=FALSE;
#endif
            *state = WAIT_START_REQ;
          }
          break;

          case WAIT_START_REQ:
          {
            if (SignalCode == MMI_EXT_AUDIO_MGT_START_REQ)
            {
              // save global variable
              l1s.ext_audio_mgt.session_id = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->session_id;
		#if(L1_BT_AUDIO ==1)
		  l1_audio_bt_init(AUDIO_EXT_MIDI_BUFFER_SIZE);
		  if(bt_audio.connected_status==TRUE)
            	  {
			bt_audio.pcmconfig.bitsPerSample=16;
			bt_audio.pcmconfig.numChannels =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo+1;
	              sample_rate   =((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency;
			bt_audio.pcmconfig.sampleRate   =l1_ext_audio_get_frequencyrate(sample_rate);
			bt_audio.audio_configure_callback(&bt_audio.pcmconfig);
            	  }	
		 #endif
	if(bt_audio.connected_status==FALSE)
     	  {
              // Download the stereopath description.
              l1a_l1s_com.stereopath_drv_task.parameters.sampling_frequency    = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->sampling_frequency;
              l1a_l1s_com.stereopath_drv_task.parameters.DMA_allocation        = AUDIO_SP_DMA_ALLOC_MCU;
              l1a_l1s_com.stereopath_drv_task.parameters.DMA_int_callback_fct  = l1_ext_audio_mgt_dma_handler;
              l1a_l1s_com.stereopath_drv_task.parameters.DMA_channel_number    = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->DMA_channel_number;
              l1a_l1s_com.stereopath_drv_task.parameters.data_type             = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->data_type;
              l1a_l1s_com.stereopath_drv_task.parameters.source_port           = AUDIO_SP_SOURCE_IMIF;
              l1a_l1s_com.stereopath_drv_task.parameters.source_buffer_address = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->source_buffer_address;
              l1a_l1s_com.stereopath_drv_task.parameters.element_number        = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->element_number;
              l1a_l1s_com.stereopath_drv_task.parameters.frame_number          = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->frame_number;
              l1a_l1s_com.stereopath_drv_task.parameters.mono_stereo           = ((T_MMI_EXT_AUDIO_MGT_START_REQ *)(msg->SigP))->mono_stereo;
              l1a_l1s_com.stereopath_drv_task.parameters.feature_identifier    = AUDIO_SP_EXT_AUDIO_ID;

              // Start the L1S stereopath task
              l1a_l1s_com.stereopath_drv_task.command.start = TRUE;
#if(L1_BT_AUDIO ==1)
              midi_task_running=TRUE;
#endif

              *state = WAIT_START_CON;
            }
	   else
	  {
 		  l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON);

              *state = WAIT_STOP;
	   }
            // End process
            return;
          }
          }
 // omaps00090550         break;

          case WAIT_START_CON:
          {
            if (SignalCode == L1_STEREOPATH_DRV_START_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_START_CON);

              *state = WAIT_STOP;
            }

            // End process
            return;
          }
 // omaps00090550        break;

          case WAIT_STOP:
          {
            if (SignalCode == MMI_EXT_AUDIO_MGT_STOP_REQ)
            {
		if(bt_audio.connected_status==TRUE)
     	  	{

	       // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON);
	        midi_task_running=FALSE;
	       *state = RESET;
		}
		else
		{
              // Stop the L1S stereopath task
              l1a_l1s_com.stereopath_drv_task.command.stop = TRUE;

              // End process
              return;
            }
            }

            if (SignalCode == L1_STEREOPATH_DRV_STOP_CON)
            {

              // Send the stop confirmation message
              l1a_audio_send_confirmation(MMI_EXT_AUDIO_MGT_STOP_CON);
	      #if(L1_BT_AUDIO ==1)
              midi_task_running=FALSE;
	     #endif
              *state = RESET;
            }
            else
            {
              // End process
              return;
            }
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // EXT_AUDIO_MGT == 1

  #if (L1_ANR == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_anr_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* ANR feature.                                          */
    /*                                                       */
    /* Starting messages:        MMI_ANR_REQ                 */
    /*                                                       */
    /* Result messages (input):  L1_ANR_CON                  */
    /*                                                       */
    /* Result messages (output): MMI_ANR_CON                 */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
#if(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.anr_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_ANR_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.anr_task.parameters.anr_enable       = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable;
              l1a_l1s_com.anr_task.parameters.min_gain         = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain;
              l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift;
              l1a_l1s_com.anr_task.parameters.ns_level         = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level;

              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
              {
                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
                // when activating the task at L1s level

                // Enable the L1S task
                l1a_l1s_com.anr_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"ANR SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
          break;
          case WAIT_DYN_DWNLD:
          {
            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.anr_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"ANR SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_ANR_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_ANR_CON);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.anr_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_ANR_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.anr_task.parameters.anr_enable       = ((T_MMI_ANR_REQ *)(msg->SigP))->anr_enable;
              l1a_l1s_com.anr_task.parameters.min_gain         = ((T_MMI_ANR_REQ *)(msg->SigP))->min_gain;
              l1a_l1s_com.anr_task.parameters.div_factor_shift = ((T_MMI_ANR_REQ *)(msg->SigP))->div_factor_shift;
              l1a_l1s_com.anr_task.parameters.ns_level         = ((T_MMI_ANR_REQ *)(msg->SigP))->ns_level;

              // Enable the L1S task
              l1a_l1s_com.anr_task.command.update = TRUE;

              *state = WAIT_CON;
            }
            // End process
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_ANR_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_ANR_CON);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#endif // L1_DYN_DSP_DWNLD
  #endif // L1_ANR
#if (L1_ANR == 2) // ANR 2.13
    /*-------------------------------------------------------*/
    /* l1a_mmi_anr_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* ANR 2.13 feature.                                     */
    /*                                                       */
    /* Starting messages:        MMI_AQI_ANR_REQ             */
    /*                                                       */
    /* Result messages (input):  L1_AQI_ANR_CON              */
    /*                                                       */
    /* Result messages (output): MMI_AQI_ANR_CON             */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
#if(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.anr_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_ANR_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.anr_task.parameters.anr_ul_control     = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control;
              l1a_l1s_com.anr_task.parameters.control            = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control;
              l1a_l1s_com.anr_task.parameters.ns_level           = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level;
              l1a_l1s_com.anr_task.parameters.tone_ene_th        = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th;
              l1a_l1s_com.anr_task.parameters.tone_cnt_th        = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th;

              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
              {
                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
                // when activating the task at L1s level

                // Enable the L1S task
                l1a_l1s_com.anr_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"ANR SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
 // omaps00090550           break;
          case WAIT_DYN_DWNLD:
          {
            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.anr_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"ANR SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
 // omaps00090550        break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_ANR_CON)
            {
              // Send the confirmation message
              l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550          break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_anr_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_ANR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.anr_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_ANR_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.anr_task.parameters.anr_ul_control   = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->anr_ul_control;
              l1a_l1s_com.anr_task.parameters.control          = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.control;
              l1a_l1s_com.anr_task.parameters.ns_level         = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.ns_level;
              l1a_l1s_com.anr_task.parameters.tone_ene_th      = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_ene_th;
              l1a_l1s_com.anr_task.parameters.tone_cnt_th      = ((T_MMI_AQI_ANR_REQ *)(msg->SigP))->parameters.tone_cnt_th;

              // Enable the L1S task
              l1a_l1s_com.anr_task.command.update = TRUE;

              *state = WAIT_CON;
            }
            // End process
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_ANR_CON)
            {
              // Send the confirmation message
              l1a_audio_send_result(MMI_AQI_ANR_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#endif // L1_DYN_DSP_DWNLD
#endif // L1_ANR

  #if (L1_IIR == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_iir_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* IIR feature.                                          */
    /*                                                       */
    /* Starting messages:        MMI_IIR_REQ                 */
    /*                                                       */
    /* Result messages (input):  L1_IIR_CON                  */
    /*                                                       */
    /* Result messages (output): MMI_IIR_CON                 */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_iir_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_IIR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.iir_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_IIR_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.iir_task.parameters.iir_enable          = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_enable;
              l1a_l1s_com.iir_task.parameters.nb_iir_blocks       = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_iir_blocks;
              l1a_l1s_com.iir_task.parameters.iir_coefs           = ((T_MMI_IIR_REQ *)(msg->SigP))->iir_coefs;
              l1a_l1s_com.iir_task.parameters.nb_fir_coefs        = ((T_MMI_IIR_REQ *)(msg->SigP))->nb_fir_coefs;
              l1a_l1s_com.iir_task.parameters.fir_coefs           = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_coefs;
              l1a_l1s_com.iir_task.parameters.input_scaling       = ((T_MMI_IIR_REQ *)(msg->SigP))->input_scaling;
              l1a_l1s_com.iir_task.parameters.fir_scaling         = ((T_MMI_IIR_REQ *)(msg->SigP))->fir_scaling;
              l1a_l1s_com.iir_task.parameters.input_gain_scaling  = ((T_MMI_IIR_REQ *)(msg->SigP))->input_gain_scaling;
              l1a_l1s_com.iir_task.parameters.output_gain_scaling = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain_scaling;
              l1a_l1s_com.iir_task.parameters.output_gain         = ((T_MMI_IIR_REQ *)(msg->SigP))->output_gain;
              l1a_l1s_com.iir_task.parameters.feedback            = ((T_MMI_IIR_REQ *)(msg->SigP))->feedback;

              // Enable the L1S task
              l1a_l1s_com.iir_task.command.update = TRUE;

              *state = WAIT_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_CON:
          {
            if (SignalCode == L1_IIR_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_IIR_CON);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
  #endif // L1_IIR

 #if (L1_AGC_UL == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_agc_ul_process()                              */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* AGC UL feature.                                       */
    /*                                                       */
    /* Starting messages:        MMI_AQI_AGC_UL_REQ          */
    /*                                                       */
    /* Result messages (input):  L1_AQI_AGC_UL_CON           */
    /*                                                       */
    /* Result messages (output): MMI_AQI_AGC_UL_CON          */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
#if(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_AGC_UL_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.agc_ul_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_AGC_UL_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.agc_ul_task.parameters.agc_ul_control         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control;
              l1a_l1s_com.agc_ul_task.parameters.control                = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control;
              l1a_l1s_com.agc_ul_task.parameters.frame_size             = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size;
              l1a_l1s_com.agc_ul_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level;
              l1a_l1s_com.agc_ul_task.parameters.signal_up              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up;
              l1a_l1s_com.agc_ul_task.parameters.signal_down            = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down;
              l1a_l1s_com.agc_ul_task.parameters.max_scale              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
              l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag;


              if (l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN)
              {
                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
                // when activating the task at L1s level

                // Enable the L1S task
                l1a_l1s_com.agc_ul_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"AGC_UL SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
 // omaps00090550          break;
          case WAIT_DYN_DWNLD:
          {
            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_UL_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.agc_ul_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"AGC_UL SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
 // omaps00090550        break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_AGC_UL_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550          break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_agc_ul_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_AGC_UL_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.agc_ul_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_AGC_UL_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.agc_ul_task.parameters.agc_ul_control         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->agc_ul_control;
              l1a_l1s_com.agc_ul_task.parameters.control                = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.control;
              l1a_l1s_com.agc_ul_task.parameters.frame_size             = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.frame_size;
              l1a_l1s_com.agc_ul_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.targeted_level;
              l1a_l1s_com.agc_ul_task.parameters.signal_up              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_up;
              l1a_l1s_com.agc_ul_task.parameters.signal_down            = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.signal_down;
              l1a_l1s_com.agc_ul_task.parameters.max_scale              = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.max_scale;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
              l1a_l1s_com.agc_ul_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
              l1a_l1s_com.agc_ul_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_UL_REQ *)(msg->SigP))->parameters.gain_intp_flag;

              // Enable the L1S task
              l1a_l1s_com.agc_ul_task.command.update = TRUE;

              *state = WAIT_CON;
            }
            // End process
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_AGC_UL_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_AGC_UL_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#endif // L1_DYN_DSP_DWNLD

#endif // L1_AGC_UL


#if (L1_AGC_DL == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_agc_dl_process()                              */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* AGC DL feature.                                       */
    /*                                                       */
    /* Starting messages:        MMI_AQI_AGC_DL_REQ          */
    /*                                                       */
    /* Result messages (input):  L1_AQI_AGC_DL_CON           */
    /*                                                       */
    /* Result messages (output): MMI_AQI_AGC_DL_CON          */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
#if(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_AGC_DL_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.agc_dl_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_AGC_DL_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.agc_dl_task.parameters.agc_dl_control         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control;
              l1a_l1s_com.agc_dl_task.parameters.control                = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control;
              l1a_l1s_com.agc_dl_task.parameters.frame_size             = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size;
              l1a_l1s_com.agc_dl_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level;
              l1a_l1s_com.agc_dl_task.parameters.signal_up              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up;
              l1a_l1s_com.agc_dl_task.parameters.signal_down            = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down;
              l1a_l1s_com.agc_dl_task.parameters.max_scale              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
              l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag;


              if (l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN)
              {
                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
                // when activating the task at L1s level

                // Enable the L1S task
                l1a_l1s_com.agc_dl_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"AGC_DL SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
 // omaps00090550           break;
          case WAIT_DYN_DWNLD:
          {
            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[AGC_DL_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.agc_dl_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"AGC_DL SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
 // omaps00090550          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_AGC_DL_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550           break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_agc_dl_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_AGC_DL_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.agc_dl_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_AGC_DL_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.agc_dl_task.parameters.agc_dl_control         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->agc_dl_control;
              l1a_l1s_com.agc_dl_task.parameters.control                = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.control;
              l1a_l1s_com.agc_dl_task.parameters.frame_size             = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.frame_size;
              l1a_l1s_com.agc_dl_task.parameters.targeted_level         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.targeted_level;
              l1a_l1s_com.agc_dl_task.parameters.signal_up              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_up;
              l1a_l1s_com.agc_dl_task.parameters.signal_down            = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.signal_down;
              l1a_l1s_com.agc_dl_task.parameters.max_scale              = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.max_scale;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha      = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_alpha_fast = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_alpha_fast;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta       = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta;
              l1a_l1s_com.agc_dl_task.parameters.gain_smooth_beta_fast  = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_smooth_beta_fast;
              l1a_l1s_com.agc_dl_task.parameters.gain_intp_flag         = ((T_MMI_AQI_AGC_DL_REQ *)(msg->SigP))->parameters.gain_intp_flag;

              // Enable the L1S task
              l1a_l1s_com.agc_dl_task.command.update = TRUE;

              *state = WAIT_CON;
            }
            // End process
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_AGC_DL_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_AGC_DL_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#endif // L1_DYN_DSP_DWNLD

#endif // L1_AGC_DL


  #if (L1_IIR == 2)
    /*-------------------------------------------------------*/
    /* l1a_mmi_iir_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* IIR feature.                                          */
    /*                                                       */
    /* Starting messages:        MMI_AQI_IIR_DL_REQ             */
    /*                                                       */
    /* Result messages (input):  L1_AQI_IIR_DL_CON              */
    /*                                                       */
    /* Result messages (output): MMI_AQI_IIR_DL_CON             */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_iir_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_IIR_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.iir_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_IIR_DL_REQ)
            {
	          l1a.iir_req_msg_ptr = msg;
              l1a.l1_msg_forwarded = TRUE;

              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.iir_task.parameters = (T_MMI_AQI_IIR_DL_REQ *) (msg->SigP);

              // Enable the L1S task
              l1a_l1s_com.iir_task.command.update = TRUE;

              *state = WAIT_CON;
            }

            // End process
            return;
          }
 // omaps00090550           break;

          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_IIR_DL_CON)
            {
              os_free_sig(l1a.iir_req_msg_ptr);
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_IIR_DL_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550         break;
        } // switch
      } // while(1)
    }
  #endif // L1_IIR

  #if (L1_WCM == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_wcm_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* WCM feature.                                          */
    /*                                                       */
    /* Starting messages:        MMI_AQI_WCM_REQ             */
    /*                                                       */
    /* Result messages (input):  L1_AQI_WCM_CON              */
    /*                                                       */
    /* Result messages (output): MMI_AQI_WCM_CON             */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/

#if(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_wcm_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_WCM_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.wcm_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_WCM_REQ)
            {
	          l1a.wcm_req_msg_ptr = msg;
      	      l1a.l1_msg_forwarded = TRUE;

              // Load the message into the l1a_l1s_com memory
              l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP);

              if (l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN)
              {
                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
                // when activating the task at L1s level

                // Enable the L1S task
                l1a_l1s_com.wcm_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"WCM SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
 // omaps00090550          break;
          case WAIT_DYN_DWNLD:
          {
            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[WCM_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.wcm_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"WCM SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
 // omaps00090550          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_WCM_CON)
            {
              os_free_sig(l1a.wcm_req_msg_ptr);
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550          break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_wcm_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_WCM_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.wcm_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_WCM_REQ)
            {
	          l1a.wcm_req_msg_ptr = msg;
      	      l1a.l1_msg_forwarded = TRUE;

              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.wcm_task.parameters = (T_MMI_AQI_WCM_REQ *) (msg->SigP);

              // Enable the L1S task
              l1a_l1s_com.wcm_task.command.update = TRUE;

              *state = WAIT_CON;
            }
            // End process
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_WCM_CON)
            {
              os_free_sig(l1a.wcm_req_msg_ptr);
              // Send the start confirmation message
              l1a_audio_send_result(MMI_AQI_WCM_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#endif // L1_DYN_DSP_DWNLD

#endif // L1_WCM

#if (L1_DRC == 1) // DRC 1.x
// DRC NDB API
T_DRC_MCU_DSP *drc_ndb;
#if (CODE_VERSION == SIMULATION)
  T_DRC_MCU_DSP drc_ndb_sim;
#endif

    /*-------------------------------------------------------*/
    /* l1a_mmi_drc_process()                                 */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* DRC 1.x feature.                                     */
    /*                                                       */
    /* Starting messages:        MMI_AQI_DRC_REQ             */
    /*                                                       */
    /* Result messages (input):  L1_AQI_DRC_CON              */
    /*                                                       */
    /* Result messages (output): MMI_AQI_DRC_CON             */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
#if(L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_drc_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD    = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_DRC_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.drc_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_DRC_REQ)
            {
	          l1a.drc_req_msg_ptr = msg;
       	      l1a.l1_msg_forwarded = TRUE;
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP);

              if (l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN)
              {
                // WARNING: the following code must be copied in the state WAIT_DYN_DWNLD
                // when activating the task at L1s level

                // Enable the L1S task
                l1a_l1s_com.drc_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"DRC SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
 // omaps00090550          break;
          case WAIT_DYN_DWNLD:
          {
            if(SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[DRC_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.drc_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"DRC SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
 // omaps00090550          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_DRC_CON)
            {
              os_free_sig(l1a.drc_req_msg_ptr);
              // Send the confirmation message
              l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550          break;
        } // switch
      } // while(1)
    }
#else
    void l1a_mmi_drc_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_DRC_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.drc_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_AQI_DRC_REQ)
            {
	          l1a.drc_req_msg_ptr = msg;
       	      l1a.l1_msg_forwarded = TRUE;
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.drc_task.parameters = (T_MMI_AQI_DRC_REQ *) (msg->SigP);

              // Enable the L1S task
              l1a_l1s_com.drc_task.command.update = TRUE;

              *state = WAIT_CON;
            }
            // End process
            return;
          }
          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_AQI_DRC_CON)
            {
              os_free_sig(l1a.drc_req_msg_ptr);

              // Send the confirmation message
              l1a_audio_send_result(MMI_AQI_DRC_CON, msg, MMI_QUEUE);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
#endif // L1_DYN_DSP_DWNLD
#endif // L1_DRC

  #if (L1_LIMITER == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_limiter_process()                             */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* LIMITER feature.                                      */
    /*                                                       */
    /* Starting messages:        MMI_LIMITER_REQ             */
    /*                                                       */
    /* Result messages (input):  L1_LIMITER_CON              */
    /*                                                       */
    /* Result messages (output): MMI_LIMITER_CON             */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
    void l1a_mmi_limiter_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_LIMITER_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the commands
            l1a_l1s_com.limiter_task.command.update         = FALSE;
            l1a_l1s_com.limiter_task.command.partial_update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_LIMITER_REQ)
            {
              // Load the message into the l1a_l1s_com memory.
              l1a_l1s_com.limiter_task.parameters.limiter_enable      = ((T_MMI_LIMITER_REQ *)(msg->SigP))->limiter_enable;
              l1a_l1s_com.limiter_task.parameters.block_size          = ((T_MMI_LIMITER_REQ *)(msg->SigP))->block_size;
              l1a_l1s_com.limiter_task.parameters.slope_update_period = ((T_MMI_LIMITER_REQ *)(msg->SigP))->slope_update_period;
              l1a_l1s_com.limiter_task.parameters.nb_fir_coefs        = ((T_MMI_LIMITER_REQ *)(msg->SigP))->nb_fir_coefs;
              l1a_l1s_com.limiter_task.parameters.filter_coefs        = ((T_MMI_LIMITER_REQ *)(msg->SigP))->filter_coefs;
              l1a_l1s_com.limiter_task.parameters.thr_low_0           = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_0;
              l1a_l1s_com.limiter_task.parameters.thr_low_slope       = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_low_slope;
              l1a_l1s_com.limiter_task.parameters.thr_high_0          = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_0;
              l1a_l1s_com.limiter_task.parameters.thr_high_slope      = ((T_MMI_LIMITER_REQ *)(msg->SigP))->thr_high_slope;
              l1a_l1s_com.limiter_task.parameters.gain_fall           = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_fall;
              l1a_l1s_com.limiter_task.parameters.gain_rise           = ((T_MMI_LIMITER_REQ *)(msg->SigP))->gain_rise;

              // Enable the L1S task
              l1a_l1s_com.limiter_task.command.update = TRUE;

              *state = WAIT_CON;
            }

            // End process
            return;
          }
 // omaps00090550           break;

          case WAIT_CON:
          {
            if (SignalCode == L1_LIMITER_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_LIMITER_CON);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550         break;
        } // switch
      } // while(1)
    }
  #endif // L1_LIMITER

  #if (L1_ES == 1)
    /*-------------------------------------------------------*/
    /* l1a_mmi_es_process()                                  */
    /*-------------------------------------------------------*/
    /*                                                       */
    /* Description:                                          */
    /* ------------                                          */
    /* This function is a state machine which handles the    */
    /* Echo Suppressor feature.                              */
    /*                                                       */
    /* Starting messages:        MMI_ES_REQ                  */
    /*                                                       */
    /* Result messages (input):  L1_ES_CON                   */
    /*                                                       */
    /* Result messages (output): MMI_ES_CON                  */
    /*                                                       */
    /* Reset messages (input):   none                        */
    /*                                                       */
    /* Stop message (input):     none                        */
    /*                                                       */
    /* Stop message (output):    none                        */
    /*                                                       */
    /*-------------------------------------------------------*/
#if (L1_DYN_DSP_DWNLD == 1)
    void l1a_mmi_es_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_DYN_DWNLD = 2,
        WAIT_CON          = 3
      };

      UWORD8    *state      = &l1a.state[L1A_ES_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.es_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_ES_REQ)
            {
              // Load the message into the l1a_l1s_com memory
              l1a_l1s_com.es_task.parameters.es_enable     = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable;
              l1a_l1s_com.es_task.parameters.es_behavior   = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior;

              if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM)
              {
                // Load every parameters from the message
                l1a_l1s_com.es_task.parameters.es_config.es_mode               = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode;
                l1a_l1s_com.es_task.parameters.es_config.es_gain_dl            = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl;
                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1;
                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2;
                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr            = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr;
                l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr            = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr;
                l1a_l1s_com.es_task.parameters.es_config.switching_time        = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time;
                l1a_l1s_com.es_task.parameters.es_config.switching_time_dt     = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt;
                l1a_l1s_com.es_task.parameters.es_config.hang_time             = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time;
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3];
              }
              if (l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
              {
                // WARNING: The following code must be copied in the state WAIT_DYN_DWNLD
                // when ES task is activated at L1s level

                // Enable the L1S task
                l1a_l1s_com.es_task.command.update = TRUE;

                *state = WAIT_CON;
              }
              else
              {
                *state = WAIT_DYN_DWNLD;

                #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                  if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"ES SM blocked by DYN DWNLD\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
                #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
              }
            }

            // End process
            return;
          }
 // omaps00090550           break;
          case WAIT_DYN_DWNLD:
          {
            if (SignalCode == API_L1_DYN_DWNLD_FINISHED && l1a.dyn_dwnld.semaphore_vect[ANR_STATE_MACHINE] == GREEN)
            {
              // Enable the L1S task
              l1a_l1s_com.es_task.command.update = TRUE;

              *state = WAIT_CON;

              #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4) || (TRACE_TYPE == 5))
                if((trace_info.current_config->l1_dyn_trace) & (1<<L1_DYN_TRACE_DYN_DWNLD))
                  {
                    char str[30];
                    sprintf(str,"ES SM un-blocked\r\n");
                    #if(CODE_VERSION == SIMULATION)
                      trace_fct_simu_dyn_dwnld(str);
                    #else
                      rvt_send_trace_cpy((T_RVT_BUFFER)str,trace_info.l1_trace_user_id,strlen(str),RVT_ASCII_FORMAT);
                    #endif
                  }
               #endif    // (TRACE_TYPE == 1) || (TRACE_TYPE == 4)
            }
            return;
          }
 // omaps00090550          break;
          case WAIT_CON:
          {
            if (SignalCode == L1_ES_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_ES_CON);

              *state = RESET;
            }

            // End process
            return;
          }
 // omaps00090550          break;
        } // switch
      } // while(1)
    }

#else
    void l1a_mmi_es_process(xSignalHeaderRec *msg)
    {
      enum states
      {
        RESET             = 0,
        WAIT_REQ          = 1,
        WAIT_CON          = 2
      };

      UWORD8    *state      = &l1a.state[L1A_ES_STATE];
      UWORD32   SignalCode  = msg->SignalCode;

      while(1)
      {
        switch(*state)
        {
          case RESET:
          {
            // Reset the command
            l1a_l1s_com.es_task.command.update = FALSE;

            *state = WAIT_REQ;
          }
          break;

          case WAIT_REQ:
          {
            if (SignalCode == MMI_ES_REQ)
            {
              // Load the message into the l1a_l1s_com memory
              l1a_l1s_com.es_task.parameters.es_enable     = ((T_MMI_ES_REQ *)(msg->SigP))->es_enable;
              l1a_l1s_com.es_task.parameters.es_behavior   = ((T_MMI_ES_REQ *)(msg->SigP))->es_behavior;

              if (l1a_l1s_com.es_task.parameters.es_behavior == ES_CUSTOM_PARAM)
              {
                // Load every parameters from the message
                l1a_l1s_com.es_task.parameters.es_config.es_mode               = ((T_MMI_ES_REQ *)(msg->SigP))->es_mode;
                l1a_l1s_com.es_task.parameters.es_config.es_gain_dl            = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_dl;
                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_1          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_1;
                l1a_l1s_com.es_task.parameters.es_config.es_gain_ul_2          = ((T_MMI_ES_REQ *)(msg->SigP))->es_gain_ul_2;
                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ls_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ls_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ls_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_fe_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_fe_ns_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_dt_ns_thr         = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_dt_ns_thr;
                l1a_l1s_com.es_task.parameters.es_config.tcl_ne_thr            = ((T_MMI_ES_REQ *)(msg->SigP))->tcl_ne_thr;
                l1a_l1s_com.es_task.parameters.es_config.ref_ls_pwr            = ((T_MMI_ES_REQ *)(msg->SigP))->ref_ls_pwr;
                l1a_l1s_com.es_task.parameters.es_config.switching_time        = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time;
                l1a_l1s_com.es_task.parameters.es_config.switching_time_dt     = ((T_MMI_ES_REQ *)(msg->SigP))->switching_time_dt;
                l1a_l1s_com.es_task.parameters.es_config.hang_time             = ((T_MMI_ES_REQ *)(msg->SigP))->hang_time;
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[0];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[1];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[2];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_dl_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_dl_vect[3];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[0]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[0];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[1]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[1];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[2]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[2];
                l1a_l1s_com.es_task.parameters.es_config.gain_lin_ul_vect[3]   = ((T_MMI_ES_REQ *)(msg->SigP))->gain_lin_ul_vect[3];
              }

              // Enable the L1S task
              l1a_l1s_com.es_task.command.update = TRUE;

              *state = WAIT_CON;
            }

            // End process
            return;
          }
          break;

          case WAIT_CON:
          {
            if (SignalCode == L1_ES_CON)
            {
              // Send the start confirmation message
              l1a_audio_send_confirmation(MMI_ES_CON);

              *state = RESET;
            }

            // End process
            return;
          }
          break;
        } // switch
      } // while(1)
    }
  #endif //L1_DYN_DSP_DWNLD
  #endif // L1_ES

// New Vocoder IF process

#if (L1_VOCODER_IF_CHANGE == 1)
  void l1a_mmi_vocoder_cfg_process    (xSignalHeaderRec *msg)
  {

    BOOL msg_parameter;

    enum states
    {
      WAIT_REQ = 0,
      WAIT_ENABLE_CON = 1,
      WAIT_DISABLE_CON = 2
    };

    enum vocoder_cfg_req
    {
      VOCODER_DISABLE_REQ  = 0,
      VOCODER_ENABLE_REQ  = 1
    };

    UWORD8    *state      = &l1a.state[L1A_VOCODER_CFG_STATE];
    UWORD32   SignalCode  = msg->SignalCode;

    while (1)
    {
      switch(*state)
      {
        case WAIT_REQ:
        {

          // Waiting PS messages....

          // If SignalCode is an MPHC_STOP_DEDICATED_REQ and vocoders are enabled, they must be stopped automatically

#if(L1_CHECK_COMPATIBLE == 1)
          if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE)) || (l1a.vch_auto_disable == TRUE))
#else
          if (((SignalCode == MPHC_STOP_DEDICATED_REQ) && (l1a.vocoder_state.enabled == TRUE)))          
#endif		 	
          {
             // Command vocoder disabling at L1A-L1s interface and set the automatic disable flag to TRUE
             l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND;
             l1a.vocoder_state.automatic_disable = TRUE;
             *state = WAIT_DISABLE_CON;
#if(L1_CHECK_COMPATIBLE == 1)			
  	      l1a.vch_auto_disable = FALSE;
#endif
          }
          else if (SignalCode == MMI_TCH_VOCODER_CFG_REQ)
          {
            // In case the vocoder START or STOP is commanded by PS

          
            msg_parameter = ((T_MMI_TCH_VOCODER_CFG_REQ *) (msg->SigP))->vocoder_state;
            // If it is an explicit STOP....
            if (msg_parameter == VOCODER_DISABLE_REQ)
            {
#if (AUDIO_DEBUG == 1)
              trace_info.audio_debug_var.vocoder_enable_status = 0;
#endif

              //... explicitely disable vocoders if they're enabled commanidng the stop at L1A-L1s interface
              if (l1a.vocoder_state.enabled == TRUE)
              {
                 l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_DISABLE_COMMAND;
                 l1a.vocoder_state.automatic_disable = FALSE;
                 *state = WAIT_DISABLE_CON;
              }
              else
              {
                // ...else, if vocoders are already disabled but PS is sending erroneously the request
                // send him however the confirmation without doing anything (protection check).
                // In case L1 standalone or SIMULATION, confirmation message must be
                // sent to MMI mailbox, else with complete PS software the message must be
                // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).

                l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
              }
            }
            else if (msg_parameter == VOCODER_ENABLE_REQ)
            {
#if (AUDIO_DEBUG == 1)
              trace_info.audio_debug_var.vocoder_enable_status = 1;
#endif
              // If it is a START
              if (l1a.vocoder_state.enabled == FALSE)
              {
                // Command the start at L1A-L1s interface if vocoders are disabled
                l1a_l1s_com.dedic_set.start_vocoder = TCH_VOCODER_ENABLE_COMMAND;
                *state = WAIT_ENABLE_CON;
              }
              else
              {
                // ...else, if vocoders are already enabled but PS is sending erroneously the request
                // send him however the confirmation without doing anything (protection check).
                // In case L1 standalone or SIMULATION, confirmation message must be
                // sent to MMI mailbox, else with complete PS software the message must be
                // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).

                l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
              }
            }
          }
        return;
        }
 // omaps00090550        break;
        case WAIT_ENABLE_CON:
        {
          if (SignalCode == L1_VOCODER_CFG_ENABLE_CON)
          {
            // when L1s confirms the enabling, forward the confirmation to PS and set the vocoders enabled flag to TRUE
            l1a.vocoder_state.enabled = TRUE;

            // in case L1 standalone or SIMULATION, confirmation message must be
            // sent to MMI mailbox, else with complete PS software the message must be
            // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).

            l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
            *state = WAIT_REQ;
          }
          return;
        }
 // omaps00090550        break;
        case WAIT_DISABLE_CON:
        {
          if (SignalCode == L1_VOCODER_CFG_DISABLE_CON)
          {
            // when L1s confirms the disabling, forwards the confirmation to PS and set the vocoders enabled flag to FALSE
            l1a.vocoder_state.enabled = FALSE;
            *state = WAIT_REQ;

            if (l1a.vocoder_state.automatic_disable == FALSE)
            {
              // Only in case it is an explicit request to STOP the vocoders (made previously by PS)
              // send him the confirmation.
              // In case L1 standalone or SIMULATION, confirmation message must be
              // sent to MMI mailbox, else with complete PS software the message must be
              // addressed to the ACI queue (WARNING: ACI_QUEUE must be properly defined).

              l1a_send_confirmation(MMI_TCH_VOCODER_CFG_CON, ACI_QUEUE);
            }
            else
            	// Reset automatic disable flag
            	l1a.vocoder_state.automatic_disable = FALSE;
          }
        return;
        }
      // omaps00090550 break;
      }
    }

  }
#endif // L1_VOCODER_IF_CHANGE == 1

#if 0	/* FreeCalypso: LoCosto-ism removed */
  void l1a_mmi_outen_cfg_process    (xSignalHeaderRec *msg)
  {
#if (OP_RIV_AUDIO == 1)

    UWORD32 SignalCode = msg->SignalCode;
    void              *p_message;
    T_RVF_MB_STATUS   mb_status;

    if (SignalCode == MMI_OUTEN_CFG_REQ)
    {
      l1a_l1s_com.outen_cfg_task.outen1 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen1;
      l1a_l1s_com.outen_cfg_task.outen2 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen2;
      l1a_l1s_com.outen_cfg_task.outen3 = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->outen3;
      l1a_l1s_com.outen_cfg_task.classD  = ((T_MMI_OUTEN_CFG_REQ *)(msg->SigP))->classD;

      l1a_l1s_com.outen_cfg_task.command_requested++;
      // Send the confirmation message
      l1a_audio_send_confirmation(MMI_OUTEN_CFG_CON);
     }
     else if(SignalCode == MMI_OUTEN_CFG_READ_REQ)
     {
        // Allocate the Riviera buffer
        mb_status = rvf_get_buf ( p_audio_gbl_var->mb_external,
                                  sizeof (T_MMI_OUTEN_CFG_READ_CON),
                                  (T_RVF_BUFFER **) (&p_message));

        // If insufficient resources, then report a memory error and abort.
        if (mb_status == RVF_RED)
        {
          // the memory is insufficient to continue the non regression test
          AUDIO_SEND_TRACE("AUDIO entity has no memory for L1 confirm",RV_TRACE_LEVEL_ERROR);
          return;
        }

        // Fill the message ID
        ((T_MMI_OUTEN_CFG_READ_CON *)(p_message))->header.msg_id = MMI_OUTEN_CFG_READ_CON;

        // Fill the message parameter
        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen1 = l1a_l1s_com.outen_cfg_task.outen1;
        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen2 = l1a_l1s_com.outen_cfg_task.outen2;
        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->outen3 = l1a_l1s_com.outen_cfg_task.outen3;
        ((T_MMI_OUTEN_CFG_READ_CON*)(p_message))->classD  = l1a_l1s_com.outen_cfg_task.classD;

          // send the messsage to the audio entity
          rvf_send_msg (p_audio_gbl_var->addrId,p_message);
     }
#endif /*OP_RIV_AUDIO*/
  } /* end function l1a_mmi_outen_cfg_process */
#endif

#if(L1_BT_AUDIO ==1)
void l1a_mmi_bt_process(xSignalHeaderRec *msg)
{             
     UWORD32 SignalCode = msg->SignalCode;
	 
     if (SignalCode == MMI_BT_ENABLE_REQ)
           bt_audio.connected_status   = TRUE;
     else if(SignalCode == MMI_BT_DISABLE_REQ)
	    bt_audio.connected_status  = FALSE;

}
#endif
#endif // AUDIO_TASK