FreeCalypso > hg > leo2moko-debug
view chipsetsw/services/Audio/audio_driver.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 source
/****************************************************************************/ /* */ /* File Name: audio_driver.c */ /* */ /* Purpose: This file contains all the functions used to manage the */ /* driver. */ /* */ /* Version 0.1 */ /* */ /* Date Modification */ /* ------------------------------------ */ /* 09 December 2002 Create */ /* */ /* Author Frederic Turgis */ /* */ /* (C) Copyright 2002 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 "rvf/rvf_api.h" #include "rv/rv_general.h" #include "rvm/rvm_gen.h" #include "audio/audio_features_i.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" #ifndef _WINDOWS // include the usefull L1 header #define BOOL_FLAG #define CHAR_FLAG #include "l1_types.h" #include "cust_os.h" #include "l1audio_cust.h" #include "l1audio_msgty.h" #include "l1audio_signa.h" #include "l1_signa.h" #else // include the usefull L1 header #define BOOL_FLAG #define CHAR_FLAG #include "l1_types.h" #include "l1audio_const.h" #include "l1audio_cust.h" #include "l1audio_defty.h" #include "l1audio_msgty.h" #include "l1audio_signa.h" #include "l1_const.h" #include "l1_defty.h" #include "l1_msgty.h" #include "l1_signa.h" #include "l1_varex.h" #include "audio/tests/audio_test.h" #endif #if (L1_AUDIO_DRIVER) #if (L1_VOICE_MEMO_AMR) extern T_AUDIO_RET audio_driver_vm_amr_play_manager (T_RV_HDR *p_message, T_AUDIO_DRIVER_SESSION *p_session); extern T_AUDIO_RET audio_driver_vm_amr_record_manager (T_RV_HDR *p_message, T_AUDIO_DRIVER_SESSION *p_session); extern T_AUDIO_RET audio_driver_midi_manager (T_RV_HDR *p_message, T_AUDIO_DRIVER_SESSION *p_session); #endif UINT8 audio_driver_message_switch(T_RV_HDR *p_message); void audio_driver_send_status (T_AUDIO_RET status, UINT8 status_type, UINT8 channel_id, T_RV_RETURN return_path); void audio_driver_init_send_status (T_AUDIO_RET status, UINT8 session_id, UINT8 channel_id, T_RV_RETURN return_path); void audio_driver_manager(T_RV_HDR *p_message); T_AUDIO_RET audio_driver_get_play_buffer(UINT8 channel_id, UINT8 **pp_buffer); T_AUDIO_RET audio_driver_play_buffer(UINT8 channel_id, UINT8 *p_buffer); UINT8 audio_driver_message_switch(T_RV_HDR *p_message) { switch (p_message->msg_id) { case AUDIO_DRIVER_START_SESSION: case AUDIO_DRIVER_STOP_SESSION: case AUDIO_DRIVER_FREE_SESSION: return(AUDIO_DRIVER_SWITCH); break; #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case MMI_VM_AMR_RECORD_START_CON: case MMI_VM_AMR_RECORD_STOP_CON: return(AUDIO_DRIVER_VM_AMR_RECORD_SESSION_SWITCH); break; case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: case MMI_VM_AMR_PLAY_START_CON: case MMI_VM_AMR_PLAY_STOP_CON: return(AUDIO_DRIVER_VM_AMR_PLAY_SESSION_SWITCH); break; #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: case MMI_MIDI_START_CON: case MMI_MIDI_STOP_CON: return(AUDIO_DRIVER_MIDI_SESSION_SWITCH); break; #endif default: return(AUDIO_DRIVER_NONE); break; } // switch } void audio_driver_send_status (T_AUDIO_RET status, UINT8 status_type, UINT8 channel_id, T_RV_RETURN return_path) { T_AUDIO_DRIVER_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_DRIVER_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_driver_error_trace(AUDIO_ENTITY_NO_MEMORY); rvf_delay(RVF_MS_TO_TICKS(1000)); } } // fill the header of the message + parameters p_send_message->os_hdr.msg_id = AUDIO_DRIVER_STATUS_MSG; p_send_message->status = status; p_send_message->status_type = status_type; p_send_message->channel_id = channel_id; // 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_driver_init_send_status (T_AUDIO_RET status, UINT8 session_id, UINT8 channel_id, T_RV_RETURN return_path) { T_AUDIO_DRIVER_INIT_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_DRIVER_INIT_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_driver_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_DRIVER_INIT_STATUS_MSG; // fill the status parameters p_send_message->status = status; p_send_message->session_id = session_id; p_send_message->channel_id = channel_id; // 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_driver_manager(T_RV_HDR *p_message) { T_AUDIO_DRIVER_SESSION *p_session; T_AUDIO_DRIVER_PARAMETER *driver_parameter; T_RV_RETURN return_path; T_RVF_MB_STATUS mb_status; UINT8 session_id, channel_id, state, j; // initialize return_path to default values return_path.callback_func=NULL; return_path.addr_id=0; // find state + extract information:channel_id or session_id + driver_parameter switch (p_message->msg_id) { // start/stop session messages have channel_id so we know the driver_session case AUDIO_DRIVER_START_SESSION: case AUDIO_DRIVER_STOP_SESSION: case AUDIO_DRIVER_FREE_SESSION: channel_id = ((T_AUDIO_DRIVER_HANDLE_SESSION *)p_message)->channel_id; p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); state = p_session->session_info.state; if (p_message->msg_id != AUDIO_DRIVER_STOP_SESSION) return_path = ((T_AUDIO_DRIVER_HANDLE_SESSION *)p_message)->return_path; else return_path = p_session->session_req.return_path; break; // messages which contain only session_id, must look for it in ACTIVE driver_session default: { switch (p_message->msg_id) { #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: session_id = AUDIO_VM_AMR_RECORD_SESSION_ID; driver_parameter = &(((T_AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION *)p_message)->driver_parameter); return_path = ((T_AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION *)p_message)->return_path; break; case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: session_id = AUDIO_VM_AMR_PLAY_SESSION_ID; driver_parameter = & (((T_AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION *)p_message)->driver_parameter); return_path = ((T_AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION *)p_message)->return_path; break; case MMI_VM_AMR_RECORD_START_CON: case MMI_VM_AMR_RECORD_STOP_CON: session_id = AUDIO_VM_AMR_RECORD_SESSION_ID; break; case MMI_VM_AMR_PLAY_START_CON: case MMI_VM_AMR_PLAY_STOP_CON: session_id = AUDIO_VM_AMR_PLAY_SESSION_ID; break; #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: session_id = AUDIO_MIDI_SESSION_ID; driver_parameter = &(((T_AUDIO_DRIVER_INIT_MIDI_SESSION *)p_message)->driver_parameter); return_path = ((T_AUDIO_DRIVER_INIT_MIDI_SESSION *)p_message)->return_path; break; case MMI_MIDI_START_CON: case MMI_MIDI_STOP_CON: session_id = AUDIO_MIDI_SESSION_ID; break; #endif } // initialize channel_id to browse all driver channels channel_id = 0; state = AUDIO_DRIVER_CHANNEL_WAIT_INIT; // look for an active session, which session_id matches the one from the message while ( (channel_id < AUDIO_DRIVER_MAX_CHANNEL)&& ((p_audio_gbl_var->audio_driver_session[channel_id].session_info.state == AUDIO_DRIVER_CHANNEL_WAIT_INIT)|| (p_audio_gbl_var->audio_driver_session[channel_id].session_req.session_id != session_id)) ) { channel_id++; } // if channel_id < MAX_CHANNEL, we found an active channel so we can derive channel_id + state if (channel_id < AUDIO_DRIVER_MAX_CHANNEL) { p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); state = p_session->session_info.state; return_path = p_session->session_req.return_path; } } break; // default } switch (state) { case AUDIO_DRIVER_CHANNEL_WAIT_INIT: { switch (p_message->msg_id) { #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: #endif { T_AUDIO_RET result; // Find a free channel channel_id = 0; while ( (p_audio_gbl_var->audio_driver_session[channel_id].session_info.state != AUDIO_DRIVER_CHANNEL_WAIT_INIT) && (channel_id < AUDIO_DRIVER_MAX_CHANNEL) ) channel_id++; if (channel_id == AUDIO_DRIVER_MAX_CHANNEL) { AUDIO_SEND_TRACE("no driver channel available", RV_TRACE_LEVEL_DEBUG_LOW); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); return; } AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER: open channel", channel_id, RV_TRACE_LEVEL_DEBUG_LOW); // get session descriptor and fill REQ parameters p_session = &(p_audio_gbl_var->audio_driver_session[channel_id]); p_session->session_req.session_id = session_id; p_session->session_req.size = driver_parameter->buffer_size << 1;// we request 16-bit words buffers p_session->session_req.nb_buffer = driver_parameter->nb_buffer; // fill return_path parameters, may be used if next message is STOP_SESSION p_session->session_req.return_path.callback_func = return_path.callback_func; p_session->session_req.return_path.addr_id = return_path.addr_id; /************************************************************/ /* the driver must allocate the RAM buffers pointer */ /************************************************************/ mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal, sizeof(T_AUDIO_DRIVER_BUFFER_INFO)*p_session->session_req.nb_buffer, (T_RVF_BUFFER **) (&p_session->session_info.buffer)); // If insufficient resources, then report a memory error and abort. if (mb_status == RVF_RED) { audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); return; } /************************************************************/ /* the driver must allocate the RAM buffers */ /************************************************************/ for (j = 0; j < p_session->session_req.nb_buffer; 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) { UINT8 i; // free already allocated buffers + buffer pointer if (j > 0) { for (i = j - 1; i >= 0; i--) rvf_free_buf((T_RVF_BUFFER *)p_session->session_info.buffer[i].p_start_pointer); } rvf_free_buf((T_RVF_BUFFER *)p_session->session_info.buffer); audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); return; } // initialize parameters p_session->session_info.buffer[j].size = p_session->session_req.size; AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER: allocate buffer", p_session->session_info.buffer[j].p_start_pointer, RV_TRACE_LEVEL_DEBUG_LOW); } // info parameters (state must be changed before driver specific functions call p_session->session_info.index_l1 = 0; p_session->session_info.index_appli = 0; p_session->session_info.stop_request = 0; // conversion of parameters + prepare l1 start message switch(p_message->msg_id) { #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: result=audio_driver_vm_amr_record_manager(p_message,p_session); break; case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: result=audio_driver_vm_amr_play_manager(p_message,p_session); break; #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: result=audio_driver_midi_manager(p_message,p_session); break; #endif } // check L1 msg allocation was successfull if (result != AUDIO_OK) { AUDIO_SEND_TRACE("AUDIO DRIVER MANAGER: L1 msg allocation failed", RV_TRACE_LEVEL_DEBUG_LOW); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); return; } // state (must be changed after driver specific functions calls) p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_START; audio_driver_init_send_status(AUDIO_OK, session_id, channel_id, return_path); } //case AUDIO_DRIVER_INIT_..._SESSION: break; case AUDIO_DRIVER_START_SESSION: audio_driver_error_trace(AUDIO_ERROR_START_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_START_STATUS, channel_id, return_path); break; case AUDIO_DRIVER_STOP_SESSION: audio_driver_error_trace(AUDIO_ERROR_STOP_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_STOP_STATUS, channel_id, return_path); break; case AUDIO_DRIVER_FREE_SESSION: audio_driver_error_trace(AUDIO_ERROR_FREE_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_FREE_STATUS, channel_id, return_path); break; } // switch (p_message->msg_id) } //case AUDIO_DRIVER_CHANNEL_WAIT_INIT: break; case AUDIO_DRIVER_CHANNEL_WAIT_START: { switch (p_message->msg_id) { case AUDIO_DRIVER_START_SESSION: { T_AUDIO_RET result; // fill notification parameters p_session->session_req.return_path.callback_func = return_path.callback_func; p_session->session_req.return_path.addr_id = return_path.addr_id; // send l1 message switch(p_session->session_req.session_id) { #if (L1_VOICE_MEMO_AMR) case AUDIO_VM_AMR_RECORD_SESSION_ID: result=audio_driver_vm_amr_record_manager(p_message,p_session); break; case AUDIO_VM_AMR_PLAY_SESSION_ID: result=audio_driver_vm_amr_play_manager(p_message,p_session); break; #endif #if (L1_MIDI == 1) case AUDIO_MIDI_SESSION_ID: result=audio_driver_midi_manager(p_message,p_session); break; #endif } if (result != AUDIO_OK) { audio_driver_error_trace(AUDIO_ERROR_L1_START_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_START_STATUS, channel_id, return_path); return; } // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_START_CON; } break; case AUDIO_DRIVER_STOP_SESSION: { // deallocate buffers for(j=0; j<p_session->session_req.nb_buffer; j++) { mb_status=rvf_free_buf((T_RVF_BUFFER *)(p_session->session_info.buffer[j].p_start_pointer)); AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER MANAGER: deallocate buffer", j, RV_TRACE_LEVEL_DEBUG_LOW); if (mb_status != RVF_GREEN) AUDIO_SEND_TRACE_PARAM("can't deallocate buffer", j, RV_TRACE_LEVEL_ERROR); } // Deallocate buffers pointer rvf_free_buf((T_RVF_BUFFER *)p_session->session_info.buffer); // deallocate l1 message audio_deallocate_l1_message(p_session->session_req.p_l1_send_message); // send status OK audio_driver_send_status(AUDIO_OK,AUDIO_STOP_STATUS,channel_id,return_path); // change state p_session->session_info.state=AUDIO_DRIVER_CHANNEL_WAIT_INIT; } break; #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: #endif audio_driver_error_trace(AUDIO_ERROR_INIT_EVENT); audio_driver_init_send_status(AUDIO_ERROR, session_id, 0, return_path); break; case AUDIO_DRIVER_FREE_SESSION: audio_driver_error_trace(AUDIO_ERROR_FREE_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_FREE_STATUS, channel_id, return_path); break; } // switch } //case AUDIO_DRIVER_CHANNEL_WAIT_START: break; case AUDIO_DRIVER_CHANNEL_WAIT_START_CON: { switch (p_message->msg_id) { #if (L1_VOICE_MEMO_AMR) case MMI_VM_AMR_RECORD_START_CON: case MMI_VM_AMR_PLAY_START_CON: #endif #if (L1_MIDI == 1) case MMI_MIDI_START_CON: #endif // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_STOP; break; case AUDIO_DRIVER_STOP_SESSION: // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_START_CON_TO_STOP; break; #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: #endif audio_driver_error_trace(AUDIO_ERROR_INIT_EVENT); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); break; case AUDIO_DRIVER_START_SESSION: audio_driver_error_trace(AUDIO_ERROR_START_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_START_STATUS, channel_id, return_path); break; case AUDIO_DRIVER_FREE_SESSION: audio_driver_error_trace(AUDIO_ERROR_FREE_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_FREE_STATUS, channel_id, return_path); break; } // switch } //case AUDIO_DRIVER_CHANNEL_WAIT_START_CON: break; case AUDIO_DRIVER_CHANNEL_WAIT_STOP: { switch (p_message->msg_id) { case AUDIO_DRIVER_STOP_SESSION: { // 1st stop request if (p_session->session_info.stop_request == 0) { T_AUDIO_RET result; // send l1 message STOP_REQ switch(p_session->session_req.session_id) { #if (L1_VOICE_MEMO_AMR) case AUDIO_VM_AMR_RECORD_SESSION_ID: result=audio_driver_vm_amr_record_manager(p_message,p_session); break; case AUDIO_VM_AMR_PLAY_SESSION_ID: result=audio_driver_vm_amr_play_manager(p_message,p_session); break; #endif #if (L1_MIDI == 1) case AUDIO_MIDI_SESSION_ID: result=audio_driver_midi_manager(p_message,p_session); break; #endif } // allocate or send L1 msg went wrong if (result != AUDIO_OK) { audio_driver_error_trace(AUDIO_ERROR_L1_STOP_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_STOP_STATUS, channel_id, return_path); return; } // STOP has been requested, no longer accept it p_session->session_info.stop_request = 1; } else { audio_driver_error_trace(AUDIO_ERROR_STOP_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_STOP_STATUS, channel_id, return_path); } } break; #if (L1_VOICE_MEMO_AMR) case MMI_VM_AMR_RECORD_STOP_CON: { // send last notification T_AUDIO_DRIVER_LAST_NOTIFICATION *p_status_message; // Allocate the Riviera buffer mb_status = RVF_RED; while (mb_status == RVF_RED) { mb_status = rvf_get_buf (p_audio_gbl_var->mb_internal, sizeof (T_AUDIO_DRIVER_LAST_NOTIFICATION), (T_RVF_BUFFER **) (&p_status_message)); // If insufficient resources, then report a memory error and abort. if (mb_status == RVF_RED) { // the memory is insufficient to continue the non regression test audio_driver_error_trace(AUDIO_ENTITY_NO_MEMORY); rvf_delay(RVF_MS_TO_TICKS(1000)); } } // Fill the message ID p_status_message->header.msg_id = AUDIO_DRIVER_LAST_NOTIFICATION_MSG; // fill parameters p_status_message->channel_id = channel_id; p_status_message->recorded_size = ((T_MMI_VM_AMR_RECORD_CON *)p_message)->recorded_size - SC_VM_AMR_END_MASK_SIZE; p_status_message->p_buffer = (UINT16 *)p_session->session_info.buffer[p_session->session_info.index_l1].p_start_pointer; if (return_path.callback_func == NULL) rvf_send_msg (return_path.addr_id, p_status_message); else { // call the callback function (*(return_path.callback_func))((void *)(p_status_message)); rvf_free_buf((T_RVF_BUFFER *)p_status_message); } // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_FREE; } break; #endif // #if (L1_VOICE_MEMO_AMR) #if (L1_VOICE_MEMO_AMR) case MMI_VM_AMR_PLAY_STOP_CON: #endif #if (L1_MIDI == 1) case MMI_MIDI_STOP_CON: #endif { // deallocate buffers for (j = 0; j < p_session->session_req.nb_buffer; j++) { mb_status = rvf_free_buf ((T_RVF_BUFFER *) (p_session->session_info.buffer[j].p_start_pointer)); AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER MANAGER: deallocate buffer", j, RV_TRACE_LEVEL_DEBUG_LOW); if (mb_status != RVF_GREEN) AUDIO_SEND_TRACE_PARAM("can't deallocate buffer", j, RV_TRACE_LEVEL_ERROR); } // Deallocate buffers pointer rvf_free_buf((T_RVF_BUFFER *)p_session->session_info.buffer); audio_driver_send_status (AUDIO_OK, AUDIO_STOP_STATUS, channel_id, return_path); // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_INIT; } break; #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: #endif audio_driver_error_trace(AUDIO_ERROR_INIT_EVENT); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); break; case AUDIO_DRIVER_START_SESSION: audio_driver_error_trace(AUDIO_ERROR_START_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_START_STATUS, channel_id, return_path); break; case AUDIO_DRIVER_FREE_SESSION: audio_driver_error_trace(AUDIO_ERROR_FREE_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_FREE_STATUS, channel_id, return_path); break; } //switch } //case AUDIO_DRIVER_CHANNEL_WAIT_STOP: break; case AUDIO_DRIVER_CHANNEL_WAIT_START_CON_TO_STOP: { T_AUDIO_RET result = AUDIO_OK; switch (p_message->msg_id) { #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: #endif audio_driver_error_trace(AUDIO_ERROR_INIT_EVENT); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); return; break; case AUDIO_DRIVER_START_SESSION: audio_driver_error_trace(AUDIO_ERROR_START_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_START_STATUS, channel_id, return_path); return; break; case AUDIO_DRIVER_STOP_SESSION: audio_driver_error_trace(AUDIO_ERROR_STOP_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_STOP_STATUS, channel_id, return_path); return; break; case AUDIO_DRIVER_FREE_SESSION: audio_driver_error_trace(AUDIO_ERROR_FREE_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_FREE_STATUS, channel_id, return_path); return; break; #if (L1_VOICE_MEMO_AMR) case MMI_VM_AMR_RECORD_START_CON: // send L1 stop msg result=audio_driver_vm_amr_record_manager(p_message, p_session); break; case MMI_VM_AMR_PLAY_START_CON: // send L1 stop msg result=audio_driver_vm_amr_play_manager(p_message, p_session); break; #endif #if (L1_MIDI == 1) case MMI_MIDI_START_CON: // send L1 stop msg result=audio_driver_midi_manager(p_message,p_session); break; #endif } if (result != AUDIO_OK) { audio_driver_send_status(AUDIO_ERROR, AUDIO_STOP_STATUS, channel_id, return_path); return; } else { // next state should be WAIT_STOP_CON, which is WAIT_STOP + stop_request == 1 p_session->session_info.stop_request = 1; // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_STOP; } } break; case AUDIO_DRIVER_CHANNEL_WAIT_FREE: { switch (p_message->msg_id) { case AUDIO_DRIVER_FREE_SESSION: { // deallocate buffers for (j = 0; j < p_session->session_req.nb_buffer; j++) { mb_status = rvf_free_buf ((T_RVF_BUFFER *) (p_session->session_info.buffer[j].p_start_pointer)); AUDIO_SEND_TRACE_PARAM("AUDIO DRIVER MANAGER: deallocate buffer", j, RV_TRACE_LEVEL_DEBUG_LOW); if (mb_status != RVF_GREEN) AUDIO_SEND_TRACE_PARAM("can't deallocate buffer", j, RV_TRACE_LEVEL_ERROR); } // Deallocate buffers pointer rvf_free_buf((T_RVF_BUFFER *)p_session->session_info.buffer); audio_driver_send_status (AUDIO_OK, AUDIO_FREE_STATUS, channel_id, return_path); // change state p_session->session_info.state = AUDIO_DRIVER_CHANNEL_WAIT_INIT; } break; #if (L1_VOICE_MEMO_AMR) case AUDIO_DRIVER_INIT_VM_AMR_RECORD_SESSION: case AUDIO_DRIVER_INIT_VM_AMR_PLAY_SESSION: #endif #if (L1_MIDI == 1) case AUDIO_DRIVER_INIT_MIDI_SESSION: #endif audio_driver_error_trace(AUDIO_ERROR_INIT_EVENT); audio_driver_init_send_status(AUDIO_ERROR, session_id, channel_id, return_path); break; case AUDIO_DRIVER_START_SESSION: audio_driver_error_trace(AUDIO_ERROR_START_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_START_STATUS, channel_id, return_path); break; case AUDIO_DRIVER_STOP_SESSION: audio_driver_error_trace(AUDIO_ERROR_STOP_EVENT); audio_driver_send_status(AUDIO_ERROR, AUDIO_STOP_STATUS, channel_id, return_path); break; } // switch } break; } } #endif // (L1_AUDIO_DRIVER) #endif // #ifdef RVM_AUDIO_MAIN_SWE