FreeCalypso > hg > tcs211-c139
view chipsetsw/services/Audio/audio_ffs.c @ 43:52325cb524a8
new README written for the UI-enabled configuration
| author | Mychaela Falconia <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Thu, 05 Nov 2015 08:09:54 +0000 |
| parents | 509db1a7b7b8 |
| children |
line wrap: on
line source
/****************************************************************************/ /* */ /* Name audio_ffs.c */ /* */ /* Function this file contains the AUDIO ffs function: */ /* */ /* */ /* Version 0.1 */ /* */ /* Date Modification */ /* ------------------------------------ */ /* 18 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" #if (MELODY_E1) || (MELODY_E2) || (VOICE_MEMO) #include "rvf/rvf_api.h" #include "rv/rv_general.h" #include "rvm/rvm_gen.h" #include "audio/audio_api.h" #include "audio/audio_env_i.h" #include "audio/audio_ffs_i.h" #include "audio/audio_structs_i.h" #include "audio/audio_macro_i.h" #include "rvf/rvf_target.h" #include "audio/audio_const_i.h" #include "audio/audio_var_i.h" #include "audio/audio_error_hdlr_i.h" #include "audio/audio_messages_i.h" /* include the usefull L1 header */ #define BOOL_FLAG #define CHAR_FLAG #include "l1_types.h" #include "l1audio_cust.h" #include "l1audio_const.h" #include "l1audio_msgty.h" #include "l1audio_signa.h" #include "ffs/ffs_api.h" /********************************************************************************/ /* */ /* Function Name: audio_ffs_manager */ /* */ /* Purpose: This function is called to manage the FFS request from the */ /* audio entity */ /* */ /* Input Parameters: */ /* message from the audio entity */ /* */ /* Output Parameters: */ /* None. */ /* */ /* Note: */ /* None. */ /* */ /* Revision History: */ /* None. */ /* */ /********************************************************************************/ void audio_ffs_manager (T_RV_HDR *p_message) { UINT8 j, active_task, index_ffs, index_l1, *p_buffer, channel_id; T_AUDIO_FFS_SESSION *p_session; T_RV_HDR *p_send_message; T_RVF_MB_STATUS mb_status; BOOLEAN loop_mode; #ifndef _WINDOWS UINT16 voice_memo_size, *p_scan; #else UINT16 i; UINT8 *p_mem; #endif UINT16 buffer_size; T_FFS_SIZE size; T_RV_RET status; switch (p_message->msg_id) { case AUDIO_FFS_FLASH_2_RAM_START_REQ: { AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: flash to RAM session_id", ((T_AUDIO_FFS_FLASH_2_RAM_START *)p_message)->session_id, RV_TRACE_LEVEL_DEBUG_LOW); /* Find a free channel */ channel_id = 0; while ( (p_audio_gbl_var->audio_ffs_session[channel_id].session_req.valid_channel) && (channel_id < AUDIO_FFS_MAX_CHANNEL) ) channel_id++; AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: open channel", channel_id, RV_TRACE_LEVEL_DEBUG_LOW); p_session = &(p_audio_gbl_var->audio_ffs_session[channel_id]); /* fill the request structure corresponding to the session id */ p_session->session_req.audio_ffs_fd = ((T_AUDIO_FFS_FLASH_2_RAM_START *)p_message)->audio_ffs_fd; p_session->session_req.size = ((T_AUDIO_FFS_FLASH_2_RAM_START *)p_message)->initial_size; p_session->session_req.loop_mode = ((T_AUDIO_FFS_FLASH_2_RAM_START *)p_message)->loop; p_session->session_req.session_id = ((T_AUDIO_FFS_FLASH_2_RAM_START *)p_message)->session_id; /************************************************************/ /* the FFS must download the 2 first buffers to the RAM */ /************************************************************/ for (j=0; j<2; j++) { /* allocate the first buffer */ p_session->session_info.buffer[j].size = p_session->session_req.size; mb_status = rvf_get_buf (p_audio_gbl_var->mb_audio_ffs, p_session->session_info.buffer[j].size, (T_RVF_BUFFER **) (&p_session->session_info.buffer[j].p_start_pointer)); /* If insufficient resources, then report a memory error and abort. */ if (mb_status == RVF_RED) { audio_ffs_error_trace(AUDIO_ENTITY_NO_MEMORY); } AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: allocate buffer", j, RV_TRACE_LEVEL_DEBUG_LOW); /* intialize the stop pointer */ p_session->session_info.buffer[j].p_stop_pointer = p_session->session_info.buffer[j].p_start_pointer + (p_session->session_info.buffer[j].size); /* Fill the buffer j while it isn't full in case of the loop back mode activated */ loop_mode = TRUE; buffer_size = p_session->session_info.buffer[j].size; p_buffer = (UINT8 *)p_session->session_info.buffer[j].p_start_pointer; while ( (p_buffer < p_session->session_info.buffer[j].p_stop_pointer) && (loop_mode) ) { loop_mode = p_session->session_req.loop_mode; #ifndef _WINDOWS size = ffs_read(p_session->session_req.audio_ffs_fd, p_buffer, buffer_size); #else size = buffer_size; p_mem = p_buffer; for (i=0; i<size; i++) { *p_mem = (UINT8)i; p_mem++; } #endif AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: ffs_read size", size, RV_TRACE_LEVEL_DEBUG_LOW); buffer_size -= size; p_buffer += size; if (buffer_size != 0) { #ifndef _WINDOWS /* reset the FFS pointer */ ffs_seek(p_session->session_req.audio_ffs_fd, 0, FFS_SEEK_SET); #endif } } /* while */ } /* for (j=0; j<2; j++) */ /* initialize the cust_get_pointer state machine */ p_session->session_info.cust_get_pointer_state = AUDIO_CUST_GET_POINTER_INIT; /* inform the L1 to use the buffer 0 */ p_session->session_info.index_l1 = 0; /* inform the FFS downloader to fill the buffer 0 when the L1 doesn't used */ p_session->session_info.index_ffs = 0; p_session->session_req.session_mode = AUDIO_FFS_FLASH_2_RAM_SESSION; /* a new session is valid now */ p_session->session_req.valid_channel = TRUE; /* Active the downloader if it is not already activated */ active_task = 0; for (j=0; j<AUDIO_FFS_MAX_CHANNEL; j++) { if ( p_audio_gbl_var->audio_ffs_session[j].session_req.valid_channel ) { active_task++; } } AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: active session", active_task, RV_TRACE_LEVEL_DEBUG_LOW); if (active_task == 1) { AUDIO_SEND_TRACE("AUDIO FFS MANAGER: start FFS DOWNLOADER", RV_TRACE_LEVEL_DEBUG_LOW); /* Active asap the FFS downloader */ rvf_start_timer(AUDIO_FFS_TIMER, AUDIO_FFS_ACTIVE_NOW, AUDIO_FFS_ONE_SHOT_TIMER); } /* Send the message to confirm that the first buffer is downloaded */ /* allocate the message buffer */ mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal, sizeof (T_AUDIO_FFS_INIT), (T_RVF_BUFFER **) (&p_send_message)); /* If insufficient resources, then report a memory error and abort. */ if (mb_status == RVF_RED) { audio_ffs_error_trace(AUDIO_ENTITY_NO_MEMORY); } /* fill the header of the message */ ((T_AUDIO_FFS_INIT*)(p_send_message))->os_hdr.msg_id = AUDIO_FFS_INIT_DONE; /* fill the status parameters */ ((T_AUDIO_FFS_INIT *)(p_send_message))->session_id = ((T_AUDIO_FFS_FLASH_2_RAM_START *)p_message)->session_id; ((T_AUDIO_FFS_INIT *)(p_send_message))->channel_id = channel_id; /* send the message to the AUDIO entity */ rvf_send_msg (p_audio_gbl_var->addrId, p_send_message); break; } case AUDIO_FFS_RAM_2_FLASH_START_REQ: { AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: RAM to flash session_id", ((T_AUDIO_FFS_RAM_2_FLASH_START *)p_message)->session_id, RV_TRACE_LEVEL_DEBUG_LOW); /* Find a free channel */ channel_id = 0; while ( (p_audio_gbl_var->audio_ffs_session[channel_id].session_req.valid_channel) && (channel_id < AUDIO_FFS_MAX_CHANNEL) ) channel_id++; AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: open channel", channel_id, RV_TRACE_LEVEL_DEBUG_LOW); p_session = &(p_audio_gbl_var->audio_ffs_session[channel_id]); /* fill the request structure corresponding to the session id */ p_session->session_req.size = ((T_AUDIO_FFS_RAM_2_FLASH_START *)p_message)->initial_size; p_session->session_req.loop_mode = FALSE; p_session->session_req.audio_ffs_fd = ((T_AUDIO_FFS_RAM_2_FLASH_START *)p_message)->audio_ffs_fd; p_session->session_req.session_mode = AUDIO_FFS_RAM_2_FLASH_SESSION; p_session->session_req.session_id = ((T_AUDIO_FFS_RAM_2_FLASH_START *)p_message)->session_id; /********************* TO BE COMPLETED **********************/ /* the FFS must allocate the first buffer to the RAM */ /************************************************************/ for (j=0; j<2; j++) { mb_status = rvf_get_buf (p_audio_gbl_var->mb_audio_ffs, p_session->session_req.size, (T_RVF_BUFFER **) (&p_session->session_info.buffer[j].p_start_pointer)); /* If insufficient resources, then report a memory error and abort. */ if (mb_status == RVF_RED) { audio_ffs_error_trace(AUDIO_ENTITY_NO_MEMORY); } AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: allocate buffer", j, RV_TRACE_LEVEL_DEBUG_LOW); /* Copy the initial size */ p_session->session_info.buffer[j].size = p_session->session_req.size; } /* initialize the cust_get_pointer state machine */ p_session->session_info.cust_get_pointer_state = AUDIO_CUST_GET_POINTER_INIT; /* inform the L1 to use the buffer 0 */ p_session->session_info.index_l1 = 0; /* inform the FFS downloader to read the buffer 0 when the L1 doesn't used */ p_session->session_info.index_ffs = 0; /* a new session is valid now */ p_session->session_req.valid_channel = TRUE; /* Active the downloader if it is not already activated */ active_task = 0; for (j=0; j<AUDIO_FFS_MAX_CHANNEL; j++) { if ( p_audio_gbl_var->audio_ffs_session[j].session_req.valid_channel) { active_task++; } } AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: active session", active_task, RV_TRACE_LEVEL_DEBUG_LOW); if (active_task == 1) { AUDIO_SEND_TRACE("AUDIO FFS MANAGER: start FFS DOWNLOADER", RV_TRACE_LEVEL_DEBUG_LOW); /* Active asap the FFS downloader */ rvf_start_timer(AUDIO_FFS_TIMER, AUDIO_FFS_ACTIVE_NOW, AUDIO_FFS_ONE_SHOT_TIMER); } /* Send the message to confirm that the first buffer is allocated */ /* allocate the message buffer */ mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal, sizeof (T_AUDIO_FFS_INIT), (T_RVF_BUFFER **) (&p_send_message)); /* If insufficient resources, then report a memory error and abort. */ if (mb_status == RVF_RED) { audio_ffs_error_trace(AUDIO_ENTITY_NO_MEMORY); } /* fill the header of the message */ ((T_AUDIO_FFS_INIT*)(p_send_message))->os_hdr.msg_id = AUDIO_FFS_INIT_DONE; /* fill the status parameters */ ((T_AUDIO_FFS_INIT *)(p_send_message))->session_id = ((T_AUDIO_FFS_RAM_2_FLASH_START *)p_message)->session_id; ((T_AUDIO_FFS_INIT *)(p_send_message))->channel_id = channel_id; /* send the message to the AUDIO entity */ rvf_send_msg (p_audio_gbl_var->addrId, p_send_message); break; } case AUDIO_FFS_STOP_REQ: { /* Find a channel corresponding to this session */ channel_id = 0; while ( (p_audio_gbl_var->audio_ffs_session[channel_id].session_req.session_id != ((T_AUDIO_FFS_STOP_REQ *)p_message)->session_id) && (channel_id < AUDIO_FFS_MAX_CHANNEL) ) channel_id++; p_session = &(p_audio_gbl_var->audio_ffs_session[channel_id]); AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: stop session_id", ((T_AUDIO_FFS_STOP_REQ *)p_message)->session_id, RV_TRACE_LEVEL_DEBUG_LOW); AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: close channel", channel_id, RV_TRACE_LEVEL_DEBUG_LOW); /* the task is stopped */ p_session->session_req.valid_channel = FALSE; /* the stop process depends on the session_mode and sometimes the session_id */ #if (VOICE_MEMO) if ( (p_session->session_req.session_mode == AUDIO_FFS_RAM_2_FLASH_SESSION) && (((T_AUDIO_FFS_STOP_REQ *)p_message)->session_id == AUDIO_FFS_SESSION_VM_RECORD) ) { index_l1 = p_session->session_info.index_l1; index_ffs = p_session->session_info.index_ffs; if (index_ffs != index_l1) /* There's two buffers to save: one full (index_ffs) and one not full (index_l1) */ { AUDIO_SEND_TRACE("AUDIO FFS MANAGER: end of VM record session with index_l1<>index_ffs", RV_TRACE_LEVEL_DEBUG_LOW); #ifndef _WINDOWS /* save the full buffer */ if ((ffs_write (p_session->session_req.audio_ffs_fd, p_session->session_info.buffer[index_ffs].p_start_pointer, p_session->session_req.size)) < EFFS_OK) { audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_SAVED); } /* save a part of the buffer pointed by the L1 */ voice_memo_size = 2; p_scan = (UINT16 *)(p_session->session_info.buffer[index_l1].p_start_pointer); while ( (*p_scan++) != SC_VM_END_MASK ) { voice_memo_size += 2; } if ((ffs_write (p_session->session_req.audio_ffs_fd, p_session->session_info.buffer[index_l1].p_start_pointer, voice_memo_size)) < EFFS_OK) { audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_SAVED); } #endif } else /* 1 buffer (not full) needs to be saved */ { AUDIO_SEND_TRACE("AUDIO FFS MANAGER: end of VM record session with index_l1==index_ffs", RV_TRACE_LEVEL_DEBUG_LOW); #ifndef _WINDOWS voice_memo_size = 2; p_scan = (UINT16*)(p_session->session_info.buffer[index_l1].p_start_pointer); while ( (*p_scan++) != SC_VM_END_MASK ) { voice_memo_size += 2; } if ((ffs_write (p_session->session_req.audio_ffs_fd, p_session->session_info.buffer[index_l1].p_start_pointer, voice_memo_size)) < EFFS_OK) { audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_SAVED); } #endif } /* index_ffs != index_l1 */ } #endif /* VOICE_MEMO */ /* deallocate the buffers */ for (j=0; j<AUDIO_MAX_FFS_BUFFER_PER_SESSION; j++) { status = rvf_free_buf ( (T_RVF_BUFFER *)(p_session->session_info.buffer[j].p_start_pointer) ); if (status != RVF_GREEN) { AUDIO_SEND_TRACE(" wrong buffer deallocated ", RV_TRACE_LEVEL_ERROR); } AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: deallocate buffer", j, RV_TRACE_LEVEL_DEBUG_LOW); } /* Close the FFS file */ #ifndef _WINDOWS if ( ffs_close(p_session->session_req.audio_ffs_fd) != EFFS_OK ) { audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_CLOSE); } #endif /* Send the message to confirm that the session is stopped */ /* allocate the message buffer */ mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal, sizeof (T_AUDIO_FFS_STOP_CON), (T_RVF_BUFFER **)(&p_send_message)); /* If insufficient resources, then report a memory error and abort. */ if (mb_status == RVF_RED) { audio_ffs_error_trace(AUDIO_ENTITY_NO_MEMORY); } /* fill the header of the message */ ((T_AUDIO_FFS_STOP_CON*)(p_send_message))->os_hdr.msg_id = AUDIO_FFS_STOP_CON; /* fill the status parameters */ ((T_AUDIO_FFS_STOP_CON*)(p_send_message))->session_id = ((T_AUDIO_FFS_STOP_REQ *)p_message)->session_id; /* send the message to the AUDIO entity */ rvf_send_msg (p_audio_gbl_var->addrId, p_send_message); break; } } /* switch (p_message) */ } /********************************************************************************/ /* */ /* Function Name: audio_ffs_downloader */ /* */ /* Purpose: This function is called to download the melody, voice memo data */ /* between the RAM and the FLASH. */ /* */ /* Input Parameters: */ /* None. */ /* */ /* Output Parameters: */ /* None. */ /* */ /* Note: */ /* None. */ /* */ /* Revision History: */ /* None. */ /* */ /********************************************************************************/ void audio_ffs_downloader(void) { UINT8 i, index_ffs, index_l1, *p_buffer; T_AUDIO_FFS_SESSION *p_session; UINT16 buffer_size; T_FFS_SIZE size = 0; BOOLEAN loop_mode, active_session; /* Scan all session in order to know which is valid */ active_session = FALSE; for (i=0; i<AUDIO_FFS_MAX_CHANNEL; i++) { p_session = &(p_audio_gbl_var->audio_ffs_session[i]); if (p_session->session_req.valid_channel) { /* a session is valid */ active_session = TRUE; index_l1 = p_session->session_info.index_l1; index_ffs = p_session->session_info.index_ffs; if (index_l1 != index_ffs) /* It's time to download a new buffer for the L1 */ { AUDIO_SEND_TRACE_PARAM("AUDIO FFS DOWNLOADER: index_l1", index_l1, RV_TRACE_LEVEL_DEBUG_LOW); AUDIO_SEND_TRACE_PARAM("AUDIO FFS DOWNLOADER: index_ffs", index_ffs, RV_TRACE_LEVEL_DEBUG_LOW); switch (p_session->session_req.session_mode) { case AUDIO_FFS_FLASH_2_RAM_SESSION: { AUDIO_SEND_TRACE("AUDIO FFS DOWNLOADER: FLASH to RAM", RV_TRACE_LEVEL_DEBUG_LOW); /* Fill the buffer 0 while it isn't full in case of the loop back mode activated */ loop_mode = TRUE; buffer_size = p_session->session_info.buffer[index_ffs].size; p_buffer = (UINT8 *)p_session->session_info.buffer[index_ffs].p_start_pointer; while ( (p_buffer < p_session->session_info.buffer[index_ffs].p_stop_pointer) && (loop_mode) ) { loop_mode = p_session->session_req.loop_mode; #ifndef _WINDOWS size = ffs_read(p_session->session_req.audio_ffs_fd, p_buffer, buffer_size); #endif AUDIO_SEND_TRACE_PARAM("AUDIO FFS MANAGER: ffs_read size", size, RV_TRACE_LEVEL_DEBUG_LOW); buffer_size -= size; p_buffer += size; if (buffer_size != 0) { #ifndef _WINDOWS /* reset the FFS pointer */ ffs_seek(p_session->session_req.audio_ffs_fd, 0, FFS_SEEK_SET); #endif } } /* while */ break; } case AUDIO_FFS_RAM_2_FLASH_SESSION: { AUDIO_SEND_TRACE("AUDIO FFS DOWNLOADER: RAM to FLASH", RV_TRACE_LEVEL_DEBUG_LOW); /* save the full buffer */ #ifndef _WINDOWS if ((ffs_write (p_session->session_req.audio_ffs_fd, p_session->session_info.buffer[index_ffs].p_start_pointer, p_session->session_req.size)) < EFFS_OK) { audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_SAVED); } #endif break; } } /* switch (p_session->session_req.session_mode) */ /* update the ffs buffer index */ p_session->session_info.index_ffs++; if (p_session->session_info.index_ffs == AUDIO_MAX_FFS_BUFFER_PER_SESSION) { p_session->session_info.index_ffs = 0; } } /* (p_session->session_info.index_l1 != p_session->session_info.index_l1) */ } /* valid session */ } /* for (i=0; i<AUDIO_FFS_MAX_CHANNEL; i++) */ /* Activate or not the Timer the next time */ if (active_session) { rvf_start_timer(AUDIO_FFS_TIMER, AUDIO_FFS_TIME_OUT, AUDIO_FFS_ONE_SHOT_TIMER); } else { AUDIO_SEND_TRACE("AUDIO FFS DOWNLOADER: stop", RV_TRACE_LEVEL_DEBUG_LOW); /* Stop asap the FFS downloader */ rvf_stop_timer(AUDIO_FFS_TIMER); } } #endif /* MELODY_E1 || MELODY_E2 || VOICE_MEMO */ #if (L1_VOICE_MEMO_AMR) T_AUDIO_RET audio_convert_to_mms(UINT8 *p_buffer, UINT16 *buffer_size, UINT8 *previous_type, UINT8 *size_left) { UINT8 rxtx_type, frame_header, data_size; UINT8 frame_type, quality; UINT8 *ptr_final, *ptr_mms; ptr_mms = p_buffer; ptr_final = ptr_mms + *buffer_size; /* sample is shared among the 2 buffers */ if (*size_left > 0) { UINT8 i; switch (*previous_type) { case AUDIO_VM_AMR_RXTX_SID_FIRST: /* set data bits to 0 */ for (i = 0; i < *size_left; i++) *(ptr_mms + i) = 0; /* set Mode Indication */ *(ptr_mms + *size_left - 1) = AUDIO_MMS_MODE_INDICATION; break; case AUDIO_VM_AMR_RXTX_SID_UPDATE: //case AUDIO_VM_AMR_RXTX_SID_BAD: *(ptr_mms + *size_left - 1) |= AUDIO_MMS_STI_BIT | AUDIO_MMS_MODE_INDICATION; break; } ptr_mms += *size_left; } *size_left = 0; while (ptr_mms < ptr_final) { /* read header */ frame_header = *ptr_mms; /* if end_mask, stop */ if (frame_header == SC_VM_AMR_END_MASK) { *buffer_size = (ptr_mms - p_buffer); return AUDIO_OK; } /* reset header */ *ptr_mms = 0; rxtx_type = (frame_header & SC_RX_TX_TYPE_MASK); *previous_type = rxtx_type; switch (rxtx_type) { case AUDIO_VM_AMR_RXTX_SPEECH_GOOD: //case AUDIO_VM_AMR_RXTX_SPEECH_BAD: { /* FT + data_size */ frame_type = frame_header & SC_CHAN_TYPE_MASK; switch (frame_type) { case AUDIO_VM_AMR_SPEECH_475: data_size = AUDIO_VM_AMR_SPEECH_475_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_515: data_size = AUDIO_VM_AMR_SPEECH_515_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_59: data_size = AUDIO_VM_AMR_SPEECH_590_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_67: data_size = AUDIO_VM_AMR_SPEECH_670_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_74: data_size = AUDIO_VM_AMR_SPEECH_740_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_795: data_size = AUDIO_VM_AMR_SPEECH_795_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_102: data_size = AUDIO_VM_AMR_SPEECH_102_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_122: data_size = AUDIO_VM_AMR_SPEECH_122_DATA_SIZE; break; } /* Q */ //if (rxtx_type == AUDIO_VM_AMR_RXTX_SPEECH_GOOD) quality = AUDIO_MMS_GOOD_QUALITY; //else // quality = AUDIO_MMS_BAD_QUALITY; } break; case AUDIO_VM_AMR_RXTX_SID_FIRST: case AUDIO_VM_AMR_RXTX_SID_UPDATE: //case AUDIO_VM_AMR_RXTX_SID_BAD: { /* FT, data_size, Q */ frame_type = AUDIO_MMS_SID_FRAME_TYPE; data_size = AUDIO_VM_AMR_SID_DATA_SIZE; //if ((rxtx_type == AUDIO_VM_AMR_RXTX_SID_FIRST)|| // (rxtx_type == AUDIO_VM_AMR_RXTX_SID_UPDATE)) //{ quality = AUDIO_MMS_GOOD_QUALITY; //} //else // quality = AUDIO_MMS_BAD_QUALITY; /* data, STI, Mode indication */ if (rxtx_type == AUDIO_VM_AMR_RXTX_SID_FIRST) { UINT8 data, i; /* number of bytes to set to 0 */ data = ((ptr_final - ptr_mms) >= (data_size + 1)) ? (data_size) : (ptr_final - ptr_mms - 1); /* set data bits to 0 */ for (i = 0; i < data; i++) *(ptr_mms + 1 + i) = 0; /* set Mode indication */ if ((ptr_final - ptr_mms) >= (data_size + 1)) *(ptr_mms + data_size) = AUDIO_MMS_MODE_INDICATION; } /* SID_UPDATE */ else { /* set STI bit to 1 + Mode indication */ if ((ptr_final - ptr_mms) >= (data_size + 1)) *(ptr_mms + data_size) |= AUDIO_MMS_STI_BIT | AUDIO_MMS_MODE_INDICATION; } } break; case AUDIO_VM_AMR_RXTX_NO_DATA: frame_type = AUDIO_MMS_NO_DATA_FRAME_TYPE; data_size = AUDIO_VM_AMR_NO_DATA_DATA_SIZE; quality = AUDIO_MMS_GOOD_QUALITY; break; default: { AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: convert to MMS, header not recognized", frame_header, RV_TRACE_LEVEL_DEBUG_LOW); return AUDIO_ERROR; } } /* write header */ *(ptr_mms)++ |= (frame_type << AUDIO_MMS_FRAME_TYPE_SHIFT) | (quality << AUDIO_MMS_QUALITY_SHIFT); /* write data, check we are not at the end of the buffer */ if ((ptr_final - ptr_mms) < data_size) { *size_left = data_size - (ptr_final - ptr_mms); data_size = ptr_final - ptr_mms; } ptr_mms += data_size; } *buffer_size = (ptr_final - p_buffer); return AUDIO_OK; } T_AUDIO_RET audio_convert_from_mms(UINT8 *p_buffer, UINT16 buffer_size, UINT8 *previous_type, UINT8 *size_left) { UINT8 frame_header, data_size; UINT8 frame_type, quality; UINT8 *ptr_final, *ptr_mms; ptr_mms = p_buffer; ptr_final = ptr_mms + buffer_size; /* a sample is split between 2 RAM buffers */ if (*size_left > 0) { /* if SID sample, remove STI and mode indication */ if (*previous_type == AUDIO_MMS_SID_FRAME_TYPE) { *(ptr_mms + *size_left - 1) &= (~(AUDIO_MMS_STI_BIT | AUDIO_MMS_MODE_INDICATION)); } ptr_mms += *size_left; *size_left = 0; } while (ptr_mms < ptr_final) { /* read header */ frame_header = *ptr_mms; /* reset header */ *ptr_mms = 0; /* FT and Q */ frame_type = (frame_header & AUDIO_MMS_FRAME_TYPE_MASK) >> AUDIO_MMS_FRAME_TYPE_SHIFT; quality = (frame_header & AUDIO_MMS_QUALITY_MASK) >> AUDIO_MMS_QUALITY_SHIFT; *previous_type = frame_type; /* Identify sample */ if (frame_type < AUDIO_MMS_SID_FRAME_TYPE) { /* speech good or bad */ *ptr_mms |= frame_type; if (quality == AUDIO_MMS_GOOD_QUALITY) *ptr_mms |= AUDIO_VM_AMR_RXTX_SPEECH_GOOD; else *ptr_mms |= AUDIO_VM_AMR_RXTX_SPEECH_BAD; switch (frame_type) { case AUDIO_VM_AMR_SPEECH_475: data_size = AUDIO_VM_AMR_SPEECH_475_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_515: data_size = AUDIO_VM_AMR_SPEECH_515_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_59: data_size = AUDIO_VM_AMR_SPEECH_590_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_67: data_size = AUDIO_VM_AMR_SPEECH_670_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_74: data_size = AUDIO_VM_AMR_SPEECH_740_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_795: data_size = AUDIO_VM_AMR_SPEECH_795_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_102: data_size = AUDIO_VM_AMR_SPEECH_102_DATA_SIZE; break; case AUDIO_VM_AMR_SPEECH_122: data_size = AUDIO_VM_AMR_SPEECH_122_DATA_SIZE; break; } } else if (frame_type == AUDIO_MMS_SID_FRAME_TYPE) { data_size = AUDIO_VM_AMR_SID_DATA_SIZE; /* SID_BAD */ if (quality == AUDIO_MMS_BAD_QUALITY) *ptr_mms |= AUDIO_VM_AMR_RXTX_SID_BAD; /* SID_FIRST or SID_UPDATE */ else { if (*previous_type == AUDIO_MMS_NO_DATA_FRAME_TYPE) *ptr_mms |= AUDIO_VM_AMR_RXTX_SID_UPDATE; else *ptr_mms |= AUDIO_VM_AMR_RXTX_SID_FIRST; /* try to remove STI + mode indication if sample not split between 2 buffers */ if ((ptr_final - ptr_mms) >= (data_size + 1)) *(ptr_mms + data_size) &= (~(AUDIO_MMS_STI_BIT | AUDIO_MMS_MODE_INDICATION)); } } else if (frame_type == AUDIO_MMS_NO_DATA_FRAME_TYPE) { data_size = AUDIO_VM_AMR_NO_DATA_DATA_SIZE; *ptr_mms |= AUDIO_VM_AMR_RXTX_NO_DATA; } else { AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: convert from MMS, header not recognized", frame_header, RV_TRACE_LEVEL_DEBUG_LOW); return AUDIO_ERROR; } /* pass header */ ptr_mms++; /* write data, check we are not at the end of the buffer */ if ((ptr_final - ptr_mms) < data_size) { *size_left = data_size - (ptr_final - ptr_mms); data_size = ptr_final - ptr_mms; } ptr_mms += data_size; } return AUDIO_OK; } #endif #if (AUDIO_RAM_MANAGER) /* try to copy "size" bytes from audio_ram_fd to dest_buffer, returns bytes copied (0 to size) */ INT16 ram_read(T_AUDIO_MEM_SESSION *p_session, UINT8 *dest_buffer, UINT16 size) { UINT16 i; /* check how many bytes there are in audio_ram_fd */ if (size > p_session->session_req.audio_ram_size) size = p_session->session_req.audio_ram_size; /* copy byte by byte */ for (i = 0; i < size; i++) *dest_buffer++ = *(p_session->session_req.audio_ram_fd)++; /* update audio_ram_fd size */ p_session->session_req.audio_ram_size -= size; return size; } /* copy "size" bytes from src_buffer to audio_ram_fd, does not check size */ INT16 ram_write(T_AUDIO_MEM_SESSION *p_session, UINT8 *src_buffer, UINT16 size) { UINT16 i; /* copy byte by byte */ for (i = 0; i < size; i++) *(p_session->session_req.audio_ram_fd)++ = *src_buffer++; return size; } #endif #if (AUDIO_MEM_MANAGER) void audio_mem_send_status(T_AUDIO_RET status, UINT8 channel_id, UINT8 status_type, T_RV_RETURN return_path) { /* status_type START or STOP, status AUDIO_OK or AUDIO_ERROR */ T_AUDIO_MEM_STATUS *p_send_message; T_RVF_MB_STATUS mb_status = RVF_RED; while (mb_status == RVF_RED) { /* allocate the message buffer */ mb_status = rvf_get_buf (p_audio_gbl_var->mb_external, sizeof (T_AUDIO_MEM_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_mem_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_MEM_STATUS_MSG; /* fill the status parameters */ p_send_message->status = status; p_send_message->channel_id = channel_id; p_send_message->status_type = status_type; /* 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_mem_send_record_status(UINT8 channel_id, UINT32 recorded_size, T_RV_RETURN return_path) { /* status_type START or STOP, status AUDIO_OK or AUDIO_ERROR */ T_AUDIO_MEM_STATUS *p_send_message; T_RVF_MB_STATUS mb_status = RVF_RED; while (mb_status == RVF_RED) { /* allocate the message buffer */ mb_status = rvf_get_buf (p_audio_gbl_var->mb_external, sizeof (T_AUDIO_MEM_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_mem_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_MEM_STATUS_MSG; /* fill the status parameters */ p_send_message->status = AUDIO_OK; p_send_message->channel_id = channel_id; p_send_message->status_type = AUDIO_STOP_STATUS; p_send_message->recorded_size = 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_mem_manager (T_RV_HDR *p_message) { UINT8 channel_id, session_id, state; UINT8 mem_channel_id; T_RV_RETURN return_path; T_AUDIO_MEM_SESSION *p_session; /* get channel_id from messages */ switch (p_message->msg_id) { case AUDIO_MEM_START_REQ: channel_id = ((T_AUDIO_MEM_START *)p_message)->channel_id; session_id = ((T_AUDIO_MEM_START *)p_message)->session_id; break; case AUDIO_MEM_STOP_REQ: channel_id = ((T_AUDIO_MEM_STOP *)p_message)->channel_id; break; case AUDIO_DRIVER_NOTIFICATION_MSG: channel_id = ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id; break; case AUDIO_DRIVER_LAST_NOTIFICATION_MSG: channel_id = ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id; break; case AUDIO_DRIVER_STATUS_MSG: channel_id = ((T_AUDIO_DRIVER_STATUS *)p_message)->channel_id; break; } /* Init mem_channel_id to browse all mem channels and find channel_id */ /* state will stay IDLE if no mem channel is found */ mem_channel_id = 0; state = AUDIO_MEM_IDLE; /* look for an ACTIVE session, which channel_id matches the one from the message */ while ( (mem_channel_id < AUDIO_MEM_MAX_CHANNEL)&& ((p_audio_gbl_var->audio_mem_session[mem_channel_id].session_info.state == AUDIO_MEM_IDLE)|| (p_audio_gbl_var->audio_mem_session[mem_channel_id].session_req.channel_id != channel_id)) ) { mem_channel_id++; } /* if mem_channel_id < MAX_CHANNEL, we found an active channel so we can derive state */ if (mem_channel_id < AUDIO_MEM_MAX_CHANNEL) { p_session = &(p_audio_gbl_var->audio_mem_session[mem_channel_id]); state = p_session->session_info.state; } switch (state) { case AUDIO_MEM_IDLE: { /* requester return_path (currently is Riviera Audio) */ return_path.callback_func = NULL; return_path.addr_id = p_audio_gbl_var->addrId; switch (p_message->msg_id) { case AUDIO_MEM_START_REQ: { /* find free MEM channel i.e. state = AUDIO_MEM_IDLE */ mem_channel_id = 0; while ( (p_audio_gbl_var->audio_mem_session[mem_channel_id].session_info.state != AUDIO_MEM_IDLE) && (mem_channel_id < AUDIO_MEM_MAX_CHANNEL) ) mem_channel_id++; if (mem_channel_id == AUDIO_MEM_MAX_CHANNEL) { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: no memory channel available", RV_TRACE_LEVEL_DEBUG_LOW); audio_mem_send_status(AUDIO_ERROR, channel_id, AUDIO_START_STATUS, return_path); return; } /* get MEM session */ p_session = &(p_audio_gbl_var->audio_mem_session[mem_channel_id]); /* fill parameters */ p_session->session_req.channel_id = channel_id; p_session->session_req.session_id = session_id; #if (AUDIO_NEW_FFS_MANAGER) p_session->session_req.audio_ffs_fd = ((T_AUDIO_MEM_START *)p_message)->audio_ffs_fd; #endif #if (AUDIO_RAM_MANAGER) p_session->session_req.audio_ram_fd = ((T_AUDIO_MEM_START *)p_message)->audio_ram_fd; p_session->session_req.audio_ram_size = ((T_AUDIO_MEM_START *)p_message)->audio_ram_size; #endif p_session->session_req.size = ((T_AUDIO_MEM_START *)p_message)->size;// temporary RAM buffer size /* parameters for notification handling */ p_session->session_info.size_left = 0; p_session->session_info.previous_type = AUDIO_VM_AMR_RXTX_SPEECH_GOOD; p_session->session_info.stop_req_allowed = TRUE; /* initialization phase for play sessions */ switch (session_id) { case AUDIO_VM_AMR_PLAY_SESSION_ID: { UINT8 *play_buffer;// temporary RAM buffer to fill INT16 size_read; /* fill all buffers in advance */ while (audio_driver_get_play_buffer(channel_id, &play_buffer) == AUDIO_OK) { #if (AUDIO_NEW_FFS_MANAGER) /* write from FLASH to RAM buffer */ if (p_session->session_req.audio_ffs_fd != NULL) { /* copy from Flash "size" bytes into play_buffer */ size_read = ffs_read(p_session->session_req.audio_ffs_fd, play_buffer, p_session->session_req.size); /* wrong read */ if (size_read < EFFS_OK) { if ( ffs_close(p_session->session_req.audio_ffs_fd) != EFFS_OK ) audio_mem_error_trace(AUDIO_ENTITY_FILE_NO_CLOSE); AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER INIT: FFS PLAY READ failed", RV_TRACE_LEVEL_DEBUG_LOW); audio_mem_send_status(AUDIO_ERROR, channel_id, AUDIO_START_STATUS, return_path); return; } } #endif #if (AUDIO_RAM_MANAGER) /* write from RAM to RAM buffer */ if (p_session->session_req.audio_ram_fd != NULL) { /* copy from RAM "size" bytes into play_buffer */ size_read = ram_read(p_session, play_buffer, p_session->session_req.size); } #endif /* convert to MMS */ if (audio_convert_from_mms(play_buffer, size_read, &(p_session->session_info.previous_type), &(p_session->session_info.size_left)) != AUDIO_OK) { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER INIT: wrong MMS format", RV_TRACE_LEVEL_DEBUG_LOW); size_read = 0;// will fill buffer with END_MASK and stop task } /* last buffer already, put END_MASK */ if ( ((UINT16)size_read) < p_session->session_req.size ) { UINT16 i; if (p_session->session_info.size_left != 0) AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY DOWNLOADER: MMS PLAY file incomplete", p_session->session_info.size_left, RV_TRACE_LEVEL_DEBUG_LOW); for (i = size_read; i < p_session->session_req.size; i++) *(play_buffer + i) = SC_VM_AMR_END_MASK; } AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY DOWNLOADER: size read", size_read, RV_TRACE_LEVEL_DEBUG_LOW); audio_driver_play_buffer(channel_id, play_buffer); } }// case AUDIO_VM_AMR_PLAY_SESSION_ID break; }// switch (session_id) audio_driver_start_session(channel_id, return_path); p_session->session_info.state = AUDIO_MEM_WAIT_NOTIFICATION_OR_STOP; } break; //case AUDIO_MEM_START_REQ: case AUDIO_MEM_STOP_REQ: audio_mem_error_trace(AUDIO_ERROR_STOP_EVENT); break; } } // case AUDIO_MEM_IDLE: break; case AUDIO_MEM_WAIT_NOTIFICATION_OR_STOP: { /* requester return_path (currently is Riviera Audio) */ return_path.callback_func = NULL; return_path.addr_id = p_audio_gbl_var->addrId; switch (p_message->msg_id) { case AUDIO_DRIVER_NOTIFICATION_MSG: { switch (p_session->session_req.session_id) { case AUDIO_VM_AMR_RECORD_SESSION_ID: { UINT16 record_buffer_size; /* default is session_req.size but can be less if we find END_MASK */ record_buffer_size = p_session->session_req.size; /* convert to MMS, update record_buffer_size if END_MASK is found */ audio_convert_to_mms((UINT8 *)((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer, &record_buffer_size, &(p_session->session_info.previous_type), &(p_session->session_info.size_left)); #if (AUDIO_NEW_FFS_MANAGER) if (p_session->session_req.audio_ffs_fd != NULL) { if ((ffs_write (p_session->session_req.audio_ffs_fd, (UINT8 *)((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer, record_buffer_size)) < EFFS_OK) { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: FFS RECORD WRITE FAILED", RV_TRACE_LEVEL_DEBUG_LOW); } } #endif #if (AUDIO_RAM_MANAGER) if (p_session->session_req.audio_ram_fd != NULL) { ram_write (p_session, (UINT8 *)((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer, record_buffer_size); } #endif AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: RAM to MEMORY", record_buffer_size, RV_TRACE_LEVEL_DEBUG_LOW);//DEBUG } break; case AUDIO_VM_AMR_PLAY_SESSION_ID: { UINT8 *play_buffer; INT16 size_read; /* try to get a buffer */ if (audio_driver_get_play_buffer(channel_id, &play_buffer) == AUDIO_OK) { #if (AUDIO_NEW_FFS_MANAGER) if (p_session->session_req.audio_ffs_fd != NULL) { size_read = ffs_read(p_session->session_req.audio_ffs_fd, play_buffer, p_session->session_req.size); /* wrong read */ if (size_read < EFFS_OK) { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: FFS PLAY READ FAILED", RV_TRACE_LEVEL_DEBUG_LOW); size_read = 0;// will put END_MASK in whole buffer so stops play } } #endif #if (AUDIO_RAM_MANAGER) if (p_session->session_req.audio_ram_fd != NULL) { size_read = ram_read(p_session, play_buffer, p_session->session_req.size); } #endif if (audio_convert_from_mms(play_buffer, size_read, &(p_session->session_info.previous_type), &(p_session->session_info.size_left)) != AUDIO_OK) { AUDIO_SEND_TRACE("AUDIO MEMORY DOWNLOADER: wrong MMS format", RV_TRACE_LEVEL_DEBUG_LOW); size_read = 0;// will fill buffer with END_MASK } /* last buffer, put END_MASK */ if ( ((UINT16)size_read) < p_session->session_req.size ) { UINT16 i; if (p_session->session_info.size_left != 0) AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: MMS PLAY file incomplete", p_session->session_info.size_left, RV_TRACE_LEVEL_DEBUG_LOW); for (i = size_read; i < p_session->session_req.size; i++) *(play_buffer + i) = SC_VM_AMR_END_MASK; } audio_driver_play_buffer(channel_id, play_buffer); if (size_read > 0) { AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: MEMORY to RAM", size_read, RV_TRACE_LEVEL_DEBUG_LOW);//DEBUG } else { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: buffer not used", RV_TRACE_LEVEL_DEBUG_LOW);//DEBUG } } // if (audio_driver_get_play_buffer(channel_id, &p_buffer) == AUDIO_OK) else AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: no buffer available", RV_TRACE_LEVEL_DEBUG_LOW);//DEBUG } break; } } break; case AUDIO_DRIVER_LAST_NOTIFICATION_MSG: { UINT16 record_buffer_size; record_buffer_size = p_session->session_req.size; audio_convert_to_mms((UINT8 *)((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer, &record_buffer_size, &(p_session->session_info.previous_type), &(p_session->session_info.size_left)); #if (AUDIO_NEW_FFS_MANAGER) if (p_session->session_req.audio_ffs_fd != NULL) { if ((ffs_write (p_session->session_req.audio_ffs_fd, (UINT8 *)((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer, record_buffer_size)) < EFFS_OK) { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: FFS RECORD WRITE FAILED", RV_TRACE_LEVEL_DEBUG_LOW); } } #endif #if (AUDIO_RAM_MANAGER) if (p_session->session_req.audio_ram_fd != NULL) { if ((ram_write (p_session, (UINT8 *)((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->p_buffer, record_buffer_size)) < 0) { AUDIO_SEND_TRACE("AUDIO MEMORY MANAGER: RAM RECORD WRITE FAILED", RV_TRACE_LEVEL_DEBUG_LOW); } } #endif /* recorded_size */ AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: last RAM to MEMORY", record_buffer_size, RV_TRACE_LEVEL_DEBUG_LOW); AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: size recorded", ((T_AUDIO_DRIVER_LAST_NOTIFICATION *)p_message)->recorded_size, RV_TRACE_LEVEL_DEBUG_LOW); p_session->session_info.recorded_size = ((T_AUDIO_DRIVER_LAST_NOTIFICATION *)p_message)->recorded_size; /* stop must no longer be accepted as it is an automatic stop */ p_session->session_info.stop_req_allowed = FALSE; /* MEM return_path */ return_path.callback_func = NULL; return_path.addr_id = p_audio_gbl_var->addrId; audio_driver_free_session(channel_id, return_path); } break; case AUDIO_DRIVER_STATUS_MSG: { /* STOP OK for play */ /* FREE OK for record */ if ( ( (((T_AUDIO_DRIVER_STATUS *)p_message)->status_type == AUDIO_STOP_STATUS) && (((T_AUDIO_DRIVER_STATUS *)p_message)->status == AUDIO_OK)) || ( (((T_AUDIO_DRIVER_STATUS *)p_message)->status_type == AUDIO_FREE_STATUS) && (((T_AUDIO_DRIVER_STATUS *)p_message)->status == AUDIO_OK)) ) { #if (AUDIO_NEW_FFS_MANAGER) if (p_session->session_req.audio_ffs_fd != NULL) { if ( ffs_close(p_session->session_req.audio_ffs_fd) != EFFS_OK ) { audio_ffs_error_trace(AUDIO_ENTITY_FILE_NO_CLOSE); } AUDIO_SEND_TRACE_PARAM("AUDIO MEMORY MANAGER: close FFS file for mem channel:", mem_channel_id, RV_TRACE_LEVEL_DEBUG_LOW); } #endif if (((T_AUDIO_DRIVER_STATUS *)p_message)->status_type == AUDIO_FREE_STATUS) audio_mem_send_record_status(channel_id, p_session->session_info.recorded_size, return_path); else audio_mem_send_status(AUDIO_OK, channel_id, AUDIO_STOP_STATUS, return_path); p_session->session_info.state = AUDIO_MEM_IDLE; } } //case AUDIO_DRIVER_STATUS_MSG: break; case AUDIO_MEM_STOP_REQ: { /* check stop req is allowed i.e. no previous stop req, nor automatic stop */ if (p_session->session_info.stop_req_allowed == TRUE) { p_session->session_info.stop_req_allowed = FALSE; audio_driver_stop_session(channel_id); } else { audio_mem_error_trace(AUDIO_ERROR_STOP_EVENT); //audio_mem_send_status(AUDIO_ERROR, channel_id, AUDIO_STOP_STATUS, return_path); } } break; case AUDIO_MEM_START_REQ: audio_mem_error_trace(AUDIO_ERROR_START_EVENT); //audio_mem_send_status(AUDIO_ERROR, channel_id, AUDIO_START_STATUS, return_path); break; }//switch (p_message->msg_id) } //case AUDIO_MEM_WAIT_NOTIFICATION_OR_STOP: break; } // switch(state) } UINT8 audio_mem_message_switch(T_RV_HDR *p_message) { UINT8 channel_id; UINT8 mem_channel_id = 0; /* MEM START and STOP */ if ((p_message->msg_id == AUDIO_MEM_START_REQ)|| (p_message->msg_id == AUDIO_MEM_STOP_REQ)) return 1; /* For other messages, we must check channel_id is really handled by MEM and not by other managers such as streaming or UART */ if (p_message->msg_id == AUDIO_DRIVER_STATUS_MSG) channel_id = ((T_AUDIO_DRIVER_STATUS *)p_message)->channel_id; if (p_message->msg_id == AUDIO_DRIVER_NOTIFICATION_MSG) channel_id = ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id; if (p_message->msg_id == AUDIO_DRIVER_LAST_NOTIFICATION_MSG) channel_id = ((T_AUDIO_DRIVER_NOTIFICATION *)p_message)->channel_id; /* find active MEM session handling channel_id */ while ( (mem_channel_id < AUDIO_MEM_MAX_CHANNEL) && ((p_audio_gbl_var->audio_mem_session[mem_channel_id].session_info.state == AUDIO_MEM_IDLE)|| (p_audio_gbl_var->audio_mem_session[mem_channel_id].session_req.channel_id != channel_id))) { mem_channel_id++; } if (mem_channel_id == AUDIO_MEM_MAX_CHANNEL) return 0; else return 1; } #endif // AUDIO_MEM_MANAGER #endif /* RVM_AUDIO_MAIN_SWE */