# HG changeset patch # User Mychaela Falconia # Date 1489376106 0 # Node ID dab163da789ada2efd2dfc1dfe738d04945b6684 # Parent 539abdacabf0a7e95ea18cd3aa9dc87684003b74 l1audio_back.c: initial import from LoCosto source diff -r 539abdacabf0 -r dab163da789a chipsetsw/layer1/audio_cfile/l1audio_back.c --- a/chipsetsw/layer1/audio_cfile/l1audio_back.c Mon Mar 13 03:29:52 2017 +0000 +++ b/chipsetsw/layer1/audio_cfile/l1audio_back.c Mon Mar 13 03:35:06 2017 +0000 @@ -1,1 +1,609 @@ -/* dummy C source file */ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1AUDIO_SRBACK.C + * + * Filename l1audio_back.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +/************************************/ +/* Include files... */ +/************************************/ + +#define L1_SRBACK_COM // switch to define the l1_srback_com variable +#define L1_AUDIOBACK_MELODYE2 // switch to define the audio background variable + +#include "l1_macro.h" +#include "l1_confg.h" + +#if (AUDIO_TASK == 1) && (L1_AUDIO_BACKGROUND_TASK) + + #include "l1_types.h" + #include "sys_types.h" + + #if (CODE_VERSION == SIMULATION) && (AUDIO_SIMULATION) + + + #include + #include + + #include "iq.h" // Debug / Init hardware ("eva3.lib") + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added form e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added form e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "l1_ctl.h" + + + #include "l1_time.h" + #include "l1_scen.h" + + #else + // Layer1 and debug include files. + + #include + #include + #include "l1_ver.h" + #include "l1_const.h" + #include "l1_signa.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_signa.h" + #include "l1audio_defty.h" + #include "l1audio_msgty.h" + #include "l1audio_varex.h" + + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif +//added form e-sample for AAC + #if (L1_DYN_DSP_DWNLD == 1) + #include "l1_dyn_dwl_const.h" + #include "l1_dyn_dwl_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif +//added form e-sample for AAC + #if (L1_AAC == 1) + #include "l1aac_defty.h" + #endif + + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "tpudrv.h" // TPU drivers. ("eva3.lib") + #include "l1_varex.h" + + #include "l1_proto.h" + #include "l1_mftab.h" + #include "l1_tabs.h" + #include "mem.h" + #include "armio.h" + #include "timer.h" + #include "timer1.h" + #include "dma.h" + #include "inth.h" + #include "ulpd.h" + #include "rhea_arm.h" + #include "clkm.h" // Clockm ("eva3.lib") + #include "l1_ctl.h" + + #include "l1_time.h" + #if L2_L3_SIMUL + #include "l1_scen.h" + #endif + #endif + + /****************************************/ + /* Prototypes for audio background task */ + /****************************************/ + void l1_audio_background_task (UWORD32 argc, void *argv); + #if (SPEECH_RECO) + void srback_CTO_algorithm (API *RAM_address); + void srback_save_model_temp (API *RAM_address_input, UWORD16 *RAM_address_output); + #endif + #if (MELODY_E2 && FIR) + void audio_background_melody_e2_download_instrument_manager(xSignalHeaderRec *msg); + #endif + /**************************************/ + /* External prototypes */ + /**************************************/ + #if (SPEECH_RECO) + extern void Cust_srback_save_model (UWORD8 database, UWORD8 index, API *RAM_address); + extern void Cust_srback_save_speech (UWORD8 database, UWORD8 index, UWORD16 *start_buffer, UWORD16 *stop_buffer, UWORD16 *start_speech, UWORD16 *stop_speech); + extern void Cust_srback_load_model (UWORD8 database, UWORD8 index, API *RAM_address); + #endif + #if (MELODY_E2 && FIR) + extern UWORD16 Cust_audio_melody_E2_load_instrument (UWORD8 customer_instrument_id, + API *API_address, + UWORD16 allowed_size); + #endif + +#if (OP_RIV_AUDIO == 0) + /*--------------------------------------------------------*/ + /* l1_audio_background_task() */ + /*--------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is a state machine which handles the */ + /* audio background feature. */ + /* */ + /* Starting messages: L1_SRBACK_SAVE_DATA_REQ */ + /* L1_SRBACK_TEMP_SAVE_DATA_REQ */ + /* L1_SRBACK_LOAD_MODEL_REQ */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): L1_SRBACK_SAVE_DATA_CON */ + /* L1_SRBACK_TEMP_SAVE_DATA_CON */ + /* L1_SRBACK_LOAD_MODEL_CON */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): non */ + /* */ + /* Stop message (output): L1_SRBACK_SAVE_DATA_CON */ + /* L1_SRBACK_TEMP_SAVE_DATA_CON */ + /* L1_SRBACK_LOAD_MODEL_CON */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Rem: to stop immeditly the speech reco feature a flag */ + /* ---- is created: l1_srback_com.emergency_stop */ + /* */ + /*--------------------------------------------------------*/ + void l1_audio_background_task(UWORD32 argc, void *argv) + { + xSignalHeaderRec *receive_msg, *confirm_msg; + UWORD8 index; + + while(1) + { + // Wait until a message is receive + receive_msg = os_receive_sig(SRBACK_QUEUE); + + #if (SPEECH_RECO) + if (receive_msg->SignalCode == L1_SRBACK_SAVE_DATA_REQ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the customer function to save the model + Cust_srback_save_model( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + if ( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->speech ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the customer function to save the speech from a circular buffer to the database + Cust_srback_save_speech( ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->start_buffer, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->stop_buffer, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->start_address, + ((T_L1_SRBACK_SAVE_DATA_REQ *)(receive_msg->SigP))->stop_address); + } + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_SAVE_DATA_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_SAVE_DATA_REQ + else + if (receive_msg->SignalCode == L1_SRBACK_LOAD_MODEL_REQ) + { + if ( ( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->CTO_enable ) == FALSE ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to load a model + Cust_srback_load_model( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->database_id, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + } + else + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Calculate the good index + index = ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index>>1; + + // Call the function to load a model with the good index + Cust_srback_load_model( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->database_id, + index, + ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + + // The CTO algorithm is used and the model index is odd + if ( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_index & 0x01 ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to apply the CTO algorithm to the loaded model + srback_CTO_algorithm( ((T_L1_SRBACK_LOAD_MODEL_REQ *)(receive_msg->SigP))->model_RAM_address ); + } + } + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_LOAD_MODEL_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_LOAD_MODEL_REQ + else + if (receive_msg->SignalCode == L1_SRBACK_TEMP_SAVE_DATA_REQ) + { + if (l1_srback_com.emergency_stop == FALSE) + { + // Call the function to save the model in a temporary buffer + srback_save_model_temp( ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address_input, + ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(receive_msg->SigP))->model_RAM_address_output ); + } + + // Send the stop confirmation message + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + confirm_msg->SignalCode = L1_SRBACK_TEMP_SAVE_DATA_CON; + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } // L1_SRBACK_TEMP_SAVE_DATA_REQ + #endif // SPEECH_RECO + #if (MELODY_E2 && FIR) + if ( (receive_msg->SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ) || + (receive_msg->SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) ) + { + audio_background_melody_e2_download_instrument_manager(receive_msg); + } // L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ + #endif // MELODY_E2 + + // Deallocate the received message + os_free_sig(receive_msg); + DEBUGMSG(status,NU_ALLOC_ERR) + } // while(1) + } +#endif // OP_RIV_AUDIO + + #if (SPEECH_RECO) + /*-------------------------------------------------------*/ + /* srback_CTO_algorithm() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : RAM_address */ + /* */ + /* Return : none */ + /* */ + /* Description : apply the CTO algorithm to the model. */ + /* */ + /*-------------------------------------------------------*/ + void srback_CTO_algorithm (API *RAM_address) + { + UWORD16 model_size, frame; + UWORD8 frame_size; + + // This alogrithm changes the model: + // |frame 0|frame 1|frame 2|frame 3|frame 4|frame 5|frame 6|frame 7|... + // into a garbage model: + // |0000000|frame 1|0000000|0000000|frame 4|0000000|0000000|frame 7|... + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address++; + + frame = 0; + + while( (frame <= model_size) && + (l1_srback_com.emergency_stop == FALSE) ) + { + if ((frame % 3) == 1) + { + // This frame is kept + RAM_address += SC_SR_MODEL_FRAME_SIZE; + } + else + { + // This frame is set to 0 + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address++ = 0; + frame_size--; + } + } + + frame++; + } + } + + /*-------------------------------------------------------*/ + /* srback_CTO_algorithm() */ + /*-------------------------------------------------------*/ + /* */ + /* Parameters : RAM_address_input */ + /* RAM_address_output */ + /* */ + /* Return : none */ + /* */ + /* Description : apply the CTO algorithm to the model. */ + /* */ + /*-------------------------------------------------------*/ + void srback_save_model_temp (API *RAM_address_input, UWORD16 *RAM_address_output) + { + UWORD16 model_size; + UWORD8 frame_size; + + // look the size of the model in model frame unit (16 words unit) + model_size = *RAM_address_input; + + // save the header of the model + *RAM_address_output++ = *RAM_address_input++; + + while( (model_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + frame_size = SC_SR_MODEL_FRAME_SIZE; + while ( (frame_size != 0) && + (l1_srback_com.emergency_stop == FALSE) ) + { + *RAM_address_output++ = *RAM_address_input++; + frame_size--; + } + model_size--; + } + } + #endif // SPEECH_RECO + +#if (OP_RIV_AUDIO == 0) + #if (MELODY_E2 && FIR) + /*--------------------------------------------------------*/ + /*audio_background_melody_e2_download_instrument_manager()*/ + /*--------------------------------------------------------*/ + /* */ + /* Description: */ + /* ------------ */ + /* This function is used to load/unload the instrument of */ + /* the melodies E2. */ + /* */ + /* Starting messages: */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ */ + /* */ + /* Result messages (input): none */ + /* */ + /* Result messages (output): */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Reset messages (input): none */ + /* */ + /* Stop message (input): none. */ + /* */ + /* Stop message (output): */ + /* L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON */ + /* L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON */ + /* */ + /* Rem: to stop immediatly the instrument download flags */ + /* ---- is created: */ + /* l1a_l1s_com.melody0_e2_task.parameters.emergency_stop */ + /* l1a_l1s_com.melody1_e2_task.parameters.emergency_stop */ + /* */ + /*--------------------------------------------------------*/ + void audio_background_melody_e2_download_instrument_manager(xSignalHeaderRec *msg) + { + xSignalHeaderRec *confirm_msg; + UWORD8 instrument_number, max_number_of_instrument, instrument_id, id; + UWORD16 size; + UWORD32 address; + + if (msg->SignalCode == L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ) + { + // Load the instrument + + // Init the first address + address = ( ((UWORD32)(l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_wave)) + - SC_AUDIO_MCU_API_BEGIN_ADDRESS ); + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[0] = + (API)( (address>>1) + SC_AUDIO_DSP_API_BEGIN_ADDRESS ); + + // Download the instrument + max_number_of_instrument = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument; + for(instrument_number=0; instrument_number < max_number_of_instrument ; instrument_number++) + { + // No instrument was previously download + if (audioback_melody_e2.number_of_user[instrument_number] == 0) + { + // load the insturment ID + instrument_id = + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[instrument_number]; + + // Find if this instrument was already downloaded + id = 0; + while ( (id < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT) && + ((instrument_id != audioback_melody_e2.instrument_id[id]) || + (audioback_melody_e2.number_of_user[id] == 0)) ) + { + id++; + } + + if (id < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT) + { + // This insturment was already downloaded + // copy the address of this instrument + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[instrument_number] = + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[id]; + + // The size of this instrument is 0 + audioback_melody_e2.instrument_size[instrument_number] = 0; + } + else + { + // Load the customer instrument + size = Cust_audio_melody_E2_load_instrument ( + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[instrument_number], + audioback_melody_e2.API_address, + audioback_melody_e2.allowed_size); + + // Added to stop the L1 in case of download error + if (size == 0) + { + // Send a message to stop the L1 + /* send the stop command to the audio L1 */ + /* allocate the buffer for the message to the L1 */ + confirm_msg = os_alloc_sig(0); + DEBUGMSG(status,NU_ALLOC_ERR) + + if (confirm_msg != NULL) + { + /* send the stop command to the audio L1 */ + if ( ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(confirm_msg->SigP))->melody_id == 0) + { + confirm_msg->SignalCode = MMI_MELODY0_E2_STOP_REQ; + } + else + { + confirm_msg->SignalCode = MMI_MELODY1_E2_STOP_REQ; + } + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + + // Save the size of this instrument + audioback_melody_e2.instrument_size[instrument_number] = size; + } + + // Update the Cust_audio_melody_E2_load_instrument argument + audioback_melody_e2.API_address += audioback_melody_e2.instrument_size[instrument_number]; + audioback_melody_e2.allowed_size -= audioback_melody_e2.instrument_size[instrument_number]; + + // Put the DSP address to the NDB API for the next instrument + if (instrument_number < SC_AUDIO_MELODY_E2_MAX_NUMBER_OF_INSTRUMENT-1) + { + address = ( ((UWORD32)(audioback_melody_e2.API_address)) + - SC_AUDIO_MCU_API_BEGIN_ADDRESS ); + + l1s_dsp_com.dsp_ndb_ptr->a_melody_e2_instrument_ptr[instrument_number + 1] = + (API)( (address>>1) + SC_AUDIO_DSP_API_BEGIN_ADDRESS ); + } + + // Save the instrument ID + audioback_melody_e2.instrument_id[instrument_number] = instrument_id; + } + + // Increase the number of user of this instrument number + audioback_melody_e2.number_of_user[instrument_number]++; + } + + // Send the load confirmation message + confirm_msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill the parameter + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON *)(confirm_msg->SigP))->melody_id = + ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id; + + confirm_msg->SignalCode = L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON; + + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + else + if (msg->SignalCode == L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ) + { + // Unload the instrument + max_number_of_instrument = ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument; + for(instrument_number = max_number_of_instrument; instrument_number > 0 ; instrument_number--) + { + // Decrease the number of user of this instrument number + audioback_melody_e2.number_of_user[instrument_number-1]--; + + // Check if the instrument must be removed + if (audioback_melody_e2.number_of_user[instrument_number-1] == 0) + { + // Increase the size and decrease the pointer to the API with the size + // of the removed instrument + // Update the Cust_audio_melody_E2_load_instrument argument + audioback_melody_e2.API_address -= audioback_melody_e2.instrument_size[instrument_number-1]; + audioback_melody_e2.allowed_size += audioback_melody_e2.instrument_size[instrument_number-1]; + } + } + + // Send the unload confirmation message + confirm_msg = os_alloc_sig(sizeof(T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON)); + DEBUGMSG(status,NU_ALLOC_ERR) + + // Fill the paramter + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON *)(confirm_msg->SigP))->melody_id = + ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id; + + confirm_msg->SignalCode = L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON; + + os_send_sig(confirm_msg, L1C1_QUEUE); + DEBUGMSG(status,NU_SEND_QUEUE_ERR) + } + } + #endif // MELODY_E2 +#endif // OP_RIV_AUDIO +#endif // AUDIO_TASK == 1 && L1_AUDIO_BACKGROUND_TASK