--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/chipsetsw/services/Audio/audio_vm_amr_record.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,590 @@
+/****************************************************************************/
+/*                                                                          */
+/*  File Name:  audio_vm_amr_record.c                                       */
+/*                                                                          */
+/*  Purpose:  This file contains all the functions used to manage the       */
+/*            Voice Memorization AMR record task.                           */
+/*                                                                          */
+/*  Version   0.1                                                           */
+/*                                                                          */
+/*  Date          Modification                                              */
+/*  ------------------------------------                                    */
+/*  ?? ?? 2002 Create                                                       */
+/*                                                                          */
+/*  Author                                                                  */
+/*     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 the usefull L1 header */
+  #include "l1_confg.h"
+
+#if (L1_VOICE_MEMO_AMR)
+  #include "rv/rv_general.h"
+  #include "rvm/rvm_gen.h"
+  #include "audio/audio_features_i.h"
+  #include "audio/audio_ffs_i.h"
+  #include "audio/audio_api.h"
+  #include "audio/audio_structs_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_error_hdlr_i.h"
+
+  /* include the usefull L1 header */
+  #define BOOL_FLAG
+  #define CHAR_FLAG
+  #include "l1_types.h"
+  #include "l1audio_cust.h"
+  #include "l1audio_msgty.h"
+  #include "l1audio_signa.h"
+
+  #include "audio/audio_macro_i.h"
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_vm_amr_record_send_status                          */
+  /*                                                                              */
+  /*    Purpose:  This function sends the voice memorization AMR record status    */
+  /*              to the entity.                                                  */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        status,                                                               */
+  /*        return path                                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+#if (AUDIO_MEM_MANAGER)
+  void audio_vm_amr_record_send_status (T_AUDIO_RET status,
+                                        UINT32 recorded_size,
+                                        T_RV_RETURN return_path)
+  {
+    T_AUDIO_AMR_RECORD_STATUS *p_send_message;
+    T_RVF_MB_STATUS mb_status = RVF_RED;
+
+    /* allocate the message buffer */
+    while (mb_status == RVF_RED)
+    {
+      mb_status = rvf_get_buf (p_audio_gbl_var->mb_external,
+                               sizeof (T_AUDIO_AMR_RECORD_STATUS),
+                               (T_RVF_BUFFER **) (&p_send_message));
+
+      /* If insufficient resources, then report a memory error and abort.               */
+      /* and wait until more ressource is given */
+      if (mb_status == RVF_RED)
+      {
+        audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+        rvf_delay(RVF_MS_TO_TICKS(1000));
+      }
+    }
+
+    /*fill the header of the message */
+    p_send_message->os_hdr.msg_id = AUDIO_AMR_RECORD_TO_MEM_STATUS_MSG;
+
+    /* fill the status parameters */
+    p_send_message->status = status;
+    if (recorded_size == 0)
+      p_send_message->recorded_duration = 0;
+    else
+      p_send_message->recorded_duration = recorded_size;
+
+    /* send message or call callback */
+    if (return_path.callback_func == NULL)
+    {
+      rvf_send_msg (return_path.addr_id, p_send_message);
+    }
+    else
+    {
+      (*return_path.callback_func)((void *)(p_send_message));
+       rvf_free_buf((T_RVF_BUFFER *)p_send_message);
+    }
+  }
+
+  void audio_vm_amr_record_to_memory_manager (T_RV_HDR *p_message)
+  {
+    /* Declare local variables. */
+    T_RV_HDR *p_send_message;
+    T_RVF_MB_STATUS mb_status;
+    T_RV_RETURN return_path;
+
+    /**************** audio_vm_amr_record_to_memory_manager function begins ***********************/
+    switch(p_audio_gbl_var->audio_vm_amr_record.state)
+    {
+      case AUDIO_IDLE:
+      {
+        switch (p_message->msg_id)
+        {
+          case AUDIO_VM_AMR_RECORD_TO_FFS_START_REQ:
+          case AUDIO_VM_AMR_RECORD_TO_RAM_START_REQ:
+          {
+            T_AUDIO_DRIVER_VM_AMR_RECORD_PARAMETER parameter;
+            T_AUDIO_DRIVER_PARAMETER driver_parameter;
+
+            switch (p_message->msg_id)
+            {
+              case AUDIO_VM_AMR_RECORD_TO_FFS_START_REQ:
+              {
+                /* save the return path + ffs_fd */
+              #if (AUDIO_RAM_MANAGER)
+                p_audio_gbl_var->audio_vm_amr_record.audio_ram_fd = NULL;
+              #endif
+                p_audio_gbl_var->audio_vm_amr_record.return_path.callback_func =
+                  ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START *)p_message)->return_path.callback_func;
+                p_audio_gbl_var->audio_vm_amr_record.return_path.addr_id   =
+                  ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START*)p_message)->return_path.addr_id;
+              #if (AUDIO_NEW_FFS_MANAGER)
+                p_audio_gbl_var->audio_vm_amr_record.ffs_fd =
+                  ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START *)p_message)->audio_ffs_fd;
+              #endif
+
+                /* fill AMR parameters and driver parameters */
+                parameter.memo_duration      = ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START *)p_message)->memo_duration;
+                parameter.compression_mode   = ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START *)p_message)->compression_mode;
+                parameter.microphone_gain    = ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START *)p_message)->microphone_gain;
+                parameter.amr_vocoder        = ((T_AUDIO_VM_AMR_RECORD_TO_FFS_START *)p_message)->amr_vocoder;
+              }
+              break;
+              case AUDIO_VM_AMR_RECORD_TO_RAM_START_REQ:
+              {
+                /* save the return path + p_buffer */
+              #if (AUDIO_NEW_FFS_MANAGER)
+                p_audio_gbl_var->audio_vm_amr_record.ffs_fd = NULL;
+              #endif
+                p_audio_gbl_var->audio_vm_amr_record.return_path.callback_func =
+                  ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START *)p_message)->return_path.callback_func;
+                p_audio_gbl_var->audio_vm_amr_record.return_path.addr_id   =
+                  ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START*)p_message)->return_path.addr_id;
+              #if (AUDIO_RAM_MANAGER)
+                p_audio_gbl_var->audio_vm_amr_record.audio_ram_fd =
+                  ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START *)p_message)->p_buffer;
+              #endif
+
+                /* fill AMR parameters and driver parameters */
+                parameter.memo_duration      = ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START *)p_message)->memo_duration;
+                parameter.compression_mode   = ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START *)p_message)->compression_mode;
+                parameter.microphone_gain    = ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START *)p_message)->microphone_gain;
+                parameter.amr_vocoder        = ((T_AUDIO_VM_AMR_RECORD_TO_RAM_START *)p_message)->amr_vocoder;
+              }
+              break;
+            }
+
+            driver_parameter.nb_buffer   = AUDIO_VM_AMR_RECORD_NB_BUFFER;
+            driver_parameter.buffer_size = AUDIO_VM_AMR_RECORD_SIZE;
+
+            /* return_path for driver */
+            return_path.callback_func    = NULL;
+            return_path.addr_id          = p_audio_gbl_var->addrId;
+
+            /* Init driver */
+            audio_driver_init_vm_amr_record_session(&parameter, &driver_parameter, return_path);
+
+            p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_WAIT_CHANNEL_ID;
+          }
+          break;
+          case AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ:
+          case AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ:
+          {
+            audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+            /* do not send a status message because of pre-emption issues
+            An automatic stop can pre-empt a stop request. A status is sent + back in state idle
+            then the stop request is received and another status is sent, which can be misinterpreted */
+          }
+          break;
+        }
+      }
+      break;
+
+      case AUDIO_WAIT_CHANNEL_ID:
+      {
+        switch (p_message->msg_id)
+        {
+          case AUDIO_DRIVER_INIT_STATUS_MSG:
+          {
+            /* check init is successfull otherwise, send status AUDIO_ERROR */
+            if (((T_AUDIO_DRIVER_INIT_STATUS *)p_message)->status == AUDIO_OK)
+            {
+              /* get channel id */
+              p_audio_gbl_var->audio_vm_amr_record.channel_id = ((T_AUDIO_DRIVER_INIT_STATUS *)p_message)->channel_id;
+
+              /* Send the Start message to MEM */
+              mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal,
+                                       sizeof (T_AUDIO_MEM_START),
+                                       (T_RVF_BUFFER **) (&p_send_message));
+
+              /* If insufficient resources, then report a memory error and abort.               */
+              if (mb_status == RVF_RED)
+              {
+                audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+                // TODO: use blocking function from GSP
+                return;
+              }
+
+              /* fill the header of the message */
+              ((T_AUDIO_MEM_START *)p_send_message)->os_hdr.msg_id = AUDIO_MEM_START_REQ;
+
+              /* fill the parameters */
+              ((T_AUDIO_MEM_START *)p_send_message)->session_id = AUDIO_VM_AMR_RECORD_SESSION_ID;
+              ((T_AUDIO_MEM_START *)p_send_message)->channel_id = p_audio_gbl_var->audio_vm_amr_record.channel_id;
+              ((T_AUDIO_MEM_START *)p_send_message)->size = AUDIO_VM_AMR_RECORD_SIZE*2;
+            #if (AUDIO_NEW_FFS_MANAGER)
+              ((T_AUDIO_MEM_START *)p_send_message)->audio_ffs_fd = p_audio_gbl_var->audio_vm_amr_record.ffs_fd;
+            #endif
+            #if (AUDIO_RAM_MANAGER)
+              ((T_AUDIO_MEM_START *)p_send_message)->audio_ram_fd = p_audio_gbl_var->audio_vm_amr_record.audio_ram_fd;
+            #endif
+
+              /* send the message to the entity */
+              rvf_send_msg ( p_audio_gbl_var->audio_ffs_addrId, p_send_message);
+
+              /* change state */
+              p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_WAIT_STOP;
+            }
+            else
+            {
+              audio_voice_memo_amr_error_trace(AUDIO_ERROR_START_EVENT);
+              audio_vm_amr_record_send_status (AUDIO_ERROR, 0,
+                p_audio_gbl_var->audio_vm_amr_record.return_path);
+              /* change state */
+              p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_IDLE;
+            }
+          }
+          break;
+          case AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ:
+          #if (AUDIO_RAM_MANAGER)
+            if (p_audio_gbl_var->audio_vm_amr_record.audio_ram_fd != NULL)
+            {
+              audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+              return;
+            }
+          #endif
+            /* change state */
+            p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_WAIT_CHANNEL_ID_TO_STOP;
+          break;
+          case AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ:
+          #if (AUDIO_NEW_FFS_MANAGER)
+            if (p_audio_gbl_var->audio_vm_amr_record.ffs_fd != NULL)
+            {
+              audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+              return;
+            }
+          #endif
+            /* change state */
+            p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_WAIT_CHANNEL_ID_TO_STOP;
+          break;
+        }
+      } // case AUDIO_WAIT_CHANNEL_ID:
+      break;
+
+      case AUDIO_WAIT_STOP:
+      {
+        switch (p_message->msg_id)
+        {
+          case AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ:
+          case AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ:
+          {
+            // we handle a RAM stop when New_ffs is running as an error
+          #if (AUDIO_NEW_FFS_MANAGER)
+            if ((p_message->msg_id == AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ)&&
+                (p_audio_gbl_var->audio_vm_amr_record.ffs_fd != NULL))
+            {
+              audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+              return;
+            }
+          #endif
+          // we handle a New_ffs stop when RAM is running as an error
+          #if (AUDIO_RAM_MANAGER)
+            if ((p_message->msg_id == AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ)&&
+                (p_audio_gbl_var->audio_vm_amr_record.audio_ram_fd != NULL))
+            {
+              audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+              return;
+            }
+          #endif
+            /* Send the Stop message to MEM manager */
+            mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal,
+                                     sizeof (T_AUDIO_MEM_STOP),
+                                     (T_RVF_BUFFER **) (&p_send_message));
+
+            /* If insufficient resources, then report a memory error and abort.               */
+            if (mb_status == RVF_RED)
+            {
+              audio_voice_memo_amr_error_trace(AUDIO_ENTITY_NO_MEMORY);
+              return;
+            }
+
+            /* fill message */
+            ((T_AUDIO_MEM_STOP *)p_send_message)->os_hdr.msg_id = AUDIO_MEM_STOP_REQ;
+            ((T_AUDIO_MEM_STOP *)p_send_message)->channel_id    = p_audio_gbl_var->audio_vm_amr_record.channel_id;
+
+            /* send the message to the entity */
+            rvf_send_msg (p_audio_gbl_var->audio_ffs_addrId, p_send_message);
+
+            p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_WAIT_STOP_CON;
+          }
+          break;
+          case AUDIO_MEM_STATUS_MSG:
+          {
+            if (((T_AUDIO_MEM_STATUS *)p_message)->status_type == AUDIO_STOP_STATUS)
+            {
+              /* should be useless as it is an automatic stop so AUDIO_OK */
+              if (((T_AUDIO_MEM_STATUS *)p_message)->status == AUDIO_OK)
+              {
+                audio_vm_amr_record_send_status (AUDIO_OK, ((T_AUDIO_MEM_STATUS *)p_message)->recorded_size,
+                  p_audio_gbl_var->audio_vm_amr_record.return_path);
+                p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_IDLE;
+              }
+            }
+            if (((T_AUDIO_MEM_STATUS *)p_message)->status_type == AUDIO_START_STATUS)
+            {
+              /* MEM could not find a free mem channel */
+              if (((T_AUDIO_MEM_STATUS *)p_message)->status == AUDIO_ERROR)
+              {
+                audio_vm_amr_record_send_status (AUDIO_ERROR, 0,
+                  p_audio_gbl_var->audio_vm_amr_record.return_path);
+                p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_IDLE;
+              }
+            }
+          }
+          break;
+        }
+      }
+      break;
+      case AUDIO_WAIT_STOP_CON:
+      {
+        switch (p_message->msg_id)
+        {
+          case AUDIO_MEM_STATUS_MSG:
+          {
+            if (((T_AUDIO_MEM_STATUS *)p_message)->status_type == AUDIO_STOP_STATUS)
+            {
+              audio_vm_amr_record_send_status (AUDIO_OK, ((T_AUDIO_MEM_STATUS *)p_message)->recorded_size,
+                p_audio_gbl_var->audio_vm_amr_record.return_path);
+              p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_IDLE;
+            }
+          }
+          break;
+          case AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ:
+          case AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ:
+            audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+          break;
+        }
+      }
+      break;
+      case AUDIO_WAIT_CHANNEL_ID_TO_STOP:
+      {
+        switch (p_message->msg_id)
+        {
+          case AUDIO_DRIVER_INIT_STATUS_MSG:
+          {
+            if (((T_AUDIO_DRIVER_INIT_STATUS *)p_message)->status == AUDIO_OK)
+            {
+              /* get channel_id */
+              p_audio_gbl_var->audio_vm_amr_record.channel_id = ((T_AUDIO_DRIVER_INIT_STATUS *)p_message)->channel_id;
+
+              audio_driver_stop_session(p_audio_gbl_var->audio_vm_amr_record.channel_id);
+
+              /* change state */
+              p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_WAIT_DRIVER_STOP_CON;
+            }
+            else
+            {
+              /* close file */
+            #if (AUDIO_NEW_FFS_MANAGER)
+              if (p_audio_gbl_var->audio_vm_amr_record.ffs_fd != NULL)
+              {
+                if ( ffs_close(p_audio_gbl_var->audio_vm_amr_record.ffs_fd) != EFFS_OK )
+                {
+                  audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_CLOSE);
+                }
+                AUDIO_SEND_TRACE("AUDIO VM AMR RECORD: close FFS file", RV_TRACE_LEVEL_DEBUG_LOW);
+              }
+            #endif
+
+              audio_vm_amr_record_send_status (AUDIO_OK, 0,
+                p_audio_gbl_var->audio_vm_amr_record.return_path);
+
+              /* change state */
+              p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_IDLE;
+            }
+          }
+          break;
+          case AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ:
+          case AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ:
+            audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+          break;
+        }
+      } // case AUDIO_WAIT_CHANNEL_ID_TO_STOP:
+      break;
+      case AUDIO_WAIT_DRIVER_STOP_CON:
+      {
+        switch (p_message->msg_id)
+        {
+          case AUDIO_DRIVER_STATUS_MSG:
+          {
+            if (((T_AUDIO_DRIVER_STATUS *)p_message)->status_type == AUDIO_STOP_STATUS)
+            {
+              /* close file */
+            #if (AUDIO_NEW_FFS_MANAGER)
+              if (p_audio_gbl_var->audio_vm_amr_record.ffs_fd != NULL)
+              {
+                if ( ffs_close(p_audio_gbl_var->audio_vm_amr_record.ffs_fd) != EFFS_OK )
+                {
+                  audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_CLOSE);
+                }
+                AUDIO_SEND_TRACE("AUDIO VM AMR RECORD: close FFS file", RV_TRACE_LEVEL_DEBUG_LOW);
+              }
+            #endif
+
+              audio_vm_amr_record_send_status (AUDIO_OK, 0,
+                p_audio_gbl_var->audio_vm_amr_record.return_path);
+              p_audio_gbl_var->audio_vm_amr_record.state = AUDIO_IDLE;
+            }
+          }
+          break;
+          case AUDIO_VM_AMR_RECORD_TO_FFS_STOP_REQ:
+          case AUDIO_VM_AMR_RECORD_TO_RAM_STOP_REQ:
+            audio_voice_memo_amr_error_trace(AUDIO_ERROR_STOP_EVENT);
+          break;
+        }
+      } //case AUDIO_WAIT_DRIVER_STOP_CON:
+      break;
+    }
+  } /*********************** End of audio_vm_amr_record_to_memory_manager function **********************/
+#endif // AUDIO_MEM_MANAGER
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_driver_vm_amr_record_convert_parameter             */
+  /*                                                                              */
+  /*    Purpose:  Convert the voice memorization record parameters from the       */
+  /*              entity to the l1 parameters                                     */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        session_id of the voice memo record                                   */
+  /*        id of the voice memo record                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        layer 1 voice memo record message                                     */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  void audio_driver_vm_amr_record_convert_parameter(T_AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION *entity_parameter,
+                                             T_MMI_VM_AMR_RECORD_REQ *l1_parameter)
+  {
+     /* session id : specifies the customer data identification corresponding to   */
+    /*              this voice memorization */
+    l1_parameter->session_id      = AUDIO_VM_AMR_RECORD_SESSION_ID;
+    l1_parameter->maximum_size    = entity_parameter->memo_duration + SC_VM_AMR_END_MASK_SIZE;
+    l1_parameter->dtx_used        = (BOOL)(entity_parameter->compression_mode);
+    l1_parameter->record_coeff_ul = (UINT16)(entity_parameter->microphone_gain);
+    l1_parameter->amr_vocoder     = (UINT16)(entity_parameter->amr_vocoder);
+  }
+
+  /********************************************************************************/
+  /*                                                                              */
+  /*    Function Name:   audio_driver_vm_amr_record_manager                       */
+  /*                                                                              */
+  /*    Purpose:  This function is called to manage a voice memorization record   */
+  /*              manager                                                         */
+  /*                                                                              */
+  /*    Input Parameters:                                                         */
+  /*        Message to the audio entity                                           */
+  /*                                                                              */
+  /*    Output Parameters:                                                        */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Note:                                                                     */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /*    Revision History:                                                         */
+  /*        None.                                                                 */
+  /*                                                                              */
+  /********************************************************************************/
+  T_AUDIO_RET audio_driver_vm_amr_record_manager (T_RV_HDR *p_message, T_AUDIO_DRIVER_SESSION *p_session)
+  {
+    /**************** audio_driver_vm_amr_record_manager function begins ***********************/
+    switch(p_session->session_info.state)
+    {
+      case AUDIO_DRIVER_CHANNEL_WAIT_INIT:
+      {
+        /* allocate the buffer for the message to the L1 */
+        p_session->session_req.p_l1_send_message =
+          audio_allocate_l1_message(sizeof(T_MMI_VM_AMR_RECORD_REQ));
+
+        if (p_session->session_req.p_l1_send_message != NULL )
+        {
+          /* Convert the entity parameters to the audio L1 parameters */
+          audio_driver_vm_amr_record_convert_parameter((T_AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION*)p_message,
+                                                       p_session->session_req.p_l1_send_message);
+          return (AUDIO_OK);
+        }
+        return (AUDIO_ERROR);
+      }
+      break;
+
+      case AUDIO_DRIVER_CHANNEL_WAIT_START:
+      {
+        /* send the start voice memo record message to the L1 */
+        audio_send_l1_message(MMI_VM_AMR_RECORD_START_REQ,
+                              p_session->session_req.p_l1_send_message);
+        return (AUDIO_OK);
+      }
+      break;
+
+      case AUDIO_DRIVER_CHANNEL_WAIT_STOP:
+      {
+        /* send the stop command to the audio L1 */
+        /* allocate the buffer for the message to the L1 */
+        void *p_send_message = audio_allocate_l1_message(0);
+        if ( p_send_message != NULL)
+        {
+          /* send the stop command to the audio L1 */
+          audio_send_l1_message(MMI_VM_AMR_RECORD_STOP_REQ, p_send_message);
+          return (AUDIO_OK);
+        }
+        return (AUDIO_ERROR);
+      }
+      break;
+      case AUDIO_DRIVER_CHANNEL_WAIT_START_CON_TO_STOP:
+      {
+        /* only STOP is handled here */
+        /* send the stop command to the audio L1 */
+        /* allocate the buffer for the message to the L1 */
+        void *p_send_message = audio_allocate_l1_message(0);
+        if ( p_send_message != NULL)
+        {
+          /* send the stop command to the audio L1 */
+          audio_send_l1_message(MMI_VM_AMR_RECORD_STOP_REQ, p_send_message);
+          return (AUDIO_OK);
+        }
+        return (AUDIO_ERROR);
+      }
+      break;
+    }
+  } /*********************** End of audio_vm_record_manager function **********************/
+
+#endif /* VM_AMR_RECORD */
+#endif /* RVM_AUDIO_MAIN_SWE */