diff chipsetsw/services/Audio/audio_api.c @ 0:509db1a7b7b8

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/chipsetsw/services/Audio/audio_api.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,4320 @@
+/****************************************************************************/
+/*                                                                          */
+/*  File Name:  audio_api.c                                                 */
+/*                                                                          */
+/*  Purpose:  This file contains all the functions used to service          */
+/*            primitives.                                                   */
+/*                                                                          */
+/*  Version   0.1                                                           */
+/*                                                                          */
+/*  Date        Modification                                                */
+/*  ------------------------------------------------------------------------*/
+/*  14 May 2001  Create                                                     */
+/*                                                                          */
+/*  Author      Francois Mazard - Stephanie Gerthoux                        */
+/*                                                                          */
+/* (C) Copyright 2001 by Texas Instruments Incorporated, All Rights Reserved*/
+/****************************************************************************/
+
+#include "rv/rv_defined_swe.h"
+
+#ifdef RVM_AUDIO_MAIN_SWE
+  #ifndef _WINDOWS
+    #include "config/swconfig.cfg"
+	#include "config/sys.cfg"
+	#include "config/chipset.cfg"
+  #endif
+
+  #include "l1_confg.h"
+  #include "l1audio_cust.h"
+  #include "rv/rv_general.h"
+  #include "rvm/rvm_gen.h"
+  #include "audio/audio_ffs_i.h"
+  #include "audio/audio_api.h"
+  #include "audio/audio_structs_i.h"
+  #include "audio/audio_error_hdlr_i.h"
+  #include "audio/audio_var_i.h"
+  #include "audio/audio_messages_i.h"
+  #include "rvf/rvf_target.h"
+  #include "audio/audio_const_i.h"
+  #include "audio/audio_macro_i.h"
+  #include "ffs/ffs_api.h"
+
+#include <string.h>
+
+  /* external dependency */
+  #if (SPEECH_RECO)
+    extern INT8 audio_sr_create_vocabulary_database(char* directory, void** pp_database);
+  #endif
+  /* read */
+  extern T_AUDIO_RET audio_mode_voice_path_read               (T_AUDIO_VOICE_PATH_SETTING *data);
+  extern T_AUDIO_RET audio_mode_microphone_mode_read          (INT8  *data);
+  extern T_AUDIO_RET audio_mode_microphone_gain_read          (INT8  *data);
+  extern T_AUDIO_RET audio_mode_microphone_extra_gain_read    (INT8  *data);
+  extern T_AUDIO_RET audio_mode_microphone_output_bias_read   (INT8  *data);
+  extern T_AUDIO_RET audio_mode_microphone_fir_read           (T_AUDIO_FIR_COEF *data);
+  extern T_AUDIO_RET audio_mode_speaker_mode_read             (INT8  *data);
+  extern T_AUDIO_RET audio_mode_speaker_gain_read             (INT8  *data);
+  extern T_AUDIO_RET audio_mode_speaker_filter_read           (INT8  *data);
+  extern T_AUDIO_RET audio_mode_speaker_fir_read              (T_AUDIO_FIR_COEF *data);
+  extern T_AUDIO_RET audio_mode_speaker_buzzer_read           (INT8  *data);
+  extern T_AUDIO_RET audio_mode_sidetone_gain_read            (INT8  *data);
+  extern T_AUDIO_RET audio_mode_aec_read                      (T_AUDIO_AEC_CFG *data);
+  extern T_AUDIO_RET audio_mode_speaker_volume_read           (T_AUDIO_SPEAKER_LEVEL *data);
+
+  T_AUDIO_RET audio_driver_handle_session(UINT32 msg_id, UINT8 channel_id, T_RV_RETURN return_path);
+
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_keybeep_start                                      */
+  /*                                                                              */
+  /*    Purpose:  This function is called to initiate a key beep generation       */
+  /*              and DTMF generation. The key beep is the generation of two      */
+  /*              sine waves                                                      */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Key Beep Parameters,                                            */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the keybeep parameters.                                */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_keybeep_start (T_AUDIO_KEYBEEP_PARAMETER parameter,
+                                    T_RV_RETURN return_path)
+  {
+    #if (KEYBEEP)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+      T_AUDIO_KEYBEEP_START *p_msg_start = NULL;
+
+      /************************ audio_keybeep_start function begins ******************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+         audio_keybeep_error_trace(AUDIO_ENTITY_NOT_START);
+         return(AUDIO_ERROR);
+      }
+
+      /* If bad parameters, then report an error and abort.*/
+      if ((parameter.frequency_beep[0] < FREQUENCY_BEEP_MIN) ||
+          (parameter.frequency_beep[0] > FREQUENCY_BEEP_MAX) ||
+          (parameter.frequency_beep[1] < FREQUENCY_BEEP_MIN) ||
+          (parameter.frequency_beep[1] > FREQUENCY_BEEP_MAX) ||
+          (parameter.amplitude_beep[0] < AMPLITUDE_BEEP_MIN) ||
+          (parameter.amplitude_beep[0] > AMPLITUDE_BEEP_MAX) ||
+          (parameter.amplitude_beep[1] < AMPLITUDE_BEEP_MIN) ||
+          (parameter.amplitude_beep[1] > AMPLITUDE_BEEP_MAX) ||
+          (parameter.duration < DURATION_BEEP_MIN ))
+      {
+        audio_keybeep_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_KEYBEEP_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.     */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_keybeep_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_keybeep_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_KEYBEEP_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->keybeep_parameter.frequency_beep[0]     = parameter.frequency_beep[0];
+      p_msg_start->keybeep_parameter.frequency_beep[1]     = parameter.frequency_beep[1];
+      p_msg_start->keybeep_parameter.amplitude_beep[0]     = parameter.amplitude_beep[0];
+      p_msg_start->keybeep_parameter.amplitude_beep[1]     = parameter.amplitude_beep[1];
+      p_msg_start->keybeep_parameter.duration              = parameter.duration;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Keybeep not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_Keybeep_Start function ******************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_keybeep_stop                                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop a key beep generation           */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_keybeep_stop (T_RV_RETURN return_path)
+  {
+    #if (KEYBEEP)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+      T_AUDIO_KEYBEEP_STOP *p_msg  = NULL;
+
+      /************************ audio_keybeep_stop function begins ****************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_keybeep_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_KEYBEEP_STOP),
+                               (T_RVF_BUFFER **) (&p_msg));
+
+      /* If insufficient resources, then report a memory error and abort.         */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg);
+        audio_keybeep_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_keybeep_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+
+      /* fill the message id */
+      p_msg->os_hdr.msg_id = AUDIO_KEYBEEP_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg->return_path.addr_id = return_path.addr_id;
+        p_msg->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Keybeep not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_Keybeep_Stop function *******************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_tones_start                                        */
+  /*                                                                              */
+  /*    Purpose:  This function is called to initiate tones generation.           */
+  /*              The tones are the generation of up to three scheduled           */
+  /*              sine waves..........................................            */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio tones Parameters,                                               */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the tones parameters.                                  */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_tones_start (T_AUDIO_TONES_PARAMETER* parameter,
+                                 T_RV_RETURN return_path)
+  {
+    #if (TONE)
+      /* Declare local variables. */
+      T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+      T_AUDIO_TONES_START *p_msg_start = NULL;
+
+    /************************ audio_tones_start function begins ********************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_tones_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* If bad tones parameters, then report an error and abort.*/
+      if ( (parameter->tones[0].frequency_tone < FREQUENCY_BEEP_MIN) ||
+           (parameter->tones[1].frequency_tone < FREQUENCY_BEEP_MIN) ||
+           (parameter->tones[2].frequency_tone < FREQUENCY_BEEP_MIN) ||
+           (parameter->tones[0].frequency_tone > FREQUENCY_BEEP_MAX) ||
+           (parameter->tones[1].frequency_tone > FREQUENCY_BEEP_MAX) ||
+           (parameter->tones[2].frequency_tone > FREQUENCY_BEEP_MAX) ||
+           (parameter->tones[0].amplitude_tone < AMPLITUDE_BEEP_MIN) ||
+           (parameter->tones[1].amplitude_tone < AMPLITUDE_BEEP_MIN) ||
+           (parameter->tones[2].amplitude_tone < AMPLITUDE_BEEP_MIN) ||
+           (parameter->tones[0].amplitude_tone > AMPLITUDE_BEEP_MAX) ||
+           (parameter->tones[1].amplitude_tone > AMPLITUDE_BEEP_MAX) ||
+           (parameter->tones[2].amplitude_tone > AMPLITUDE_BEEP_MAX) ||
+           (parameter->frame_duration == 0 )                         ||
+           (parameter->period_duration < parameter->sequence_duration) ||
+           (parameter->sequence_duration < parameter->frame_duration)  ||
+           (parameter->period_duration < parameter->frame_duration)    ||
+           ((parameter->tones[0].stop_tone - parameter->tones[0].start_tone) < DURATION_BEEP_MIN) ||
+           ((parameter->tones[1].stop_tone - parameter->tones[1].start_tone) < DURATION_BEEP_MIN) ||
+           ((parameter->tones[2].stop_tone - parameter->tones[2].start_tone) < DURATION_BEEP_MIN) )
+      {
+        audio_tones_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_TONES_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.     */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_tones_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_tones_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_TONES_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->tones_parameter.tones[0].frequency_tone = parameter->tones[0].frequency_tone;
+      p_msg_start->tones_parameter.tones[1].frequency_tone = parameter->tones[1].frequency_tone;
+      p_msg_start->tones_parameter.tones[2].frequency_tone = parameter->tones[2].frequency_tone;
+
+      p_msg_start->tones_parameter.tones[0].amplitude_tone = parameter->tones[0].amplitude_tone;
+      p_msg_start->tones_parameter.tones[1].amplitude_tone = parameter->tones[1].amplitude_tone;
+      p_msg_start->tones_parameter.tones[2].amplitude_tone = parameter->tones[2].amplitude_tone;
+
+      p_msg_start->tones_parameter.tones[0].start_tone = parameter->tones[0].start_tone;
+      p_msg_start->tones_parameter.tones[1].start_tone = parameter->tones[1].start_tone;
+      p_msg_start->tones_parameter.tones[2].start_tone = parameter->tones[2].start_tone;
+      p_msg_start->tones_parameter.tones[0].stop_tone = parameter->tones[0].stop_tone;
+      p_msg_start->tones_parameter.tones[1].stop_tone = parameter->tones[1].stop_tone;
+      p_msg_start->tones_parameter.tones[2].stop_tone = parameter->tones[2].stop_tone;
+
+      p_msg_start->tones_parameter.frame_duration= parameter->frame_duration;
+      p_msg_start->tones_parameter.sequence_duration = parameter->sequence_duration;
+      p_msg_start->tones_parameter.period_duration = parameter->period_duration;
+      p_msg_start->tones_parameter.repetition = parameter->repetition;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Tones not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_tones_Start function ********************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_tones_stop                                         */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop a tones generation              */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        Validation of the tones parameters.                                   */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_tones_stop (T_RV_RETURN return_path)
+  {
+    #if (TONE)
+      /* Declare local variables.                                                  */
+      T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+      T_AUDIO_TONES_STOP *p_msg  = NULL;
+
+    /************************ audio_tones_stop function begins *********************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_tones_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_TONES_STOP),
+                               (T_RVF_BUFFER **) (&p_msg));
+
+      /* If insufficient resources, then report a memory error and abort.           */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg);
+        audio_tones_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_tones_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg->os_hdr.msg_id = AUDIO_TONES_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg->return_path.addr_id = return_path.addr_id;
+        p_msg->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Tones not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_Tones_Stop function *********************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_melody_E1_start                                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called to initiate the melody E1 generation    */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Melody E1 Parameters,                                           */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the melody E1 parameters.                              */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_melody_E1_start (T_AUDIO_MELODY_E1_PARAMETER *p_parameter,
+                                     T_RV_RETURN return_path)
+  {
+    #if (MELODY_E1)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+      T_AUDIO_MELODY_E1_START *p_msg_start = NULL;
+      T_FFS_FD            ffs_fd;
+
+    /************************ audio_melody_E1_start function begins ***************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_melody_E1_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the melody E1 file exist */
+      #ifndef _WINDOWS
+        ffs_fd = ffs_open(p_parameter->melody_name, FFS_O_RDONLY);
+        if (ffs_fd <= 0)
+        {
+          audio_melody_E1_error_trace(AUDIO_ENTITY_FILE_ERROR);
+          return (AUDIO_ERROR);
+        }
+      #else
+        ffs_fd = 0x00000001;
+      #endif
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_MELODY_E1_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.               */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_melody_E1_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_melody_E1_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_MELODY_E1_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd = ffs_fd;
+
+      strcpy(p_msg_start->melody_E1_parameter.melody_name,
+        p_parameter->melody_name);
+
+      if ( (p_parameter->loopback == AUDIO_MELODY_NO_LOOPBACK) ||
+           (p_parameter->loopback == AUDIO_MELODY_LOOPBACK) )
+      {
+        p_msg_start->melody_E1_parameter.loopback = p_parameter->loopback;
+      }
+      else
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        /* Wrong parameter */
+        audio_melody_E1_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      if ( (p_parameter->melody_mode == AUDIO_MELODY_GAME_MODE) ||
+           (p_parameter->melody_mode == AUDIO_MELODY_NORMAL_MODE) )
+      {
+        p_msg_start->melody_E1_parameter.melody_mode     = p_parameter->melody_mode;
+      }
+      else
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        /* Wrong parameter */
+        audio_melody_E1_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Melody E1 not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_melody_E1_Start function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_melody_E1_stop                                     */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop a melody_E1 generation          */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Melody E1 Stop Parameters,                                      */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the melody E1 parameters.                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_melody_E1_stop (T_AUDIO_MELODY_E1_STOP_PARAMETER *p_parameter,
+                                    T_RV_RETURN return_path)
+  {
+    #if (MELODY_E1)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+      T_AUDIO_MELODY_E1_STOP *p_msg  = NULL;
+
+    /************************ audio_melody_E1_stop function begins ****************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_melody_E1_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_MELODY_E1_STOP),
+                               (T_RVF_BUFFER **) (&p_msg));
+
+      /* If insufficient resources, then report a memory error and abort.        */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg);
+        audio_melody_E1_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_melody_E1_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg->os_hdr.msg_id = AUDIO_MELODY_E1_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      strcpy (p_msg->melody_name, p_parameter->melody_name);
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg->return_path.addr_id = return_path.addr_id;
+        p_msg->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Melody E1 not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_melody_E1_Stop function *****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_vm_play_start                                      */
+  /*                                                                              */
+  /*    Purpose:  This function is called to initiate the voice Memorization play */
+  /*              generation                                                      */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Voice Memorization Play Parameters,                             */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the Voice Memorization Play parameters.                */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_vm_play_start (T_AUDIO_VM_PLAY_PARAMETER *p_parameter,
+                                   T_RV_RETURN return_path)
+  {
+    #if (VOICE_MEMO)
+      /* Declare local variables. */
+      T_RVF_MB_STATUS       mb_status = RVF_GREEN;
+      T_AUDIO_VM_PLAY_START *p_msg_start = NULL;
+      T_FFS_FD            ffs_fd;
+
+    /************************ audio_vm_play_start function begins ******************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the voice memo play file exist        */
+      #ifndef _WINDOWS
+        ffs_fd = ffs_open(p_parameter->memo_name, FFS_O_RDONLY);
+        if ( ffs_fd <= 0)
+        {
+          audio_voice_memo_error_trace(AUDIO_ENTITY_FILE_ERROR);
+          return (AUDIO_ERROR);
+        }
+      #else
+        ffs_fd = 0x00000010;
+      #endif
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_PLAY_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.        */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_PLAY_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd = ffs_fd;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("VM Play not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_vm_play_start function ******************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_vm_play_stop                                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop a voice memorization Play       */
+  /*              generation                                                      */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_vm_play_stop (T_RV_RETURN return_path)
+  {
+    #if (VOICE_MEMO)
+      /* Declare local variables.                                                  */
+      T_RVF_MB_STATUS        mb_status = RVF_GREEN;
+      T_AUDIO_VM_PLAY_STOP   *p_msg  = NULL;
+
+    /************************ audio_vm_play_stop function begins *******************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_PLAY_STOP),
+                               (T_RVF_BUFFER **) (&p_msg));
+
+      /* If insufficient resources, then report a memory error and abort.            */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg);
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg->os_hdr.msg_id = AUDIO_VM_PLAY_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg->return_path.addr_id = return_path.addr_id;
+        p_msg->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("VM Play not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_vm_play_Stop function *******************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_vm_record_start                                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called to initiate the voice Memorization      */
+  /*              record generation                                               */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Voice Memorization Record Parameters,                           */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the Voice Memorization Record parameters.              */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_vm_record_start ( T_AUDIO_VM_RECORD_PARAMETER *p_record_parameter,
+                                      T_AUDIO_TONES_PARAMETER *p_tones_parameter,
+                                      T_RV_RETURN return_path)
+  {
+    #if (VOICE_MEMO)
+      /* Declare local variables. */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_VM_RECORD_START   *p_msg_start = NULL;
+      T_FFS_FD            ffs_fd;
+
+      /************************ audio_vm_record_start function begins **************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the voice memo record file already exist        */
+      #ifndef _WINDOWS
+        ffs_fd = ffs_open(p_record_parameter->memo_name,
+                  FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+        if ( ffs_fd <= 0)
+        {
+          audio_voice_memo_error_trace(AUDIO_ENTITY_FILE_ERROR);
+          return (AUDIO_ERROR);
+        }
+      #else
+        ffs_fd = 0x00000011;
+      #endif
+
+      /* If bad tones parameters, then report an error and abort.*/
+      if ( (p_tones_parameter->tones[0].frequency_tone < FREQUENCY_BEEP_MIN) ||
+           (p_tones_parameter->tones[1].frequency_tone < FREQUENCY_BEEP_MIN) ||
+           (p_tones_parameter->tones[2].frequency_tone < FREQUENCY_BEEP_MIN) ||
+           (p_tones_parameter->tones[0].frequency_tone > FREQUENCY_BEEP_MAX) ||
+           (p_tones_parameter->tones[1].frequency_tone > FREQUENCY_BEEP_MAX) ||
+           (p_tones_parameter->tones[2].frequency_tone > FREQUENCY_BEEP_MAX) ||
+           (p_tones_parameter->tones[0].amplitude_tone < AMPLITUDE_BEEP_MIN) ||
+           (p_tones_parameter->tones[1].amplitude_tone < AMPLITUDE_BEEP_MIN) ||
+           (p_tones_parameter->tones[2].amplitude_tone < AMPLITUDE_BEEP_MIN) ||
+           (p_tones_parameter->tones[0].amplitude_tone > AMPLITUDE_BEEP_MAX) ||
+           (p_tones_parameter->tones[1].amplitude_tone > AMPLITUDE_BEEP_MAX) ||
+           (p_tones_parameter->tones[2].amplitude_tone > AMPLITUDE_BEEP_MAX) ||
+           (p_tones_parameter->frame_duration == 0 )                         ||
+           (p_tones_parameter->period_duration < p_tones_parameter->sequence_duration) ||
+           (p_tones_parameter->sequence_duration < p_tones_parameter->frame_duration)  ||
+           (p_tones_parameter->period_duration < p_tones_parameter->frame_duration)    ||
+           ((p_tones_parameter->tones[0].stop_tone - p_tones_parameter->tones[0].start_tone) < DURATION_BEEP_MIN) ||
+           ((p_tones_parameter->tones[1].stop_tone - p_tones_parameter->tones[1].start_tone) < DURATION_BEEP_MIN) ||
+           ((p_tones_parameter->tones[2].stop_tone - p_tones_parameter->tones[2].start_tone) < DURATION_BEEP_MIN) )
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        #ifndef _WINDOWS
+          /* close the file previously open */
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* If bad voice memo record parameters, then report an error and abort.*/
+      if ( ( p_record_parameter->memo_duration == 0) ||
+           (( p_record_parameter->compression_mode != AUDIO_VM_NO_COMPRESSION_MODE ) &&
+            ( p_record_parameter->compression_mode != AUDIO_VM_COMPRESSION_MODE )))
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        #ifndef _WINDOWS
+          /* close the file previously open */
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_RECORD_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        #ifndef _WINDOWS
+          /* close the file previously open */
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        #ifndef _WINDOWS
+          /* close the file previously open */
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_RECORD_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd                           = ffs_fd;
+      p_msg_start->compression_mode   = p_record_parameter->compression_mode;
+      p_msg_start->memo_duration      = p_record_parameter->memo_duration;
+      p_msg_start->microphone_gain    = p_record_parameter->microphone_gain;
+      p_msg_start->network_gain       = p_record_parameter->network_gain;
+
+      /* fill the message tones parameters */
+      p_msg_start->tones_parameter.tones[0].frequency_tone = p_tones_parameter->tones[0].frequency_tone;
+      p_msg_start->tones_parameter.tones[1].frequency_tone = p_tones_parameter->tones[1].frequency_tone;
+      p_msg_start->tones_parameter.tones[2].frequency_tone = p_tones_parameter->tones[2].frequency_tone;
+
+      p_msg_start->tones_parameter.tones[0].amplitude_tone = p_tones_parameter->tones[0].amplitude_tone;
+      p_msg_start->tones_parameter.tones[1].amplitude_tone = p_tones_parameter->tones[1].amplitude_tone;
+      p_msg_start->tones_parameter.tones[2].amplitude_tone = p_tones_parameter->tones[2].amplitude_tone;
+
+      p_msg_start->tones_parameter.tones[0].start_tone = p_tones_parameter->tones[0].start_tone;
+      p_msg_start->tones_parameter.tones[1].start_tone = p_tones_parameter->tones[1].start_tone;
+      p_msg_start->tones_parameter.tones[2].start_tone = p_tones_parameter->tones[2].start_tone;
+      p_msg_start->tones_parameter.tones[0].stop_tone = p_tones_parameter->tones[0].stop_tone;
+      p_msg_start->tones_parameter.tones[1].stop_tone = p_tones_parameter->tones[1].stop_tone;
+      p_msg_start->tones_parameter.tones[2].stop_tone = p_tones_parameter->tones[2].stop_tone;
+
+      p_msg_start->tones_parameter.frame_duration= p_tones_parameter->frame_duration;
+      p_msg_start->tones_parameter.sequence_duration = p_tones_parameter->sequence_duration;
+      p_msg_start->tones_parameter.period_duration = p_tones_parameter->period_duration;
+      p_msg_start->tones_parameter.repetition = p_tones_parameter->repetition;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("VM Record not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_vm_record_start function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_vm_record_stop                                     */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop a voice memorization Record     */
+  /*              generation                                                      */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_vm_record_stop (T_RV_RETURN return_path)
+  {
+    #if (VOICE_MEMO)
+      /* Declare local variables.                                                  */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_VM_RECORD_STOP    *p_msg  = NULL;
+
+    /************************ audio_vm_record_stop function begins *****************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_RECORD_STOP),
+                               (T_RVF_BUFFER **) (&p_msg));
+
+      /* If insufficient resources, then report a memory error and abort.          */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg);
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg->os_hdr.msg_id = AUDIO_VM_RECORD_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg->return_path.addr_id = return_path.addr_id;
+        p_msg->return_path.callback_func = NULL;
+      }
+       else
+      {
+        p_msg->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("VM Record not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_vm_record_Stop function *****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_sr_enroll_start                                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called to start the SR enrollment              */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        SR enrollment parameters                                              */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_sr_enroll_start (T_AUDIO_SR_ENROLL_PARAMETER *p_parameter,
+                                     T_RV_RETURN return_path)
+  {
+    #if (SPEECH_RECO)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_SR_ENROLL_START   *p_msg_start  = NULL;
+      char                      sr_name[AUDIO_SR_PATH_NAME_MAX_SIZE];
+      T_FFS_FD            ffs_fd, sr_ffs_fd;
+
+    /************************ audio_sr_enroll_start function begins ***************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* Check the speech sample parameter */
+      if ( (p_parameter->record_speech != AUDIO_SR_RECORD_SPEECH)     &&
+           (p_parameter->record_speech != AUDIO_SR_NO_RECORD_SPEECH) )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return(AUDIO_ERROR);
+      }
+
+      /* Create the speech recognition sample file name */
+      strcpy(sr_name, p_parameter->enroll_name);
+      strcat(sr_name,"_sr");
+
+      #ifndef _WINDOWS
+        sr_ffs_fd = ffs_open(sr_name,
+          FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+        if (sr_ffs_fd <= 0)
+        {
+          audio_sr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return(AUDIO_ERROR);
+      }
+      #else
+        sr_ffs_fd = 0x00000100;
+      #endif
+
+      /* Create the speech sample file if it's requested.*/
+      if (p_parameter->record_speech == AUDIO_SR_RECORD_SPEECH)
+      {
+      #ifndef _WINDOWS
+          ffs_fd = ffs_open(p_parameter->enroll_name,
+                      FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+        if (ffs_fd <= 0)
+        {
+            ffs_close(sr_ffs_fd);
+            audio_sr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+          return (AUDIO_ERROR);
+        }
+      #else
+          ffs_fd = 0x00000101;
+      #endif
+      }
+      else
+      {
+        ffs_fd = AUDIO_SR_NO_RECORD_SPEECH;
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_SR_ENROLL_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.               */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        #ifndef _WINDOWS
+          /* close the file previously open */
+          ffs_close(sr_ffs_fd);
+          if (p_parameter->record_speech == AUDIO_SR_RECORD_SPEECH)
+          {
+            ffs_close(ffs_fd);
+          }
+        #endif
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        #ifndef _WINDOWS
+          /* close the file previously open */
+          ffs_close(sr_ffs_fd);
+          if (p_parameter->record_speech == AUDIO_SR_RECORD_SPEECH)
+          {
+            ffs_close(ffs_fd);
+          }
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_SR_ENROLL_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->sr_ffs_fd = sr_ffs_fd;
+      p_msg_start->voice_ffs_fd = ffs_fd;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Speech Reco not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_enroll_Start function **********************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_sr_enroll_stop                                     */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop the SR enrollment               */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        SR enrollment parameters                                              */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_sr_enroll_stop (T_RV_RETURN return_path)
+  {
+    #if (SPEECH_RECO)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_SR_ENROLL_STOP   *p_msg_start  = NULL;
+
+    /************************ audio_sr_enroll_start function begins ***************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_SR_ENROLL_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.          */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_SR_ENROLL_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Speech Reco not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_sr_enroll_stop function *****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_sr_update_start                                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called to start the SR update                  */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        SR update parameters                                                  */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_sr_update_start (T_AUDIO_SR_UPDATE_PARAMETER *p_parameter,
+                                     T_RV_RETURN return_path)
+  {
+    #if (SPEECH_RECO)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_SR_UPDATE_START  *p_msg_start  = NULL;
+      UINT8                     i, folder_size=0, path_size;
+      char                      sr_name[AUDIO_SR_PATH_NAME_MAX_SIZE],
+                                sr_dir[AUDIO_SR_PATH_NAME_MAX_SIZE],
+                                *p_database;
+      INT8                      model_index, model_number;
+      #ifndef _WINDOWS
+        char                    *p_model_path;
+      #endif
+
+    /************************ audio_sr_update_start function begins ***************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* Check the speech sample parameter */
+      if ( (p_parameter->record_speech != AUDIO_SR_RECORD_SPEECH)     &&
+           (p_parameter->record_speech != AUDIO_SR_NO_RECORD_SPEECH) )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return(AUDIO_ERROR);
+      }
+
+      /* Create the speech recognition sample file name */
+      strcpy(sr_name, p_parameter->update_name);
+      strcat(sr_name,"_sr");
+
+      /* Check the number of speech reco model are included in the current folder */
+      /* in order to know if the update or the update check needs to be run */
+      path_size = (UINT8)strlen(p_parameter->update_name);
+      i = 0;
+      while (i < path_size)
+      {
+        if (strncmp(&(p_parameter->update_name[i]), "/", 1) == 0)
+        {
+          folder_size = i;
+        }
+        i++;
+      }
+      if ((folder_size + 1) == path_size)
+      {
+      /* this isn't a name but a folder */
+      audio_sr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return(AUDIO_ERROR);
+      }
+      /* Create the speech recognition folder name */
+      strncpy(sr_dir, p_parameter->update_name, folder_size);
+      sr_dir[folder_size] = 0;
+
+      /* check the number of model in the database */
+      model_number = audio_sr_create_vocabulary_database(sr_dir, (void **)(&p_database));
+      if (model_number == AUDIO_ERROR)
+      {
+        return(AUDIO_ERROR);
+      }
+
+      #ifndef _WINDOWS
+        /* find the index of the model to updae */
+        p_model_path = p_database;
+        model_index == -1;
+        for (i=0; i<model_number; i++)
+        {
+          if ( strcmp(p_model_path, sr_name) == 0 )
+          {
+            model_index = i;
+          }
+          p_model_path += AUDIO_PATH_NAME_MAX_SIZE;
+        }
+        if (model_index == -1)
+        /* no file correspoding to the model to update */
+        {
+          audio_sr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+          rvf_free_buf((T_RVF_BUFFER *)p_database);
+          return (AUDIO_ERROR);
+        }
+      #else
+        model_index = 0;
+      #endif
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_SR_UPDATE_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.               */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_database);
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        rvf_free_buf((T_RVF_BUFFER *)p_database);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_SR_UPDATE_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->vocabulary_size = model_number;
+      p_msg_start->model_index = model_index;
+      p_msg_start->p_database = p_database;
+      p_msg_start->record_speech = p_parameter->record_speech;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Speech Reco not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_sr_update_start function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_sr_update_stop                                     */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop the SR update   t               */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        SR update parameters                                                  */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_sr_update_stop (T_RV_RETURN return_path)
+  {
+    #if (SPEECH_RECO)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_SR_UPDATE_STOP   *p_msg_start  = NULL;
+
+    /************************ audio_sr_update_start function begins ***************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_SR_UPDATE_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.         */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_SR_UPDATE_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Speech Reco not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_sr_update_stop function *****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_sr_reco_start                                      */
+  /*                                                                              */
+  /*    Purpose:  This function is called to start the SR recognition             */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        SR update parameters                                                  */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_sr_reco_start (T_AUDIO_SR_RECO_PARAMETER *p_parameter,
+                                     T_RV_RETURN return_path)
+  {
+    #if (SPEECH_RECO)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_SR_RECO_START  *p_msg_start  = NULL;
+      INT8                      model_number;
+      void                      *p_database;
+
+      /************************ audio_sr_reco_start function begins ****************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the / is in the end of the directory */
+      if(strlen(p_parameter->database_directory) == 0)
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_BAD_DATABASE);
+        return(AUDIO_ERROR);
+      }
+      else if ( strncmp(&(p_parameter->database_directory[strlen(p_parameter->database_directory) - 1]),
+           "/", 1) == 0 )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_BAD_DATABASE);
+        return(AUDIO_ERROR);
+      }
+
+      /* check the number of model in the database */
+      model_number = audio_sr_create_vocabulary_database(p_parameter->database_directory,
+        (void **)(&p_database));
+      if (model_number == AUDIO_ERROR)
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_BAD_DATABASE);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_SR_RECO_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.               */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_database);
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        rvf_free_buf((T_RVF_BUFFER *)p_database);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_SR_RECO_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->vocabulary_size = model_number;
+      p_msg_start->p_database = p_database;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Speech Reco not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_sr_reco_Start function ******************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_sr_reco_stop                                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop the SR recognition              */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        SR reco parameters                                                    */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_sr_reco_stop (T_RV_RETURN return_path)
+  {
+    #if (SPEECH_RECO)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS           mb_status = RVF_GREEN;
+      T_AUDIO_SR_RECO_STOP   *p_msg_start  = NULL;
+
+    /************************ audio_sr_reco_stop function begins ******************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_SR_RECO_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.         */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_sr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_SR_RECO_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Speech Reco not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_sr_reco_stop function *******************/
+
+    /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_full_access_write                                  */
+  /*                                                                              */
+  /*    Purpose:  This function is called to configure the audio mode             */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        audio configuration                                                   */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_full_access_write (T_AUDIO_FULL_ACCESS_WRITE  *p_parameter,
+                                       T_RV_RETURN                return_path)
+  {
+    UINT8                               size;
+    INT8                                i;
+    T_RVF_MB_STATUS                     mb_status = RVF_GREEN;
+    T_AUDIO_MODE_FULL_ACCESS_WRITE_REQ  *p_msg_start  = NULL;
+    void                                *p_data_buffer = NULL;
+    INT8                                *p_read, *p_write;
+
+    /************************ audio_full_access_write function begins ***********************/
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* check if the data exist */
+    if (p_parameter->data == NULL)
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return(AUDIO_ERROR);
+    }
+
+    switch (p_parameter->variable_indentifier)
+    {
+      case AUDIO_PATH_USED:
+      {
+        if ( (*((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data) != AUDIO_GSM_VOICE_PATH) &&
+             (*((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data) != AUDIO_BLUETOOTH_CORDLESS_VOICE_PATH) &&
+             (*((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data) != AUDIO_BLUETOOTH_HEADSET) &&
+             (*((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data) != AUDIO_DAI_ENCODER) &&
+             (*((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data) != AUDIO_DAI_DECODER) &&
+             (*((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data) != AUDIO_DAI_ACOUSTIC) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(T_AUDIO_VOICE_PATH_SETTING);
+        break;
+      }
+      case AUDIO_MICROPHONE_MODE:
+      {
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_HANDHELD) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_HANDFREE) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_HEADSET) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_MICROPHONE_GAIN:
+      {
+        if (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_MUTE)
+        {
+          if ( (*((INT8  *)p_parameter->data) < -12) ||
+               (*((INT8  *)p_parameter->data) > 12) )
+          {
+            audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+            return (AUDIO_ERROR);
+          }
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_MICROPHONE_EXTRA_GAIN:
+      {
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_AUX_GAIN_28_2dB) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_AUX_GAIN_4_6dB) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_MICROPHONE_OUTPUT_BIAS:
+      {
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_OUTPUT_BIAS_2_0V) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_MICROPHONE_OUTPUT_BIAS_2_5V) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_MICROPHONE_FIR:
+      {
+        size = sizeof(T_AUDIO_FIR_COEF);
+        break;
+      }
+      case AUDIO_SPEAKER_MODE:
+      {
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_HANDHELD) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_HANDFREE) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_HEADSET) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_BUZZER) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_HANDHELD_HANDFREE) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_SPEAKER_GAIN:
+      {
+        if ( (*((INT8  *)p_parameter->data) < -6) ||
+             (*((INT8  *)p_parameter->data) > 6) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_SPEAKER_FILTER:
+      {
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_FILTER_ON) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_FILTER_OFF) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_SPEAKER_FIR:
+      {
+        size = sizeof(T_AUDIO_FIR_COEF);
+        break;
+      }
+      case AUDIO_SPEAKER_BUZZER_STATE:
+      {
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_BUZZER_ON) &&
+             (*((INT8  *)p_parameter->data) != AUDIO_SPEAKER_BUZZER_OFF) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE:
+      {
+        i = ((*((INT8  *)p_parameter->data))-1)%3;
+
+        if ( (*((INT8  *)p_parameter->data) != AUDIO_SIDETONE_OPEN) &&
+             ( (*((INT8  *)p_parameter->data) < -23) ||
+               (*((INT8  *)p_parameter->data) > 1)   ||
+               (i != 0) ) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(INT8 );
+        break;
+      }
+      case AUDIO_MICROPHONE_SPEAKER_LOOP_AEC:
+      {
+        T_AUDIO_AEC_CFG *aec_param;
+        aec_param = (T_AUDIO_AEC_CFG *)p_parameter->data;
+
+      #if (L1_NEW_AEC)
+        if ( ((aec_param->aec_enable != AUDIO_AEC_ENABLE) &&
+              (aec_param->aec_enable != AUDIO_AEC_DISABLE)) ||
+             ((aec_param->aec_visibility != AUDIO_AEC_VISIBILITY_ENABLE) &&
+              (aec_param->aec_visibility != AUDIO_AEC_VISIBILITY_DISABLE)) ||
+             ((aec_param->continuous_filtering != TRUE) &&
+              (aec_param->continuous_filtering != FALSE)) ||
+             ((aec_param->noise_suppression_enable != AUDIO_NOISE_SUPPRESSION_ENABLE) &&
+              (aec_param->noise_suppression_enable != AUDIO_NOISE_SUPPRESSION_DISABLE)) ||
+             ((aec_param->noise_suppression_level != AUDIO_NOISE_NO_LIMITATION) &&
+              (aec_param->noise_suppression_level != AUDIO_NOISE_6dB) &&
+              (aec_param->noise_suppression_level != AUDIO_NOISE_12dB) &&
+              (aec_param->noise_suppression_level != AUDIO_NOISE_18dB)) )
+      #else
+        if ( (aec_param->aec_enable != AUDIO_AEC_ENABLE) &&
+             (aec_param->aec_enable != AUDIO_AEC_DISABLE) &&
+             (aec_param->aec_mode != AUDIO_SHORT_ECHO) &&
+             (aec_param->aec_mode != AUDIO_LONG_ECHO) &&
+             (aec_param->echo_suppression_level != AUDIO_ECHO_0dB) &&
+             (aec_param->echo_suppression_level != AUDIO_ECHO_6dB) &&
+             (aec_param->echo_suppression_level != AUDIO_ECHO_12dB) &&
+             (aec_param->echo_suppression_level != AUDIO_ECHO_18dB) &&
+             (aec_param->noise_suppression_enable != AUDIO_NOISE_SUPPRESSION_ENABLE) &&
+             (aec_param->noise_suppression_enable != AUDIO_NOISE_SUPPRESSION_DISABLE) &&
+             (aec_param->noise_suppression_level != AUDIO_NOISE_NO_LIMITATION) &&
+             (aec_param->noise_suppression_enable != AUDIO_NOISE_6dB) &&
+             (aec_param->noise_suppression_level != AUDIO_NOISE_12dB) &&
+             (aec_param->noise_suppression_level != AUDIO_NOISE_18dB) )
+      #endif
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(T_AUDIO_AEC_CFG);
+        break;
+      }
+      case AUDIO_SPEAKER_VOLUME_LEVEL:
+      {
+        if ( (((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data)->audio_speaker_level != AUDIO_SPEAKER_VOLUME_MUTE) &&
+             (((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data)->audio_speaker_level != AUDIO_SPEAKER_VOLUME_0dB) &&
+             (((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data)->audio_speaker_level != AUDIO_SPEAKER_VOLUME_6dB) &&
+             (((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data)->audio_speaker_level != AUDIO_SPEAKER_VOLUME_12dB) &&
+             (((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data)->audio_speaker_level != AUDIO_SPEAKER_VOLUME_18dB) &&
+             (((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data)->audio_speaker_level != AUDIO_SPEAKER_VOLUME_24dB) )
+        {
+          audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+          return (AUDIO_ERROR);
+        }
+
+        size = sizeof(T_AUDIO_SPEAKER_LEVEL);
+        break;
+      }
+      default :
+      {
+        audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return (AUDIO_ERROR);
+      }
+    }
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                             sizeof (T_AUDIO_MODE_FULL_ACCESS_WRITE_REQ),
+                             (T_RVF_BUFFER **) (&p_msg_start));
+
+    /* If insufficient resources, then report a memory error and abort.               */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* allocate the memory for the data to write */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                             size,
+                             (T_RVF_BUFFER **) (&p_data_buffer));
+
+    /* If insufficient resources, then report a memory error and abort.               */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+      rvf_free_buf((T_RVF_BUFFER *)p_data_buffer);
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill the message parameters */
+    p_msg_start->audio_parameter.data = p_data_buffer;
+
+    p_read  = (INT8 *)(p_parameter->data);
+    p_write = (INT8 *)p_data_buffer;
+    for (i=0; i<size; i++)
+    {
+      *p_write++ = *p_read++;
+    }
+
+    p_msg_start->audio_parameter.variable_indentifier = p_parameter->variable_indentifier;
+
+    /* fill the message id */
+    p_msg_start->os_hdr.msg_id    = AUDIO_MODE_WRITE_REQ;
+
+    /* fill the task source id */
+    p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+    p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg_start->return_path.addr_id = return_path.addr_id;
+      p_msg_start->return_path.callback_func = NULL;
+    }
+    else
+    {
+      p_msg_start->return_path.callback_func = return_path.callback_func;
+    }
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId,
+                  p_msg_start);
+
+    return (AUDIO_OK);
+    /************************ Enf of audio_full_access_write function ***********************/
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_full_access_read                                   */
+  /*                                                                              */
+  /*    Purpose:  This function is called to read the current audio mode.         */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        Status                                                                */
+  /*        Audio settings                                                        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_full_access_read (T_AUDIO_FULL_ACCESS_READ *p_parameter)
+  {
+    T_AUDIO_RET status = AUDIO_ERROR;
+
+    /************************ audio_full_access_write function begins ***********************/
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    switch (p_parameter->variable_indentifier)
+    {
+      case AUDIO_PATH_USED:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: voice path", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_voice_path_read((T_AUDIO_VOICE_PATH_SETTING *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_MODE:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: microphone mode", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_microphone_mode_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_GAIN:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: microphone gain", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_microphone_gain_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_EXTRA_GAIN:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: microphone extra gain", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_microphone_extra_gain_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_OUTPUT_BIAS:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: output bias", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_microphone_output_bias_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_FIR:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: microphone FIR", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_microphone_fir_read((T_AUDIO_FIR_COEF *)p_parameter->data);
+        break;
+      }
+      case AUDIO_SPEAKER_MODE:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: speaker mode", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_speaker_mode_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_SPEAKER_GAIN:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: speaker gain", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_speaker_gain_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_SPEAKER_FILTER:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: speaker filter", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_speaker_filter_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_SPEAKER_FIR:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: speaker_FIR", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_speaker_fir_read((T_AUDIO_FIR_COEF *)p_parameter->data);
+        break;
+      }
+      case AUDIO_SPEAKER_BUZZER_STATE:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: speaker buzzer", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_speaker_buzzer_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: sidetone gain", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_sidetone_gain_read((INT8 *)p_parameter->data);
+        break;
+      }
+      case AUDIO_MICROPHONE_SPEAKER_LOOP_AEC:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: AEC", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_aec_read((T_AUDIO_AEC_CFG *)p_parameter->data);
+        break;
+      }
+      case AUDIO_SPEAKER_VOLUME_LEVEL:
+      {
+        AUDIO_SEND_TRACE("AUDIO MODE FULL ACCESS READ: volume", RV_TRACE_LEVEL_DEBUG_LOW);
+        status = audio_mode_speaker_volume_read((T_AUDIO_SPEAKER_LEVEL *)p_parameter->data);
+        break;
+      }
+    }
+
+    return(status);
+
+    /************************ Enf of audio_full_access_write function ***********************/
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_mode_save                                          */
+  /*                                                                              */
+  /*    Purpose:  This function is called to save the current audio mode.         */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        audio mode file name.                                                 */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        Status                                                                */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_mode_save (T_AUDIO_MODE_SAVE *p_parameter, T_RV_RETURN return_path)
+  {
+    /************************ audio_full_access_write function begins ***********************/
+    char                  audio_mode_path_name[AUDIO_PATH_NAME_MAX_SIZE];
+    T_FFS_FD              audio_mode_ffs_fd, audio_volume_ffs_fd;
+    T_AUDIO_MODE_SAVE_REQ *p_msg_start;
+    T_RVF_MB_STATUS       mb_status = RVF_GREEN;
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* Create the audio mode path name */
+    audio_mode_path_name[0] = 0;
+    strcpy(audio_mode_path_name,"/aud/");
+    strcpy(&(audio_mode_path_name[5]), p_parameter->audio_mode_filename);
+    strcat(audio_mode_path_name,".cfg");
+
+    /* Open the FFS file */
+    #ifndef _WINDOWS
+      audio_mode_ffs_fd = ffs_open(audio_mode_path_name,
+        FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+      if (audio_mode_ffs_fd <= 0)
+      {
+        audio_mode_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return(AUDIO_ERROR);
+    }
+    #else
+      audio_mode_ffs_fd = 0x00000110;
+    #endif
+
+    /* Create the volume path name */
+    audio_mode_path_name[5] = 0;
+    strcpy(&(audio_mode_path_name[5]), p_parameter->audio_mode_filename);
+    strcat(audio_mode_path_name,".vol");
+
+    /* Open the FFS file */
+    #ifndef _WINDOWS
+      audio_volume_ffs_fd = ffs_open(audio_mode_path_name,
+        FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+      if (audio_volume_ffs_fd <= 0)
+      {
+        ffs_close(audio_mode_ffs_fd);
+        audio_mode_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return(AUDIO_ERROR);
+    }
+    #else
+      audio_volume_ffs_fd = 0x00000111;
+    #endif
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                             sizeof (T_AUDIO_MODE_SAVE_REQ),
+                             (T_RVF_BUFFER **) (&p_msg_start));
+
+    /* If insufficient resources, then report a memory error and abort.               */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill the message parameters */
+    p_msg_start->audio_ffs_fd = audio_mode_ffs_fd;
+    p_msg_start->audio_volume_ffs_fd = audio_volume_ffs_fd;
+
+    /* fill the message id */
+    p_msg_start->os_hdr.msg_id    = AUDIO_MODE_SAVE_REQ;
+
+    /* fill the task source id */
+    p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+    p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg_start->return_path.addr_id = return_path.addr_id;
+      p_msg_start->return_path.callback_func = NULL;
+    }
+    else
+    {
+      p_msg_start->return_path.callback_func = return_path.callback_func;
+    }
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId,
+                  p_msg_start);
+
+    return (AUDIO_OK);
+    /************************ Enf of audio_full_access_write function ***********************/
+  }
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_mode_save                                          */
+  /*                                                                              */
+  /*    Purpose:  This function is called to load an audio mode.                  */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        audio mode file name.                                                 */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        Status                                                                */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_mode_load (T_AUDIO_MODE_LOAD *p_parameter, T_RV_RETURN return_path)
+  {
+    /************************ audio_full_access_write function begins ***********************/
+    char                  audio_path_name[AUDIO_PATH_NAME_MAX_SIZE];
+    T_FFS_FD              audio_mode_ffs_fd, audio_volume_ffs_fd;
+    T_AUDIO_MODE_LOAD_REQ *p_msg_start;
+    T_RVF_MB_STATUS       mb_status = RVF_GREEN;
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* Create the audio mode path name */
+    audio_path_name[0] = 0;
+    strcpy(audio_path_name,"/aud/");
+    strcpy(&(audio_path_name[5]), p_parameter->audio_mode_filename);
+    strcat(audio_path_name,".cfg");
+
+    /* Open the FFS file */
+    #ifndef _WINDOWS
+      audio_mode_ffs_fd = ffs_open(audio_path_name,
+        FFS_O_RDONLY);
+      if (audio_mode_ffs_fd <= 0)
+      {
+        audio_mode_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return(AUDIO_ERROR);
+      }
+    #else
+      audio_mode_ffs_fd = 0x00001000;
+    #endif
+
+    /* Create the volume path name */
+    audio_path_name[5] = 0;
+    strcpy(&(audio_path_name[5]), p_parameter->audio_mode_filename);
+    strcat(audio_path_name,".vol");
+
+    /* Open the FFS file */
+    #ifndef _WINDOWS
+      audio_volume_ffs_fd = ffs_open(audio_path_name,
+        FFS_O_RDONLY);
+      if (audio_volume_ffs_fd <= 0)
+      {
+        ffs_close(audio_mode_ffs_fd);
+        audio_mode_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return(AUDIO_ERROR);
+      }
+    #else
+      audio_volume_ffs_fd = 0x00001001;
+    #endif
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                             sizeof (T_AUDIO_MODE_LOAD_REQ),
+                             (T_RVF_BUFFER **) (&p_msg_start));
+
+    /* If insufficient resources, then report a memory error and abort. */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill the message parameters */
+    p_msg_start->audio_ffs_fd = audio_mode_ffs_fd;
+    p_msg_start->audio_volume_ffs_fd = audio_volume_ffs_fd;
+    strcpy(p_msg_start->audio_volume_path_name , audio_path_name);
+
+    /* fill the message id */
+    p_msg_start->os_hdr.msg_id    = AUDIO_MODE_LOAD_REQ;
+
+    /* fill the task source id */
+    p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+    p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg_start->return_path.addr_id = return_path.addr_id;
+      p_msg_start->return_path.callback_func = NULL;
+    }
+    else
+    {
+      p_msg_start->return_path.callback_func = return_path.callback_func;
+    }
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId,
+                  p_msg_start);
+
+    return (AUDIO_OK);
+    /************************ Enf of audio_full_access_write function ***********************/
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_speaker_volume                                     */
+  /*                                                                              */
+  /*    Purpose:  This function is called to change the current speaker volume.   */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        speaker volume command.                                               */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        Status                                                                */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_speaker_volume (T_AUDIO_SPEAKER_VOLUME volume, T_RV_RETURN return_path)
+  {
+    /************************ audio_speaker_volume function begins ***********************/
+    T_AUDIO_SPEAKER_VOLUME_REQ *p_msg_start;
+    T_RVF_MB_STATUS       mb_status = RVF_GREEN;
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* Check if an audio mode is already loaded */
+    if (p_audio_gbl_var->audio_mode_var.audio_volume_var.audio_volume_path_name[0] == 0)
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_AUDIO_MODE_NO_LOADED);
+      return (AUDIO_ERROR);
+    }
+
+    /* Check parameters */
+    if ( (volume.volume_action != AUDIO_SPEAKER_VOLUME_INCREASE) &&
+         (volume.volume_action != AUDIO_SPEAKER_VOLUME_DECREASE) &&
+         (volume.volume_action != AUDIO_SPEAKER_VOLUME_SET) )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return (AUDIO_ERROR);
+    }
+
+    if ( (volume.value != AUDIO_SPEAKER_VOLUME_MUTE) &&
+         (volume.value != AUDIO_SPEAKER_VOLUME_24dB) &&
+         (volume.value != AUDIO_SPEAKER_VOLUME_18dB) &&
+         (volume.value != AUDIO_SPEAKER_VOLUME_12dB) &&
+         (volume.value != AUDIO_SPEAKER_VOLUME_6dB)  &&
+         (volume.value != AUDIO_SPEAKER_VOLUME_0dB) )
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return (AUDIO_ERROR);
+    }
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                             sizeof (T_AUDIO_SPEAKER_VOLUME_REQ),
+                             (T_RVF_BUFFER **) (&p_msg_start));
+
+    /* If insufficient resources, then report a memory error and abort. */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_mode_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill the message parameters */
+    p_msg_start->volume.value         = volume.value;
+    p_msg_start->volume.volume_action = volume.volume_action;
+
+    /* fill the message id */
+    p_msg_start->os_hdr.msg_id    = AUDIO_SPEAKER_VOLUME_REQ;
+
+    /* fill the task source id */
+    p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+    p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg_start->return_path.addr_id = return_path.addr_id;
+      p_msg_start->return_path.callback_func = NULL;
+    }
+    else
+    {
+      p_msg_start->return_path.callback_func = return_path.callback_func;
+    }
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId,
+                  p_msg_start);
+
+    return (AUDIO_OK);
+    /************************ Enf of audio_full_access_write function ***********************/
+  }
+
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_melody_E2_start                                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called to initiate the melody E2 generation    */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Melody E2 Parameters,                                           */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the melody E2 parameters.                              */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_melody_E2_start (T_AUDIO_MELODY_E2_PARAMETER *p_parameter,
+                                     T_RV_RETURN return_path)
+  {
+    #if (MELODY_E2)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS         mb_status    = RVF_GREEN;
+      T_AUDIO_MELODY_E2_START *p_msg_start = NULL;
+
+      T_FFS_FD               ffs_fd;
+
+    /************************ audio_melody_E2_start function begins ****************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the melody E2 file exist */
+      #ifndef _WINDOWS
+        ffs_fd = ffs_open(p_parameter->melody_E2_name, FFS_O_RDONLY);
+        if (ffs_fd <= 0)
+        {
+          audio_melody_E2_error_trace(AUDIO_ENTITY_FILE_ERROR);
+          return (AUDIO_ERROR);
+        }
+      #else
+        ffs_fd = 0x00001010;
+      #endif
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_MELODY_E2_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.*/
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NO_MEMORY);
+
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_MELODY_E2_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      /* the ffs_fd */
+      p_msg_start->audio_E2_ffs_fd = ffs_fd;
+
+      /* the name */
+      strcpy(p_msg_start->melody_E2_parameter.melody_E2_name,
+             p_parameter->melody_E2_name);
+
+      /* the loopback */
+      if ( (p_parameter->E2_loopback == AUDIO_MELODY_NO_LOOPBACK) ||
+           (p_parameter->E2_loopback == AUDIO_MELODY_LOOPBACK) )
+      {
+        p_msg_start->melody_E2_parameter.E2_loopback = p_parameter->E2_loopback;
+      }
+      else
+      {
+        /* Wrong parameter */
+        audio_melody_E2_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      /* the melody mode */
+      if ( (p_parameter->melody_E2_mode == AUDIO_MELODY_GAME_MODE) ||
+           (p_parameter->melody_E2_mode == AUDIO_MELODY_NORMAL_MODE) )
+      {
+        p_msg_start->melody_E2_parameter.melody_E2_mode = p_parameter->melody_E2_mode;
+      }
+      else
+      {
+        /* Wrong parameter */
+        audio_melody_E2_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        /* close the file previously open */
+        #ifndef _WINDOWS
+          ffs_close(ffs_fd);
+        #endif
+        return (AUDIO_ERROR);
+      }
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg_start);
+
+      return (AUDIO_OK);
+    #else
+      AUDIO_SEND_TRACE("Melody E2 not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_melody_E2_Start function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_melody_E2_stop                                     */
+  /*                                                                              */
+  /*    Purpose:  This function is called to stop a melody_E2 generation          */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Audio Melody E2 Parameters,                                           */
+  /*        Return path.                                                          */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the melody E2 parameters.                              */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_melody_E2_stop (T_AUDIO_MELODY_E2_STOP_PARAMETER *p_parameter,
+                                    T_RV_RETURN return_path)
+  {
+    #if (MELODY_E2)
+      /* Declare local variables.                                                 */
+      T_RVF_MB_STATUS        mb_status = RVF_GREEN;
+      T_AUDIO_MELODY_E2_STOP *p_msg    = NULL;
+
+      /********************** audio_melody_E2_stop function begins ****************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_MELODY_E2_STOP),
+                               (T_RVF_BUFFER **) (&p_msg));
+
+      /* If insufficient resources, then report a memory error and abort */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg);
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else
+      if (mb_status == RVF_RED)
+      {
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg->os_hdr.msg_id = AUDIO_MELODY_E2_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+
+      /* fill the message parameters */
+      /* the name */
+      strcpy(p_msg->melody_E2_name,
+             p_parameter->melody_E2_name);
+
+      /* the return path */
+      if (return_path.callback_func == NULL)
+      {
+        p_msg->return_path.addr_id = return_path.addr_id;
+        p_msg->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId,
+                    p_msg);
+
+      return (AUDIO_OK);
+
+    #else
+      AUDIO_SEND_TRACE("Melody E2 not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*********************** End of audio_melody_E2_Stop function *****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_melody_E2_load_file_instruments                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to load the instruments file   */
+  /*              used in the melody E2 format (.lsi file)                        */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        File name of the melody.                                              */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the melody E2 load file instruments parameters.        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_melody_E2_load_file_instruments (
+                 T_AUDIO_MELODY_E2_LOAD_FILE_INSTR_PARAMETER *p_parameter)
+  {
+    #if (MELODY_E2)
+      /**** Declare local variables  ****/
+      #ifndef _WINDOWS
+         /* FFS File descriptor type */
+         T_FFS_FD     ffs_fd_1, ffs_fd_2;
+         T_FFS_STAT   stat;
+         T_FFS_SIZE   size = 0;
+
+         INT8 i;
+
+         /* basic structure of the .lsi file */
+         T_AUDIO_MELODY_E2_ID_NAME file_E2;
+      #endif
+       /* Nb of instruments in the .lsi file */
+       INT8 nb_of_instruments = 0;
+
+
+      /*************** audio_melody_E2_load_file_instruments function begins ********/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_melody_E2_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* Before to start the file download, check if the melody is OFF */
+      if ((p_audio_gbl_var->melody_E2_0.state != AUDIO_MELODY_E2_IDLE ) &&
+          (p_audio_gbl_var->melody_E2_1.state != AUDIO_MELODY_E2_IDLE ))
+      {
+         /* The instrument file can't be downloaded */
+         audio_melody_E2_error_trace (AUDIO_ERROR_DOWNLOAD);
+         return (AUDIO_ERROR);
+      }
+
+      /**** Find the size of the .lsi file ****/
+      /* the .lsi file is stores into the flash */
+      /* check if the .lsi file exists */
+      #ifndef _WINDOWS
+
+         ffs_fd_1 = ffs_open(p_parameter->melody_E2_file_name, FFS_O_RDONLY );
+
+         if (ffs_fd_1 < EFFS_OK)
+         {
+            audio_melody_E2_error_trace(AUDIO_ENTITY_LOAD_FILE_INSTR_ERROR);
+            return (AUDIO_ERROR);
+         }
+
+         ffs_stat(p_parameter->melody_E2_file_name,&stat);
+
+
+         /* check if the file contains some data */
+         if (stat.size ==0)
+         {
+           /* the file doesn't contains data */
+           /* an error is generated */
+           audio_melody_E2_error_trace(AUDIO_ENTITY_FILE_ERROR);
+           return(AUDIO_ERROR);
+         }
+
+         /* the file exists and contains data */
+         /* Nb of instruments in the file */
+         nb_of_instruments = stat.size / (sizeof(T_AUDIO_MELODY_E2_ID_NAME));
+
+
+         /**** check if the melody E2 load instruments files (.mwa file) exist ****/
+         /* open the .mwa file */
+          for (i=0;i< nb_of_instruments;i++)
+          {
+             /* Load the instruments file from the FFS */
+             if (ffs_read ( ffs_fd_1,
+                              (&file_E2),
+                              (sizeof(INT8) + AUDIO_PATH_NAME_MAX_SIZE)) < EFFS_OK )
+            {
+                AUDIO_SEND_TRACE("AUDIO MELODY E2: impossible to load the .lsi file", RV_TRACE_LEVEL_ERROR);
+
+                /* Close the file */
+                ffs_close(ffs_fd_1);
+
+                return (AUDIO_ERROR);
+             }
+
+             ffs_fd_2 = ffs_open( file_E2.melody_name,
+                                  FFS_O_RDONLY );
+
+             if (ffs_fd_2 < EFFS_OK)
+             {
+                AUDIO_SEND_TRACE("AUDIO MELODY E2: impossible to open the .mwa file instruments", RV_TRACE_LEVEL_ERROR);
+
+                /* Close the .mwa file */
+                ffs_close(ffs_fd_1);
+                ffs_close(ffs_fd_2);
+
+                return (AUDIO_ERROR);
+             }
+
+             /* Close the file */
+             ffs_close(ffs_fd_2);
+         }
+         ffs_close(ffs_fd_1);
+      #endif
+
+      /* Copy the new .lsi name */
+      strcpy (p_audio_gbl_var->melody_E2_load_file_instruments.instrument_file_name,
+              p_parameter->melody_E2_file_name);
+
+      /* Copy the number of instrument listed by this .lsi file */
+      p_audio_gbl_var->melody_E2_load_file_instruments.nb_of_instruments
+        = nb_of_instruments;
+
+      p_audio_gbl_var->melody_E2_load_file_instruments.file_downloaded = TRUE;
+
+      return (AUDIO_OK);
+
+    #else
+      AUDIO_SEND_TRACE("Melody E2 not compiled", RV_TRACE_LEVEL_ERROR);
+      return (AUDIO_ERROR);
+    #endif
+  } /*************** End of audio_melody_E2_load_file_instrument function **************/
+
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_amr_record_to_ffs_start/stop                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to start/stop the recording of */
+  /*              a AMR-MMS in Flash                                              */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Record parameters                                                     */
+  /*        Return_path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters.                                        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_amr_record_to_ffs_start (T_AUDIO_AMR_RECORD_TO_FFS_PARAMETER *p_record_parameter,
+                                             T_RV_RETURN return_path)
+  {
+    #if (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_RECORD_TO_FFS_START *p_msg_start = NULL;
+      T_RVF_MB_STATUS                     mb_status = RVF_GREEN;
+      T_FFS_FD                            ffs_fd;
+
+      /************************ audio_amr_record_to_ffs_start function begins **************/
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the voice memo record file already exists */
+      ffs_fd = ffs_open(p_record_parameter->memo_name,
+                 FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+      if ( ffs_fd <= 0)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return (AUDIO_ERROR);
+      }
+
+      /* check parameters */
+      if ( ((p_record_parameter->compression_mode != AUDIO_AMR_NO_COMPRESSION_MODE ) &&
+            (p_record_parameter->compression_mode != AUDIO_AMR_COMPRESSION_MODE ))||
+            ((p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_4_75) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_15) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_90) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_6_70) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_40) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_95) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_10_2) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_12_2))
+         )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_RECORD_TO_FFS_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_AMR_RECORD_TO_FFS_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd       = ffs_fd;
+      p_msg_start->compression_mode   = p_record_parameter->compression_mode;
+      p_msg_start->memo_duration      = p_record_parameter->memo_duration;
+      p_msg_start->microphone_gain    = p_record_parameter->microphone_gain;
+      p_msg_start->amr_vocoder        = p_record_parameter->amr_vocoder;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_start);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_record_to_ffs_start function ****************/
+
+  T_AUDIO_RET audio_amr_record_to_ffs_stop (void)
+  {
+    #if (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_RECORD_STOP *p_msg_stop = NULL;
+      T_RVF_MB_STATUS            mb_status   = RVF_GREEN;
+
+      /************************ audio_amr_record_to_ffs_stop function begins **************/
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_RECORD_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_stop));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_stop);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_stop->os_hdr.msg_id    = AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_stop->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_stop->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_stop);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_record_to_ffs_stop function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_mms_record_to_ffs_start/stop                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to start/stop the recording of */
+  /*              a AMR-MMS in Flash (MMS header added)                           */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Record parameters                                                     */
+  /*        Return_path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters.                                        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_mms_record_to_ffs_start (T_AUDIO_MMS_RECORD_TO_FFS_PARAMETER *p_record_parameter,
+                                             T_RV_RETURN return_path)
+  {
+    #if (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_RECORD_TO_FFS_START *p_msg_start = NULL;
+      T_RVF_MB_STATUS                     mb_status = RVF_GREEN;
+      T_FFS_FD                            ffs_fd;
+      UINT8                               temp[6] = "#!AMR\n";
+
+      /************************ audio_amr_record_to_ffs_start function begins **************/
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the voice memo record file already exists */
+      ffs_fd = ffs_open(p_record_parameter->memo_name,
+                 FFS_O_CREATE | FFS_O_WRONLY | FFS_O_TRUNC | FFS_O_APPEND);
+      if ( ffs_fd <= 0)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return (AUDIO_ERROR);
+      }
+
+      /* check parameters */
+      if ( ((p_record_parameter->compression_mode != AUDIO_AMR_NO_COMPRESSION_MODE ) &&
+            (p_record_parameter->compression_mode != AUDIO_AMR_COMPRESSION_MODE ))||
+            ((p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_4_75) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_15) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_90) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_6_70) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_40) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_95) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_10_2) &&
+             (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_12_2))
+         )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_RECORD_TO_FFS_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_AMR_RECORD_TO_FFS_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd       = ffs_fd;
+      p_msg_start->compression_mode   = p_record_parameter->compression_mode;
+      p_msg_start->memo_duration      = p_record_parameter->memo_duration;
+      p_msg_start->microphone_gain    = p_record_parameter->microphone_gain;
+      p_msg_start->amr_vocoder        = p_record_parameter->amr_vocoder;
+
+      // write magix string #!AMR\n
+      ffs_write(ffs_fd, temp, 6);
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_start);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_mms_record_to_ffs_start function ****************/
+
+  T_AUDIO_RET audio_mms_record_to_ffs_stop (void)
+  {
+    return audio_amr_record_to_ffs_stop();
+  } /*********************** End of audio_mms_record_to_ffs_stop function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_amr_play_from_ffs_start/stop                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to start/stop the playing of   */
+  /*              a AMR-MMS from Flash                                            */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Play parameters                                                       */
+  /*        Return_path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters.                                        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_amr_play_from_ffs_start (T_AUDIO_AMR_PLAY_FROM_FFS_PARAMETER *p_play_parameter,
+                                             T_RV_RETURN return_path)
+  {
+    #if (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_PLAY_FROM_FFS_START *p_msg_start = NULL;
+      T_RVF_MB_STATUS                    mb_status = RVF_GREEN;
+      T_FFS_FD                           ffs_fd;
+
+      /************************ audio_amr_play_from_ffs_start function begins **************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the voice memo play file already exists        */
+      ffs_fd = ffs_open(p_play_parameter->memo_name, FFS_O_RDONLY);
+      if ( ffs_fd <= 0)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_PLAY_FROM_FFS_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_AMR_PLAY_FROM_FFS_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd        = ffs_fd;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_start);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_play_from_ffs_start function ****************/
+
+  T_AUDIO_RET audio_amr_play_from_ffs_stop (void)
+  {
+    #if (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_PLAY_STOP *p_msg_stop = NULL;
+      T_RVF_MB_STATUS                    mb_status = RVF_GREEN;
+
+      /************************ audio_amr_play_from_ffs_stop function begins **************/
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_PLAY_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_stop));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_stop);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_stop->os_hdr.msg_id    = AUDIO_VM_AMR_PLAY_FROM_FFS_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_stop->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg_stop->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_stop);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_play_from_ffs_stop function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_mms_play_from_ffs_start/stop                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to start/stop the playing of   */
+  /*              a AMR-MMS from Flash (MMS header handled)                       */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Play parameters                                                       */
+  /*        Return_path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters.                                        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_mms_play_from_ffs_start (T_AUDIO_MMS_PLAY_FROM_FFS_PARAMETER *p_play_parameter,
+                                             T_RV_RETURN return_path)
+  {
+    #if (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_PLAY_FROM_FFS_START *p_msg_start = NULL;
+      T_RVF_MB_STATUS                    mb_status = RVF_GREEN;
+      T_FFS_FD                           ffs_fd;
+      UINT8                              temp[6];
+
+      /************************ audio_amr_play_from_ffs_start function begins **************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check if the voice memo play file already exists        */
+      ffs_fd = ffs_open(p_play_parameter->memo_name, FFS_O_RDONLY);
+      if ( ffs_fd <= 0)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_FILE_ERROR);
+        return (AUDIO_ERROR);
+      }
+      // read magic string #!AMR\n
+      ffs_read(ffs_fd, temp, 6);
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_PLAY_FROM_FFS_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        ffs_close(ffs_fd);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_AMR_PLAY_FROM_FFS_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->audio_ffs_fd        = ffs_fd;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_start);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_NEW_FFS_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_mms_play_from_ffs_start function ****************/
+
+  T_AUDIO_RET audio_mms_play_from_ffs_stop (void)
+  {
+    return audio_amr_play_from_ffs_stop();
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_amr_record_to_ram_start/stop                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to record a MMS                */
+  /*              in RAM                                                          */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Record Parameters                                                     */
+  /*        Return_path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters.                                        */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_amr_record_to_ram_start (T_AUDIO_AMR_RECORD_TO_RAM_PARAMETER *p_record_parameter,
+                                             T_RV_RETURN return_path)
+  {
+    #if (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_RECORD_TO_RAM_START *p_msg_start = NULL;
+      T_RVF_MB_STATUS                     mb_status = RVF_GREEN;
+
+      /************************ audio_amr_record_to_ram_start function begins **************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      if ( (p_record_parameter->p_buffer == NULL) ||
+           ((p_record_parameter->compression_mode != AUDIO_AMR_NO_COMPRESSION_MODE ) &&
+            (p_record_parameter->compression_mode != AUDIO_AMR_COMPRESSION_MODE ))||
+           ((p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_4_75) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_15) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_90) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_6_70) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_40) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_95) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_10_2) &&
+            (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_12_2))
+         )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_RECORD_TO_RAM_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_AMR_RECORD_TO_RAM_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->p_buffer           = p_record_parameter->p_buffer;
+      p_msg_start->compression_mode   = p_record_parameter->compression_mode;
+      p_msg_start->memo_duration      = p_record_parameter->memo_duration;
+      p_msg_start->microphone_gain    = p_record_parameter->microphone_gain;
+      p_msg_start->amr_vocoder        = p_record_parameter->amr_vocoder;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_start);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_record_to_ram_start function ****************/
+
+  T_AUDIO_RET audio_amr_record_to_ram_stop (void)
+  {
+    #if (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_RECORD_STOP *p_msg_stop = NULL;
+      T_RVF_MB_STATUS                     mb_status = RVF_GREEN;
+
+      /************************ audio_amr_record_to_ram_stop function begins **************/
+
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_RECORD_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_stop));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_stop);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_stop->os_hdr.msg_id    = AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_stop->os_hdr.src_addr_id = rvf_get_taskid();
+      p_msg_stop->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_stop);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_record_to_ram_stop function ****************/
+
+  T_AUDIO_RET audio_amr_play_from_ram_start (T_AUDIO_AMR_PLAY_FROM_RAM_PARAMETER *p_play_parameter,
+                                             T_RV_RETURN return_path)
+  {
+    #if (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_PLAY_FROM_RAM_START *p_msg_start = NULL;
+      T_RVF_MB_STATUS                    mb_status = RVF_GREEN;
+
+      /************************ audio_amr_play_from_ram_start function begins **************/
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* check parameters */
+      if (p_play_parameter->p_buffer == NULL)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+        return (AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_PLAY_FROM_RAM_START),
+                               (T_RVF_BUFFER **) (&p_msg_start));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_start);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_start->os_hdr.msg_id    = AUDIO_VM_AMR_PLAY_FROM_RAM_START_REQ;
+
+      /* fill the address source id */
+      p_msg_start->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg_start->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* fill the message parameters */
+      p_msg_start->p_buffer        = p_play_parameter->p_buffer;
+      p_msg_start->buffer_size     = p_play_parameter->buffer_size;
+
+      if (return_path.callback_func == NULL)
+      {
+        p_msg_start->return_path.addr_id = return_path.addr_id;
+        p_msg_start->return_path.callback_func = NULL;
+      }
+      else
+      {
+        p_msg_start->return_path.callback_func = return_path.callback_func;
+      }
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_start);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_play_from_ram_start function ****************/
+
+  T_AUDIO_RET audio_amr_play_from_ram_stop (void)
+  {
+    #if (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      /* Declare local variables. */
+      T_AUDIO_VM_AMR_PLAY_STOP *p_msg_stop = NULL;
+      T_RVF_MB_STATUS                    mb_status = RVF_GREEN;
+
+      /************************ audio_amr_play_from_ram_stop function begins **************/
+      if (p_audio_gbl_var == NULL )
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NOT_START);
+        return(AUDIO_ERROR);
+      }
+
+      /* allocate the memory for the message to send */
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_VM_AMR_PLAY_STOP),
+                               (T_RVF_BUFFER **) (&p_msg_stop));
+
+      /* If insufficient resources, then report a memory error and abort.      */
+      if (mb_status == RVF_YELLOW)
+      {
+        /* deallocate the memory */
+        rvf_free_buf((T_RVF_BUFFER *)p_msg_stop);
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+      else if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        return (AUDIO_ERROR);
+      }
+
+      /* fill the message id */
+      p_msg_stop->os_hdr.msg_id    = AUDIO_VM_AMR_PLAY_FROM_RAM_STOP_REQ;
+
+      /* fill the address source id */
+      p_msg_stop->os_hdr.src_addr_id  = rvf_get_taskid();
+      p_msg_stop->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+      /* send the messsage to the audio entity */
+      rvf_send_msg (p_audio_gbl_var->addrId, p_msg_stop);
+
+      return (AUDIO_OK);
+    #else // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+      AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    #endif // (AUDIO_RAM_MANAGER)&&(L1_VOICE_MEMO_AMR)
+  } /*********************** End of audio_amr_play_from_ram_stop function ****************/
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_driver_init_vm_amr_record_session                  */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to initialize VM AMR record    */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Specific VM AMR record parameters                                     */
+  /*        Driver parameters                                                     */
+  /*        Return path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters                                         */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_driver_init_vm_amr_record_session(T_AUDIO_DRIVER_VM_AMR_RECORD_PARAMETER *p_record_parameter,
+                                                      T_AUDIO_DRIVER_PARAMETER *p_driver_parameter,
+                                                      T_RV_RETURN return_path)
+  {
+  #if (L1_VOICE_MEMO_AMR)
+    /* Declare local variables.                                                 */
+    T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+    T_AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION *p_msg  = NULL;
+
+    /************************ function begins ****************/
+
+    /* check entity started */
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* If bad voice memo record parameters, then report an error and abort.*/
+    if ( ((p_record_parameter->compression_mode != AUDIO_AMR_NO_COMPRESSION_MODE ) &&
+          (p_record_parameter->compression_mode != AUDIO_AMR_COMPRESSION_MODE ))||
+         ((p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_4_75) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_15) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_5_90) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_6_70) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_40) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_7_95) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_10_2) &&
+          (p_record_parameter->amr_vocoder != AUDIO_AMR_VOCODER_12_2))||
+         (p_driver_parameter->buffer_size < AUDIO_VM_AMR_MAX_SAMPLE_SIZE_16BIT)||
+         ((p_driver_parameter->nb_buffer < 2)||
+          (p_driver_parameter->nb_buffer > AUDIO_DRIVER_MAX_BUFFER_PER_SESSION))
+         )
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return (AUDIO_ERROR);
+    }
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal,
+                             sizeof (T_AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION),
+                             (T_RVF_BUFFER **) (&p_msg));
+
+    /* If insufficient resources, then report a memory error and abort.         */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg);
+      audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill message id */
+    p_msg->os_hdr.msg_id = AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION;
+    p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    /* fill the message parameters */
+    p_msg->compression_mode   = p_record_parameter->compression_mode;
+    p_msg->memo_duration      = p_record_parameter->memo_duration;
+    p_msg->microphone_gain    = p_record_parameter->microphone_gain;
+    p_msg->amr_vocoder        = p_record_parameter->amr_vocoder;
+
+    /* fill parameters */
+    p_msg->driver_parameter.buffer_size = p_driver_parameter->buffer_size;
+    p_msg->driver_parameter.nb_buffer   = p_driver_parameter->nb_buffer;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg->return_path.addr_id = return_path.addr_id;
+      p_msg->return_path.callback_func = NULL;
+    }
+    else
+      p_msg->return_path.callback_func = return_path.callback_func;
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId, p_msg);
+
+    return (AUDIO_OK);
+  #else  // L1_VOICE_MEMO_AMR
+    AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+    return (AUDIO_ERROR);
+  #endif // L1_VOICE_MEMO_AMR
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_driver_init_vm_amr_play_session                    */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to initialize VM AMR play      */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Specific VM AMR play parameters                                       */
+  /*        Driver parameters                                                     */
+  /*        Return path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters                                         */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_driver_init_vm_amr_play_session(T_AUDIO_DRIVER_PARAMETER *p_driver_parameter, T_RV_RETURN return_path)
+  {
+  #if (L1_VOICE_MEMO_AMR)
+    /* Declare local variables.                                                 */
+    T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+    T_AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION *p_msg  = NULL;
+
+    /************************ audio_keybeep_stop function begins ****************/
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* If bad voice memo record parameters, then report an error and abort.*/
+    if ( (p_driver_parameter->buffer_size < AUDIO_VM_AMR_MAX_SAMPLE_SIZE_16BIT)||
+         ((p_driver_parameter->nb_buffer < 2)||
+          (p_driver_parameter->nb_buffer > AUDIO_DRIVER_MAX_BUFFER_PER_SESSION))
+       )
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return (AUDIO_ERROR);
+    }
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal,
+                             sizeof (T_AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION),
+                             (T_RVF_BUFFER **) (&p_msg));
+
+    /* If insufficient resources, then report a memory error and abort.         */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg);
+      audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill the message id */
+    p_msg->os_hdr.msg_id = AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION;
+    p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    /* fill parameters */
+    p_msg->driver_parameter.buffer_size = p_driver_parameter->buffer_size;
+    p_msg->driver_parameter.nb_buffer   = p_driver_parameter->nb_buffer;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg->return_path.addr_id = return_path.addr_id;
+      p_msg->return_path.callback_func = NULL;
+    }
+    else
+      p_msg->return_path.callback_func = return_path.callback_func;
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId, p_msg);
+
+    return (AUDIO_OK);
+  #else  // L1_VOICE_MEMO_AMR
+    AUDIO_SEND_TRACE("Voice Memo AMR not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+    return (AUDIO_ERROR);
+  #endif // L1_VOICE_MEMO_AMR
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_driver_..._session                                 */
+  /*                                                                              */
+  /*    Purpose:  This function is called in order to start/stop/free session     */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        channel identifier                                                    */
+  /*        Return path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*         Validation of the parameters                                         */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_driver_start_session(UINT8 channel_id, T_RV_RETURN notification_return_path)
+  {
+    return audio_driver_handle_session(AUDIO_DRIVER_START_SESSION, channel_id, notification_return_path);
+  }
+
+  T_AUDIO_RET audio_driver_stop_session(UINT8 channel_id)
+  {
+    T_RV_RETURN return_path;
+
+    return_path.callback_func = NULL;
+    return_path.addr_id       = 0;
+
+    return audio_driver_handle_session(AUDIO_DRIVER_STOP_SESSION, channel_id, return_path);
+  }
+
+  T_AUDIO_RET audio_driver_free_session(UINT8 channel_id, T_RV_RETURN return_path)
+  {
+    return audio_driver_handle_session(AUDIO_DRIVER_FREE_SESSION, channel_id, return_path);
+  }
+
+  T_AUDIO_RET audio_driver_handle_session(UINT32 msg_id, UINT8 channel_id, T_RV_RETURN return_path)
+  {
+  #if (L1_AUDIO_DRIVER)
+    /* Declare local variables.                                                 */
+    T_RVF_MB_STATUS   mb_status = RVF_GREEN;
+    T_AUDIO_DRIVER_HANDLE_SESSION *p_msg  = NULL;
+
+    /************************ audio_driver_handle_session function begins ****************/
+
+    if (p_audio_gbl_var == NULL )
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_NOT_START);
+      return(AUDIO_ERROR);
+    }
+
+    /* If bad voice memo record parameters, then report an error and abort.*/
+    if (channel_id >= AUDIO_DRIVER_MAX_CHANNEL)
+    {
+      audio_driver_error_trace(AUDIO_ENTITY_BAD_PARAMETER);
+      return (AUDIO_ERROR);
+    }
+
+    /* allocate the memory for the message to send */
+    mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                             sizeof (T_AUDIO_DRIVER_HANDLE_SESSION),
+                             (T_RVF_BUFFER **) (&p_msg));
+
+    /* If insufficient resources, then report a memory error and abort.         */
+    if (mb_status == RVF_YELLOW)
+    {
+      /* deallocate the memory */
+      rvf_free_buf((T_RVF_BUFFER *)p_msg);
+      audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+    else
+    if (mb_status == RVF_RED)
+    {
+      audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+      return (AUDIO_ERROR);
+    }
+
+    /* fill the message id */
+    p_msg->os_hdr.msg_id = msg_id;
+    p_msg->os_hdr.dest_addr_id = p_audio_gbl_var->addrId;
+
+    /* fill the message parameters */
+    p_msg->channel_id = channel_id;
+
+    if (return_path.callback_func == NULL)
+    {
+      p_msg->return_path.addr_id = return_path.addr_id;
+      p_msg->return_path.callback_func = NULL;
+    }
+    else
+      p_msg->return_path.callback_func = return_path.callback_func;
+
+    /* send the messsage to the audio entity */
+    rvf_send_msg (p_audio_gbl_var->addrId, p_msg);
+
+    return (AUDIO_OK);
+  #else
+    AUDIO_SEND_TRACE("Audio Driver not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+    return(AUDIO_ERROR);
+  #endif
+  }
+
+  T_AUDIO_RET audio_driver_get_play_buffer(UINT8 channel_id, UINT8 **pp_buffer)
+  {
+  #if (L1_AUDIO_DRIVER)
+    T_AUDIO_DRIVER_SESSION *p_session;
+    UINT8 index_appli;
+
+    /* Test CHANNEL_ID */
+    if (channel_id >= AUDIO_DRIVER_MAX_CHANNEL)
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER GET BUFFER: channel_id not valid", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* get driver session */
+    p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]);
+    index_appli = p_session->session_info.index_appli;
+
+    /* channel must be initialized */
+    if (p_session->session_info.state == AUDIO_DRIVER_CHANNEL_WAIT_INIT)
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER GET BUFFER: channel not initialized", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* play buffer must have been used after a previous call of this API */
+    if (p_session->session_info.play_api_state != AUDIO_PLAY_API_STATE_GET_BUF)
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER GET BUFFER: PLAY not called after GET", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* test if next buffer is available */
+    if (index_appli != p_session->session_info.index_l1)
+    {
+      *pp_buffer = (UINT8 *)(p_session->session_info.buffer[index_appli].p_start_pointer);
+      AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER GET BUFFER: buffer", *pp_buffer, RV_TRACE_LEVEL_DEBUG_LOW);
+      p_session->session_info.play_api_state = AUDIO_PLAY_API_STATE_PLAY_BUF;
+    }
+    else
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER GET BUFFER: no buffer available", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* 1st time, index_l1 = 0xFF. At 1st play, layer1 becomes valid so we put 0
+       This way, appli can't circle round buffers when in WAIT_START state */
+    if (p_session->session_info.state == AUDIO_DRIVER_CHANNEL_WAIT_START)
+      p_session->session_info.index_l1 = 0;
+
+    return (AUDIO_OK);
+  #else
+    AUDIO_SEND_TRACE("Audio Driver not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+    return(AUDIO_ERROR);
+  #endif
+  }
+
+  T_AUDIO_RET audio_driver_play_buffer(UINT8 channel_id, UINT8 *p_buffer)
+  {
+  #if (L1_AUDIO_DRIVER)
+    T_AUDIO_DRIVER_SESSION *p_session;
+
+    /* Test CHANNEL_ID */
+    if (channel_id >= AUDIO_DRIVER_MAX_CHANNEL)
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER PLAY BUFFER: channel_id not valid", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* get driver session */
+    p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]);
+
+    /* channel must be initialized */
+    if (p_session->session_info.state == AUDIO_DRIVER_CHANNEL_WAIT_INIT)
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER PLAY BUFFER: channel not initialized", RV_TRACE_LEVEL_DEBUG_LOW);
+      //p_session->session_info.play_api_state = AUDIO_PLAY_API_STATE_GET_BUF;
+      return (AUDIO_ERROR);
+    }
+
+    /* get buffer must have been called before */
+    if (p_session->session_info.play_api_state != AUDIO_PLAY_API_STATE_PLAY_BUF)
+    {
+      AUDIO_SEND_TRACE("AUDIO DRIVER GET BUFFER: GET not called before play", RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* check validity of buffer */
+    if ( p_buffer !=
+         ((UINT8 *)(p_session->session_info.buffer[p_session->session_info.index_appli].p_start_pointer)))
+    {
+      AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER PLAY BUFFER: buffer is not valid", p_buffer, RV_TRACE_LEVEL_DEBUG_LOW);
+      return (AUDIO_ERROR);
+    }
+
+    /* increment index_appli */
+    AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER PLAY BUFFER:", p_session->session_info.index_appli, RV_TRACE_LEVEL_DEBUG_LOW);
+    p_session->session_info.play_api_state = AUDIO_PLAY_API_STATE_GET_BUF;
+    p_session->session_info.index_appli++;
+
+    if (p_session->session_info.index_appli == p_session->session_req.nb_buffer)
+      p_session->session_info.index_appli = 0;
+
+    return (AUDIO_OK);
+  #else
+    AUDIO_SEND_TRACE("Audio Driver not compiled", RV_TRACE_LEVEL_DEBUG_LOW);
+    return(AUDIO_ERROR);
+  #endif
+
+  }
+
+  T_AUDIO_RET Side_Tone_Mute()
+  {
+    T_RV_RETURN return_path = { NULL, 0 };
+    T_AUDIO_FULL_ACCESS_WRITE audioPara;
+    INT8 value = AUDIO_SIDETONE_OPEN;
+    
+    audioPara.variable_indentifier = AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE;
+    audioPara.data = &value;
+    
+    return audio_full_access_write(&audioPara, return_path);
+  }
+  
+  void Side_Tone_Write(INT8 gain)
+  {
+    T_RV_RETURN return_path = { NULL, 0 };
+    T_AUDIO_FULL_ACCESS_WRITE audioPara;
+    INT8 value = gain;
+        
+    audioPara.variable_indentifier = AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE;
+    audioPara.data = &value;
+
+    audio_full_access_write(&audioPara, return_path);
+  }
+  
+  T_AUDIO_RET Side_Tone_Read()
+  {
+    T_RV_RETURN return_path = { NULL, 0 };
+    T_AUDIO_FULL_ACCESS_READ audioPara;
+    INT8 value;
+    
+    audioPara.variable_indentifier = AUDIO_MICROPHONE_SPEAKER_LOOP_SIDETONE;
+    audioPara.data = &value;
+    
+    audio_full_access_read(&audioPara);
+
+    return value;
+  }
+  
+#endif // #ifdef RVM_AUDIO_MAIN_SWE